会场安排问题贪心算法

① 下题贪心算法一种形式望解得合理安排会议最多编写程序，输入10个会议开始和结束时间，输出选中的会议。。

王才”使用甄后与曹植的爱情故事。见《文选·洛神赋》李善注说：魏东阿王曹植曾求娶甄氏为妃，曹操却将她许给曹丕。甄后被谗死后，曹丕将她的遗物玉带金镂枕送给曹植。曹植离京归国途经洛水，梦见甄后对他说：“我本托心君王，其心不遂。此枕是我在家时从嫁，前与五官中郎将（曹丕），今与君王。”曹植感其事作《感甄赋》，

② C语言程序问题——活动安排问题

题目出得不严密，题目要求是“计算安排的活动最多时会场使用时间”，但当“安排的活动最多”有多种安排方式，题目中却没说输出这多种方式中的哪一种的会场使用时间。例如 ：当有3项活动要安排，开始时间和结束时间分别是1 2、3 5、4 5，这时可以安排第一项和第二项活动，也可以安排第一项和第三项活动，前者的会场使用时间是5，后者是4，这时是输出4还是5，题目中没用指出。先假设测试数据不会出现上述情况，则利用贪心算法求解活动安排问题是一种最常用的方法：#include<stdio.h>
#include<stdlib.h>
struct activity
{
int start;
int end;
}act[8501];
int comp(const void *p, const void *q)
{
struct activity *a=(struct activity *)p;
struct activity *b=(struct activity *)q;
return a->end-b->end;
}
int main()
{
int i,k,res,e;
while(scanf("%d",&k)!=EOF)
{
for(i=0;i<k;i++) scanf("%d%d",&act[i].start,&act[i].end);
qsort(act,k,sizeof(act[0]),comp);
res=act[0].end-act[0].start+1;
e=act[0].end;
for(i=1;i<k;i++)
{
if(act[i].start>e)
{
res+=act[i].end-act[i].start+1;
e=act[i].end;
}
}
printf("%d\n",res);
}
return 0;
}

③ 会场安排问题

设有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相容。

解活动安排问题的贪心算法greedySelector :
public static int greedySelector(int [] s, int [] f, boolean a[])
{
int n=s.length-1;
a[1]=true;
int j=1;
int count=1;
for (int i=2;i<=n;i++) {
if (s[i]>=f[j]) {
a[i]=true;
j=i;
count++;
}
else a[i]=false;
}
return count;
}
由于输入的活动以其完成时间的非减序排列，所以算法greedySelector每次总是选择具有最早完成时间的相容活动加入集合A中。直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。
算法greedySelector的效率极高。当输入的活动已按结束时间的非减序排列，算法只需O(n)的时间安排n个活动，使最多的活动能相容地使用公共资源。如果所给出的活动未按非减序排列，可以用O(nlogn)的时间重排。

活动安排问题源代码：
#include <iostream>

#include <vector>
#include <algorithm>

using namespace std;

struct point
{
int t;
bool f;
};

bool cmp(point x,point y)
{
return x.t<y.t;
}

int greedy(vector<point> x)
{
int max=0,cur=0,n=x.size();
sort(x.begin(),x.end(),cmp);
for(int i=0;i<n;i++)
{
if(x[i].f)
cur++;
else
cur--;
if(cur>max)
max=cur;
}
return max;
}

int main()
{
vector<point> x;
int n,i;
point temp;
while(cin>>n,n)
{
for(i=0;i<n;i++)
{
temp.f=true;
cin>>temp.t;
x.push_back(temp);
temp.f=false;
cin>>temp.t;
x.push_back(temp);
}
cout<<greedy(x)<<endl;
x.clear();
}
return 0;
}

④ 贪心算法的会场安排问题

查找有冲突的活动，将有冲突的放到第二个会场。
继续查找有冲突的活动，放到第三个会场。
就是贪心么。先按第一会场排，然后排第二会场、……
不知道是不是最优解。暂时还想不到反例。

⑤ 贪心算法 活动安排问题

