贪心算法解决活动安排问题

实验二：贪心算法【实验目的】应用贪心算法求解活动安排问题。

【实验性质】验证性实验。

【实验要求】活动安排问题是可以用贪心算法有效求解的很好的例子。

问题：有n个活动的集合A={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。

求解：安排尽量多项活动在该场地进行，即求A的最大相容子集。

设待安排的11个活动的开始时间和结束时间按结束时间的升序排列如下：将此表数据作为实现该算法的测试数据。

【算法分析】分析：每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。

如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。

若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。

也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。

例：给出待安排的11个活动的开始时间和结束时间，要求安排尽量多项活动使用会场。

首先，任意输入这11个活动。

然后对活动以其完成时间的非减序排列。

（意义：使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

）将第一次活动结束时间f[1]与后面活动开始时间s[2]相比较，若s[2]<f[1]则继续比较，直到s[4]>f[1]，选中此活动。

再用活动4的结束时间f[4]与其后活动的开始时间比较……同理类推，直到比较完成为止，最后选出合条件的活动1，活动4，活动8和活动11，它们将依次被安排使用该场地。

【调试分析和心得体会】运行依算法写出的程序并分析算法实现的时间复杂度情况。

1.程序源码：#include <iostream>using namespace std;class B{int dataT[11],dataF[11]; //使用两个数组一个放开始时间，一个放结束时间public :void cinP();//用户输入，获得数据void paiXu();//排序void dispaly();//输出排序后的数据void last();//使用贪心算法后得得到的结果};void B::cinP(){for(int i=0;i<11;i++){cout<<"请输入开始时间："<<endl;cin>>dataT[i];cout<<"请输入结束时间："<<endl;cin>>dataF[i];}}void B::paiXu(){int munT=0;//实现数据交换的一个中间量int numF=0;//实现数据交换的一个中间量for(int r=0;r<11;r++){for(int j=r+1;j<11;j++){if(dataF[r]>dataF[j]){//对结束时间排序，同时同步改变与之对应的开始时间//保持开始时间和结束时间配套numF=dataF[j];dataF[j]=dataF[r];dataF[r]=numF;//交换结束时间munT=dataT[j];dataT[j]=dataT[r];dataT[r]=munT;//交换开始时间}}}}void B::dispaly(){for(int y=0;y<11;y++){cout<<dataT[y]<<"\t";}cout<<endl;for(int y1=0;y1<11;y1++){cout<<dataF[y1]<<"\t";}void B::last(){int dataQ[11],dataH[11];int g=0;dataQ[0]=dataT[0];dataH[0]=dataF[0];//将一个节目结束时间和另一个节目开始时间进行对比//将符合条件的节目的开始时间和结束时间分别保存在数组，dataQ和dataH中for(int w=1;w<11;w++){if(dataH[g]<=dataT[w]){g++;dataQ[g]=dataT[w];dataH[g]=dataF[w];}}cout<<endl<<endl;for(int ye=0;ye<=g;ye++){cout<<dataQ[ye]<<"\t";}cout<<endl;for(int y1e=0;y1e<=g;y1e++){cout<<dataH[y1e]<<"\t";}}int main(int argc, char** argv) {B b;b.cinP();b.paiXu();b.dispaly();st();return 0;}2.运行结果：3.时间复杂度分析：本程序运用的核心数据结构是数组，由于存在两层for循环因此分析得出时间复杂度为：。

贪⼼算法（4）：活动选择问题我们继续回到上⼀堂课留下的课外习题：活动选择问题。

活动选择问题是很常见的场景。

例如各个部门共享⼀个会议室，利⽤该算法能使会议室安排尽量多的会议。

【问题】给你n个活动的开始时间和结束时间，从中选择你可以参与的活动，但是同⼀时间你只能参与⼀个活动，请找出你可以参与的最多活动数。

例如：考虑下⾯3个活动a1,a2和a3, 它们{开始时间点,结束时间点}分别为：a1 {start=10,finish=20}a2 {start=12,finish=25}a3 {start=20,finish=30}贪⼼算法直接在每⼀步选择当前看来最好的选择。

在开始时，选择活动结束时间最早的那个活动，这样能够给其他活动尽可能的腾出多余的时间。

⽽后每⼀步都在剩下的活动中选取，也遵循类似的原则。

由于获取已经按照结束时间排序好，所以这⾥第⼀个选择的活动就是a0，由于a0于时间20结束，马上再找⼀个活动，只有a2可以选择，a2结束之后再也没有活动可选了。

因此得到答案：最多可以参加两个活动（a0,a2）。

算法分析和设计现在请你设计⼀种贪⼼算法解决类似活动选择问题。

我们设计下列贪⼼算法的贪⼼策略：选择其余活动中完成时间最短的下⼀个活动，并且开始时间⼤于或等于先前所选活动的结束时间。

我们可以根据他们的完成时间对活动进⾏排序，以便我们始终将下⼀个活动视为最⼩完成时间活动。

算法描述如下{k}}U{1}，必定仍然是⼀个最佳解决⽅案，说明如下：因为S 中的活动是独⽴的，⽽在排序队列中，【活动1】在所有活动中具有最⼩的结束时间，因为k不等于1，【活动k】的完成时间必定是⼤于等与【活动1】的完成时间，因此把【活动k】换成【活动1】后的新⽅案S‘必定也是最佳解决⽅案。

