贪心算法

1、活动安排问题
//形参数组b用来记录被选中的活动
void GreedySelector(int n, action a[], bool b[])
{
　　b[1] = true;　　　　　//第1个活动是必选的
　　//记录最近一次加入到集合b中的活动
　　int preEnd = 1;
　　for(int i=2; i<=n; i++)
　　　　if (a[i].s>=a[preEnd].f)
　　　　{
　　　　　　b[i] = true;
　　　　　　preEnd = i;
　　　　}
}

2、背包问题
//形参n是物品的数量，c是背包的容量M，数组a是按物品的性价比降序排序
double knapsack(int n, bag a[], double c)
{
　　double cleft = c;　　　　　　　　//背包的剩余容量
　　int i = 0;
　　double b = 0;　　　　　　　　　　//获得的价值
　　//当背包还能完全装入物品i
　　while(i<n && a[i].w<cleft)
　　{
　　　　cleft -= a[i].w;
　　　　b += a[i].v;
　　　　i++;
　　}
　　//装满背包的剩余空间
　　if (i<n) b += 1.0*a[i].v*cleft/a[i].w;
　　return b;
}

//如果要获得解向量，则需要在数据结构中加入物品编号：
struct bag{
	int w;
	int v;
	double x;		//装入背包的量，0≤x≤1
	int index;		//物品编号
	double c;
}a[1001];

//计算背包问题的贪心算法，同时得到解向量
double knapsack(int n, bag a[], double c)
{
　　double cleft = c;
　　int i = 0;
　　double b = 0;
　　while(i<n && a[i].w<=cleft)
　　{
　　　　cleft -= a[i].w;
　　　　b += a[i].v;
　　　　//物品原先的序号是a[i].index，全部装入背包
　　　　a[a[i].index].x = 1.0;
　　　　i++;
　　}
　　if (i<n)　{
　　　　a[a[i].index].x = 1.0*cleft/a[i].w;
　　　　b += a[a[i].index].x*a[i].v;
　　}
　　return b;
}

3、最优装载问题
while (scanf("%d%d", &c, &n)!=EOF)
{
　　memset(box, 0, sizeof(box));
　　memset(x, 0, sizeof(x));
　　for (int i=1; i<=n; i++) 
　　{
　　　　scanf("%d", &box[i].w);
　　　　box[i].index = i;
　　}
　　//按集装箱的重量升序排序
　　stable_sort(box, box+n+1, cmp);
　　if (box[1].w>c) {
　　　　printf("No answer!\n");
　　　　continue;
}
　//贪心算法的实现，重量最轻者先装载
　　int i;
　　for (i=1; i<=n && box[i].w<=c; i++)
　　{
　　　　x[box[i].index] = 1;
　　　　c -= box[i].w;
　　}
　　//输出装载的集装箱数量
　　printf("%d\n", i-1);
　　//输出装载的集装箱编号
　　for (i=1; i<=n; i++)
　　　　if (x[i]) printf("%d ", i);
　　printf("\n");
｝

4、删数问题
string a;　　　　　　　　//n位数a
int k;
cin>>a>>k;
//如果k≥n，数字被删完了
If (k >= a.size())  a.erase();
else while(k > 0)
{
　　//寻找最近下降点
　　int i;
　　for (i=0; (i<a.size()-1) && (a[i] <= a[i+1]);  ++i);
　　a.erase(i, 1);　　　　//删除xi
　　k- -;
}
//删除前导数字0
while(a.size() > 1 && a[0] == '0') 
　　a.erase(0, 1);
cout<<a<<endl;

5、多处最优服务次序问题
//顾客等待的队列为client，提供服务的窗口s个
double greedy(vector<int> client, int s)
{
　　//服务窗口的顾客等待时间
　　vector<int> service(s+1, 0);
　　//服务窗口顾客等待时间的总和
　　vector<int> sum(s+1, 0);
　　//顾客的数量
　　int n = client.size();
　　//按顾客的服务时间升序排序
　　sort(client.begin(), client.end());
//贪心算法的实现
　　int i=0;　　　　　　　　　　//顾客的指针
　　int j=0;　　　　　　　　　　//窗口的指针
　　while(i < n)
　　{
　　　　service[j] += client[i];
　　　　sum[j] += service[j];
　　　　++i, ++j;
　　　　if(j == s) j = 0;
　　}
　　//计算所有窗口服务时间的总和
　　double t=0;
　　for(i=0; i<s; ++i) t += sum[i];
　　t /= n;
　　return t;
}

6、ZOJ1025-Wooden Sticks
//排序函数cmp()的实现：
int cmp(stick a, stick b) 
{ 
	//长度相等时，按重量排序
	if (a.l == b.l) 	return a.w < b.w; 
	//优先按长度排序
	else if (a.l < b.l) return true;
	return false;
}
//计算重量w的最长单调递增子序列个数的动态规划实现
//形参n是木棒的数量，stick是木棒参数的数组
int LIS(int n, stick a[]) 
{
　　//数组b表示木棒分组的序号
　　int b[maxN];
　　memset(b, 0, sizeof(b));
　　int i, j, k;
　　b[0]=1;
　　for (i=1; i<n; i++) 
　　{
　　　　//计算第i个木棒的的分组序号
　　　　k=0;
　　　　for (j=0; j<i; j++) 
　　　　　　if (a[i].w<a[j].w && k<b[j]) k=b[j];
　　　　b[i]=k+1;
　　}
　　//查找最大的分组序号（数组b中的最大值）
　　int max=0;
　　for (i=0; i<n; i++)
　　　　if (b[i]>max) max=b[i];
　　return max;
}
7、ZOJ1161-Gone Fishing
//从湖1起到湖pos止，花费时间time（不含路程）的钓鱼计划
void greedy(int pos, int time)
{ 
　　if (time <= 0) return; 　　　　　//时间已经用完
　　int i, j;
　　int fish[MAXN];
　　int p[MAXN];
　　int t = 0; 
　　for (i = 0; i < pos; ++i) 
　　　　fish[i] = f[i]; 
　　memset(p, 0, sizeof(p)); 
　　……
}
//在时间time内，选择鱼最多的湖钓鱼；如果鱼都没有了，就把时间放在湖1上
for (i = 0; i < time; ++i)
{ 
　　int max = 0;		//鱼最多的湖中，鱼的数量
　　int id = -1;　　　　　//鱼最多的湖的编号
　　//查找鱼最多的湖中，鱼的数量和湖的编号
　　for (j = 0; j < pos; ++j)
　　　　if (fish[j] > max){ 
　　　　　　max = fish[j]; 
　　　　　　id = j; 
　　　　} 
　　if (id != -1) 　　　　　//找到了，进行钓鱼处理
　　{
　　　　++p[id]; 
　　　　fish[id] -= d[id]; 
　　　　t += max; 
　　}
　　//没有找到（从湖1起到湖pos全部钓完了），就把时间放在湖1上
　　else ++p[0]; 
}
//处理最优方案
if (t > best)
{ 
　　best = t; 　　　　　　　　//最优值
　　memset(plan, 0, sizeof(plan));
　　for (i = 0; i < pos; ++i) 　//最优解
　　　　plan[i] = p[i]; 
}
输出钓鱼计划时，再把5乘回去for (i=0; i<n-1; ++i)    printf("%d, ", plan[i] * 5);
printf("%d\n", plan[n-1] * 5);     printf("Number of fish expected: %d\n", best);