这道题的贪心算法比较容易理解，我就不多说明了，只是提到一下算法思路1、建立数学模型描述问题。我在这里将时间理解成一条直线，上面有若干个点，可能是某些活动的起始时间点，或终止时间点。在具体一下，如果编程来实现的话，将时间抽象成链表数组，数组下标代表其实时间，该下标对应的链表代表在这个时间起始的活动都有哪些，具体参照程序注释。2、问题分解。为了安排更多的活动，那么每次选取占用时间最少的活动就好。那么从一开始就选取结束时间最早的，然后寻找在这个时间点上起始的活动，以此类推就可以找出贪心解。程序代码：#include<stdio.h>
struct inode //自定义的结构体
{
int end; //表示结束时间
inode *next; //指向下一个节点的指针
};int main()
{
inode start[10001],*pt;
int a,b,i,num=0; //num负责计数，i控制循环，a，b输入时候使用
for(i=0;i<10001;i++) //初始化
{
start[i].next=NULL;
}
while(scanf("%d %d",&a,&b)) //输入并建立数据结构
{
if(a==0&&b==0) break;
pt=new inode; //创建新的节点，然后将该节点插入相应的位置
pt->end=b;
pt->next=start[a].next;
start[a].next=pt;
}
i=0;
while(i<10001) //进行贪心算法，i表示当前时间
{
if(start[i].next==NULL)
{
i++; //该时间无活动开始
}
else
{
int temp=10001; //临时变量，存储该链表中最早的终止时间
for(pt=start[i].next;pt!=NULL;pt=pt->next)
{
if(pt->end<temp)
{
temp=pt->end;
}
}
i=temp; //将当前时间设置成前一子问题的终止时间
num++;
}
}
printf("%d\n",num); //打印结果
return 0;
}代码并不一定是最快速的，但是可以求出贪心解，如果你做的是ACM编程题目，不保证能AC注释我尽力写了，希望对你有帮助。

⑥ OJ贪心算法，活动安排，求大神解答

按结束时间从小到大排序，之后从开始贪心即可

⑦ 贪心算法之会场安排问题

三星算法之间最好还是不要安排互相的问题，这样不利于你们俩的关系的便有好。

⑧ 请高手进来解答一下这道算法设计与分析的题目，谢谢了！！

设有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相容。

在下面所给出的解活动安排问题的贪心算法greedySelector:

publicstaticintgreedySelector(int[]s,int[]f,booleana[])

{

intn=s.length-1;

a[1]=true;

intj=1;

intcount=1;

for(inti=2;i<=n;i++){

if(s[i]>=f[j]){

a[i]=true;

j=i;

count++;

}

elsea[i]=false;

}

returncount;

}

由于输入的活动以其完成时间的非减序排列，所以算法greedySelector每次总是选择具有最早完成时间的相容活动加入集合A中。直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

算法greedySelector的效率极高。当输入的活动已按结束时间的非减序排列，算法只需O(n)的时间安排n个活动，使最多的活动能相容地使用公共资源。如果所给出的活动未按非减序排列，可以用O(nlogn)的时间重排。

例：设待安排的11个活动的开始时间和结束时间按结束时间的非减序排列如下：

i 1 2 3 4 5 6 7 8 9 10 11

S[i] 1 3 0 5 3 5 6 8 8 2 12

f[i] 4 5 6 7 8 9 10 11 12 13 14

⑨ 会场安排问题，java的实现

您好，提问者：
会议数组那么肯定存放一个对象，我举个简单的Person例子：

importjava.util.Comparator;
importjava.util.Iterator;
importjava.util.TreeSet;


publicclassTest{
	publicstaticvoidmain(String[]args){
		//使用匿名内部类进行排序
		TreeSet<Person>set=newTreeSet<Person>(newComparator<Person>(){
			publicintcompare(Persono1,Persono2){
				intnum=newInteger(o2.end).compareTo(o1.end);
				returnnum;
			}
		});
		set.add(newPerson(1,3));
		set.add(newPerson(2,5));
		System.out.println("开始时间	结束时间");
		for(Iterator<Person>it=set.iterator();it.hasNext();){
			Personp=it.next();
			System.out.println(p.start+"	"+p.end);
		}
	}
}
classPerson{
	intstart;
	intend;
	publicPerson(intstart,intend){
		this.start=start;
		this.end=end;
	}
}

//输出结果：

开始时间 结束时间

2 5

1 3

⑩ 采用贪心算法进行安排。对算法的时间和空间复杂度进行分析

时间主要是 排序用时了，快速排序 一般是 o(n*logn)
空间 复杂度基本上是 0(1)