算法实现在以下C/C++代码实现中，假设活动已根据其完成时间进⾏了排序。

#include<stdio.h>// n --> 活动个数// s[] --> 数组保存所有活动的开始时间// f[] --> 数组保存所有活动的结束时间void printMaxActivities(int s[], int f[], int n){int i, j;printf ('选择以下的活动\n');// 第⼀个活动总是选中i = 0;printf('%d ', i);// 依次检查余下的活动for (j = 1; j < n; j++){//如果某活动在之前选择的活动结束之后开始if (s[j] >= f[i]){printf ('%d ', j);i = j;}}}//主程序int main(){int s[] = {1, 3, 0, 5, 8, 5};int f[] = {2, 4, 6, 7, 9, 9};int n = sizeof(s)/sizeof(s[0]);printMaxActivities(s, f, n);return 0;}注意：若是finish数组没有排序，需要先对它进⾏排序。

贪⼼算法（会场安排问题、区间选点）学习算法课程之后的第⼀次记录，渐渐的，程序设计考虑的因素增多，程序=数据结构+算法，这个等式让我深有体会。

从开始简单的C++编程，再到选择合适数据结构，现在需要更进⼀步，从算法层次上考虑程序执⾏的效率。

我对算法的理解是⽤更少的开销获得更优的执⾏效果。

分治法、动态规划在此之前没有记录下来，学到贪⼼算法的时候，觉得需要总结⼀下学过的东西，也能更好的理解。

动态规划的设计，要满⾜最优⼦结构性质和重叠⼦问题，采⽤⾃底向上的策略，计算出最优值，找到整体最优解。

这个过程有时候挺难的，主要在写出递归式，要⾃底向上填表。

贪⼼策略有点像动态规划，但在⼀些⽅⾯是不同的，有时候贪⼼算法的思想更容易想到。

它要满⾜⼦问题最优⽽得到整体最优？两个条件：最优⼦结构性质和贪⼼选择性质。

满⾜贪⼼选择性质⼀定满⾜最优⼦结构性质，⽽满⾜最优⼦结构性质不⼀定满⾜贪⼼选择性质，⽐如背包问题可以⽤贪⼼算法解决，⽽0-1背包问题只能⽤动态规划。

典型的贪⼼问题活动安排，有n个活动，给出开始时间和结束时间，要尽可能安排多的活动（时间互相不冲突）。

解决这个问题正确的贪⼼思想是以每个活动结束时间为⽐较变量，按结束时间升序排好活动次序，接着就进⾏⽐较选择。

⽽会场安排问题与活动⼜有些不同之处，下⾯是我的解题过程。

7-2 会场安排问题 (20 分)假设要在⾜够多的会场⾥安排⼀批活动，并希望使⽤尽可能少的会场。

设计⼀个有效的贪⼼算法进⾏安排。

（这个问题实际上是著名的图着⾊问题。

若将每⼀个活动作为图的⼀个顶点，不相容活动间⽤边相连。

使相邻顶点着有不同颜⾊的最⼩着⾊数，相应于要找的最⼩会场数。

）输⼊格式:第⼀⾏有 1 个正整数k，表⽰有 k个待安排的活动。

接下来的 k⾏中，每⾏有 2个正整数，分别表⽰ k个待安排的活动开始时间和结束时间。

时间以 0 点开始的分钟计。

输出格式:输出最少会场数。

输⼊样例:51 2312 2825 3527 8036 50输出样例:3#include<iostream>#include<algorithm>using namespace std;struct node {int begin;int end;int flag;//标记该活动是否被安排，0表⽰未安排，1表⽰已安排}t[10001];int cmp(const node &a,const node &b)//⽐较规则：以结束时间升序排列{return a.end<b.end;}int main(){int i,j,n;node temp;cin>>n;for(i=0;i<n;i++){cin>>t[i].begin>>t[i].end;t[i].flag=0;}sort(t,t+n,cmp);int sum=0;//总共需要的会场数量for(i=0;i<n;i++)//⽅法2{if(!t[i].flag)//找到未安排的活动，进⾏场地安排{sum++;int p=i;for(j=p+1;j<n;j++)//当前活动结束时间与下⼀个活动开始不相交，则安排到同⼀个会场{if(t[p].end<=t[j].begin&&!t[j].flag){p=j;t[j].flag=1;}}t[i].flag=1;}}cout<<sum;return0;}View Code贪⼼策略为：把尽可能多的时间互不冲突的活动安排到⼀个会场，若活动时间交叉，则在安排到另⼀个会场。

算法分析与设计实验二贪心算法实验二：贪心算法【实验目的】应用贪心算法求解活动安排问题。

【实验性质】验证性实验。

【实验要求】活动安排问题是可以用贪心算法有效求解的很好的例子。

问题：有n个活动的集合A={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。

求解：安排尽量多项活动在该场地进行，即求A的最大相容子集。

设待安排的11个活动的开始时间和结束时间按结束时间的升序排列如下： i 1 2 35 3 06 4 57 5 38 6 59 7 6 10 8 8 11 9 8 12 10 2 13 11 12 14 s[i] 1 f[i] 4将此表数据作为实现该算法的测试数据。

【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】附加题：【实验要求】需要在某个城市的n个居民区之间铺设煤气管道，则在这n个居民区之间只要铺设n-1条管道即可。

假设任意两个居民区之间都可以架设管道，但由于地理环境的不同，所需经费不同。

选择最优的施工方案能使总投资尽可能少，这个问题即为求网的“最小生成树”问题。

参照以下居民区示意图，使得求解算法为：在可能架设的m条管道中选取n-1条，既能连通n-1个居民区，有使总投资达到“最小”。

网可采用邻接矩阵为存储结构，以定点对（i,j）的形式输出最小生成树的边。

D 23.1 675.9 C 41.1 56B A 38.2 441218.2 I 8.7 H 52.5 G 10.5E 98.7 居民区示意图 85F 79应用贪心算法策略，采用普里姆算法或Kruskal算法来求解居民区示意图的最小生成树，采用合适的数据结构。

用C语言或C++语言编写程序代码，选上述居民区示意图中的数据作为测试数据。

并调试输出正确结果。

【算法思想及采用的数据结构】【程序代码】【运行结果】【算法分析和心得体会】感谢您的阅读，祝您生活愉快。

c++贪心算法经典例题和详解贪心算法（Greedy Algorithm）是一种优化问题解决方法，其基本思想是每一步都选择当前状态下的最优解，以期望达到全局最优解。

贪心算法的特点是每一步都要做出一个局部最优的选择，而这些局部最优选择最终构成了全局最优解。

下面是一个经典的贪心算法例题以及详解：例题：活动选择问题（Activity Selection Problem）假设有一个需要在同一时段使用同一个资源的活动集合，每个活动都有一个开始时间和结束时间。

设计一个算法，使得能够安排最多数量的互不相交的活动。

# 输入：-活动的开始时间数组`start[]`。

-活动的结束时间数组`end[]`。

# 输出：-选择的互不相交的活动的最大数量。

# 算法详解：1. 首先，将活动按照结束时间从小到大排序。

2. 选择第一个活动，并将其加入最终选择的集合中。

3. 对于剩下的活动，选择下一个结束时间最早且与前一个活动不冲突的活动。

4. 重复步骤3，直到所有活动都被选择。

```cpp#include <iostream>#include <algorithm>#include <vector>using namespace std;// 定义活动结构体struct Activity {int start, end;};// 比较函数，用于排序bool compareActivities(Activity a, Activity b) {return a.end < b.end;}// 贪心算法解决活动选择问题void activitySelection(vector<Activity>& activities) {// 按照结束时间排序sort(activities.begin(), activities.end(), compareActivities);// 第一个活动总是被选中cout << "Selected activity: (" << activities[0].start << ", " << activities[0].end << ")" << endl;// 选择其余活动int lastSelected = 0;for (int i = 1; i < activities.size(); i++) {// 如果当前活动的开始时间大于等于上一个选择的活动的结束时间，则选择该活动if (activities[i].start >= activities[lastSelected].end) {cout << "Selected activity: (" << activities[i].start << ", " << activities[i].end << ")" << endl;lastSelected = i;}}}int main() {vector<Activity> activities = {{1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}, {5, 9}};cout << "Activities before sorting:" << endl;for (const Activity& activity : activities) {cout << "(" << activity.start << ", " << activity.end << ") ";}cout << endl;activitySelection(activities);return 0;}```在这个例子中，我们首先定义了一个活动的结构体`Activity`，然后编写了一个比较函数`compareActivities` 用于排序。

贪心算法解决活动安排问题研究摘要：利用贪心算法解决如何使用最少的资源安排一系列活动。

并证明了贪心算法解决此问题的有效性，且进行了实例验证，并进行了复杂度分析，此算法是解决资源组合规划问题较好的方法。

关键词：贪心算法；java程序；复杂度分析；活动安排问题中图分类号：tp312文献标识码：a文章编号：16727800（2011）012004302基金项目：广西研究生教育创新计划（22m58）作者简介：苏方方（1986-），女，河南商丘人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为自然语言处理和算法；张金玲（1986-），女，山东菏泽人，广西师范大学计算机科学与信息工程学院硕士研究生，研究方向为远程教育和算法。

0引言假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。

这里就需要选用合适的算法来解决类似的问题。

虽然计算机的计算能力每年都在飞快增加，但是，需要处理的信息量更是呈指数级的增长。

互联网的信息流量在飞快进步，数据量更是达到了前所未有的程度。

无论是三维图形，海量数据处理等都需要极大的计算量。

在网络时代，越来越多的挑战需要靠卓越的算法来解决。

1贪心算法以及贪心算法的基本要素贪心算法是指从问题的初始状态出发，通过若干次的贪心选择而得出最优值(或较优解)的一种解题方法。

并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解。

贪心算法可以简单描述为：对一组数据进行排序，找出最小值，进行处理，再找出最小值，再处理。

也就是说贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，从而希望得到结果是最好或最优的算法。

贪心算法解题步骤：①从问题的某个初始解出发；②采用循环语句，就根据局部最优策略，得到一个部分解，缩小问题的范围或规模；③将所有部分解综合起来，得到问题的最终解。

另外它也是一种某种度量意义下的最优解的分级处理方法。

对于一个具体的问题，怎么知道是否可用贪心算法来解决问题，以及能否得到问题的一个最优解呢？从许多可以用贪心算法求解的问题中可以看到它们一般具有两个重要的性质：①贪心选择性质；②最优子结构性质。

活动安排算法有多种不同的方法，具体使用哪种方法取决于活动的性质和约束条件。

以下是几种常见的活动安排算法：贪心算法（Greedy Algorithm）：贪心算法根据当前的最佳选择来逐步安排活动。

它从一组可选活动中选择具有最早结束时间或最短持续时间的活动，并将其安排在日程中，然后继续选择下一个可行的活动。

贪心算法的优点是简单高效，但可能无法得到最优解。

动态规划（Dynamic Programming）：动态规划算法通过将问题分解为子问题并逐步求解，然后利用子问题的解来构建整体解。

在活动安排中，可以使用动态规划来确定最佳活动序列，使得活动之间没有时间冲突且总体利益最大化。

回溯算法（Backtracking Algorithm）：回溯算法通过逐个尝试所有可能的活动安排组合，并根据约束条件进行剪枝，以找到满足要求的最佳安排方案。

回溯算法可以应对更复杂的约束条件，但在问题规模较大时可能会变得计算量较大。

蚁群算法（Ant Colony Algorithm）：蚁群算法模拟了蚂蚁寻找食物的行为，通过信息素的传递和反馈机制，逐步寻找最佳的活动安排方案。

蚁群算法适用于多个活动同时进行且活动之间具有依赖关系的场景。

遗传算法（Genetic Algorithm）：遗传算法模拟了生物进化的过程，通过交叉、变异和选择等操作来生成新的解，并通过适应度函数评估解的质量。

遗传算法可以用于求解复杂的活动安排问题，寻找全局最优解。

需要根据具体的活动安排需求和问题特点选择合适的算法，并根据实际情况进行调整和优化。

在应用算法之前，需要明确活动的约束条件、目标函数以及其他需要考虑的因素，并根据这些因素选择合适的算法进行实施。

贪⼼算法之会场安排问题【问题描述】假设要在⾜够多的会场⾥安排⼀批活动，并希望使⽤尽可能少的会场。

（这个问题实际上是著名的图着⾊问题。

若将每⼀个活动作为图的⼀个顶点，不相容活动间⽤边相连。

使相邻顶点有不同颜⾊的最⼩着⾊数，相应于要找的最⼩会场数。

）【数据输⼊】由⽂件input.txt给出输⼊数据，第⼀⾏⼜⼀个正整数K，表⽰有K个待安排的活动。

接下来有K⾏数据，每⾏有两个正整数，分别表⽰K个待安排的活动的开始时间和结束时间。

【结束输出】输出最少会场数。

input.txt output.txt5 31 2312 2825 3527 8036 50来吧，帮你解决介个问题。

思路：按照俺的思路啊~遍历所有的活动时间，设⼀个int sum代表会场的个数，如果时间可叠加到前⾯已有活动的会场的，把活动加到已有会场的数组中；如不可叠加，则新加会场重新加⼀个数组把这个新会场加⼊到新数组中然后sum+1。

遍历到最后 sum则就是需要最少的会场的个数·····下次再来。

我回来了，上⾯的思路我尝试了，没试出来。

就换了⼀种思路，就是做标记，已经加⼊的会场标记为1 否则为0 就OK了代码下次贴上#include <stdio.h>#define LEN 6int sum=0;int mark[LEN];void squarePlan(int s[],int f[]){int k=1,j;int flag=1;mark[0]=mark[1]=1;while(flag==1){mark[k]=1;for(int m=k+1;m<=LEN;m++){if(mark[m]==0&&s[m]>=f[k]){mark[m]=1;k=m;}}sum++;for(j=2;j<LEN;j++){if(mark[j]==0){k=j;break;}}flag=0;for(int i=1;i<LEN;i++){if(mark[i]==0&&i!=j){flag=1;break;}}}}int main(){ int s[LEN],f[LEN];int n;FILE *fp_in,*fp_out;fp_in=fopen("input.txt","r");//打开⼀个输⼊流，读取input.txt⽂件fp_out=fopen("output.txt","w");//打开⼀个输出流，写output.txt⽂件if(fp_in==NULL){printf("open in file failed\n");return 0;}if(fp_out==NULL){printf("open out file failed\n");return 0;}fscanf(fp_in,"%d",&n);s[0]=0;f[0]=0;for(int i=1;i<=n;i++){fscanf(fp_in,"%d",&s[i]);//x坐标在此题中⽆⽤，⽽y坐标在x坐标之后写⼊。

贪心算法经典例题贪心算法是一种求解最优问题的算法思想，其核心理念是每一步都选择当前最优的策略，从而达到全局最优解。

贪心算法可以应用于许多经典问题，下面将介绍几个常见的贪心算法经典例题及相关参考内容。

1. 会议室安排问题题目描述：给定一组会议的开始时间和结束时间，求解如何安排会议，使得尽可能多的会议可以在同一时间段内进行。

解题思路：贪心算法可以通过每次选择结束时间最早的会议来求解。

首先将会议按照结束时间排序，选择第一个会议作为首先安排的会议，然后依次选择后续结束时间不冲突的会议进行安排。

相关参考内容：- 《算法导论》第16章：贪心算法（ISBN: 9787115265955）- 《数据结构与算法分析》第13章：贪心算法（ISBN: 9787302483626）2. 零钱兑换问题题目描述：给定一定面额的硬币，求解如何用最少的硬币数量兑换指定金额的零钱。

解题思路：贪心算法可以通过每次选择面额最大且不超过目标金额的硬币来求解。

从面额最大的硬币开始，尽可能多地选择当前面额的硬币，并减去已经选择的硬币金额，直到金额为0。

相关参考内容：- 《算法导论》第16章：贪心算法（ISBN: 9787115265955）- 《算法4》第1章：基础（ISBN: 9787302444627）3. 区间调度问题题目描述：给定一组区间，求解如何选择尽可能多的不重叠区间。

解题思路：贪心算法可以通过每次选择结束时间最早的区间来求解。

首先将区间按照结束时间排序，选择第一个区间作为首先选择的区间，然后依次选择后续结束时间不与已经选择的区间重叠的区间进行选择。

相关参考内容：- 《算法导论》第16章：贪心算法（ISBN: 9787115265955）- 《数据结构与算法分析》第13章：贪心算法（ISBN: 9787302483626）4. 分糖果问题题目描述：给定一组孩子和一组糖果，求解如何分配糖果，使得最多的孩子能够得到满足。

解题思路：贪心算法可以通过每次选择糖果最小且能满足当前孩子的糖果来求解。

列举用贪心算法求解的经典问题
1. 零钱兑换问题：给定一些面值不同的硬币和一个金额，要求用最少的硬币凑出这个金额。

2. 最小生成树问题：给定一个无向带权图，要求用最小的权值构建一棵生成树。

3. 背包问题：给定一些物品和一个背包，每个物品有对应的价值和重量，要求在背包容量限制下，选取物品使得总价值最大。

4. 活动安排问题：有若干个活动需要分配一段时间，每个活动有对应的开始时间和结束时间，要求选取尽可能多的活动，使得任两个安排的活动时间不重叠。

5. 单源最短路径问题：给定一个有向带权图和一个起始节点，要求求出从起始节点到其他所有节点的最短路径。

6. 任务调度问题：有若干个需要完成的任务和多个可执行任务的处理器，要求将任务分配给处理器，使得执行总时间最小。

7. 区间覆盖问题：给定一些区间，要求用尽可能少的区间覆盖整个线段。

8. 哈夫曼编码问题：给定一些字符及其对应的出现概率，要求用最短的编码方式表示这些字符。

贪⼼算法-活动选择问题（Python实现）# 有n个活动的集合E={1,2,…,n}，其中每个活动都要求使⽤同⼀资源，# 如演讲会场等，⽽在同⼀时间内只有⼀个活动能使⽤这⼀资源。

# 每个活动i都有⼀个要求使⽤该资源的起始时间si和⼀个结束时间fi,且si <fi 。

# 如果选择了活动i，则它在半开时间区间[si, fi]内占⽤资源。

# 若区间[si, fi]与区间[sj, fj]不相交，则称活动i与活动j是相容的。

# 也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。

# 活动安排问题就是要在所给的活动集合中选出最⼤的相容活动⼦集合，# 是可以⽤贪⼼算法有效求解的很好例⼦。

# 该问题要求⾼效地安排⼀系列争⽤某⼀公共资源的活动。

# 贪⼼算法提供了⼀个简单、漂亮的⽅法使得尽可能多的活动能兼容地使⽤公共资源。

import ioTool#编程任务：在所给的活动集合中选出最⼤的相容活动⼦集合。

def recursive_activity_selector(s,f,k,n):m = k +1while m <= n and s[m]< f[k]:m = m +1if m <= n:return str(m)+" "+str(recursive_activity_selector(s,f,m,n))else:return" "if __name__ =='__main__':s =[0,1,3,0,5,3,5,6,8,8,2,12]#开始时间f =[0,4,5,6,7,9,9,10,11,12,14,16]#结束时间print(len(s),len(f))n =11k =0res = recursive_activity_selector(s, f, k, n)print(res)ioTool.writeLine(res,"output1.txt")结果：。