贪心算法

贪心算法和动态规划算法的比较
共同点：
最优子结构性质是选择类最优解都具有的性质，即全优一定包含局优
不同之处：在这里插入代码片
贪心算法具有贪心选择特性。贪心算法求得局部最优解（局部最优，不一定是全局最优）
动态规划算法从全局最优考虑问题

例一：活动安排问题

#include
using namespace std;

#define NUM 50

void GreedySelector(int n, int s[], int f[], bool b[])
{
b[1]=true; //默认将第一个活动先安排
int j=1; //记录最近一次加入b中的活动

//依次检查活动i是否与当前已选择的活动相容
for(int i=2;i<=n;i++)
{
if (s[i]>=f[j])
{
b[i]=true;
j=i;
}
else
b[i]=false;
}
1
}

int main()
{
int s[] = {0,1,3,0,5,3,5,6,8,8,2,12}; //存储活动开始时间
int f[] = {0,4,5,6,7,8,9,10,11,12,13,14}; //存储活动结束时间
bool b[NUM]; //存储被安排的活动编号
int n = (sizeof(s) / sizeof(s[0])) - 1;

GreedySelector(n, s, f, b);

for(int i = 1; i <= n; i++) //输出被安排的活动编号和它的开始时间和结束时间
{
if(b[i]) cout << “活动 " << i << " :” << “(” << s[i] << “,” << f[i] << “)” <<endl;
}
return 0;

}

例二：0-1背包问题

#include
using namespace std;

#define NUM 50

//这里假设 w[], v[] 已按要求排好序
void Knapsack(int n,float M,float v[],float w[],float x[])
{
int i;
for(i = 1; i <= n; i++) x[i] = 0; //初始化数组
float c = M;
for(i = 1;i <= n; i++) //全部被装下的物品,且将 x[i] = 1
{
if(w[i]>c) break;
x[i] = 1;
c -= w[i];
}

if(i <= n) x[i] = c / w[i]; //将物品i 的部分装下
1
}

int main()
{
float M = 50; //背包所能容纳的重量
float w[] = {0,10,20,30}; //这里给定的物品按价值降序排序
float v[] = {0,60,100,120};
float x[NUM]; //存储每个物品装入背包的比例

int n = (sizeof(w) / sizeof(w[0])) - 1;

Knapsack(n, M, v, w, x);

for(int i = 1; i <= n; i++)
cout << "物品 " << i << " 装入的比例: " << x[i] << endl;
return 0;

}

例三：最优装载问题

#include
using namespace std;

const int N = 4;

template
void Swap(Type &x,Type &y);

template
void Loading(int x[], Type w[], Type c, int n);

template
void SelectSort(Type w[],int *t,int n);

int main()
{
float c = 70;
float w[] = {0,20,10,26,15};//下标从1开始
int x[N+1];

cout<<“轮船载重为：”<<c<<endl;
cout<<“待装物品的重量分别为：”<<endl;
for(int i=1; i<=N; i++)
{
cout<<w[i]<<" ";
}
cout<<endl;
Loading(x,w,c,N);

cout<<“贪心选择结果为:”<<endl;
for(int i=1; i<=N; i++)
{
cout<<x[i]<<" ";
}
cout<<endl;

return 0;

}

template
void Loading(int x[],Type w[], Type c, int n)
{
int *t = new int [n+1];//存储排完序后w[]的原始索引
SelectSort(w, t, n);

for(int i=1; i<=n; i++)
{
x[i] = 0;//初始化数组x[]
}
for(int i=1; i<=n && w[t[i]]<=c; i++)
{
x[t[i]] = 1;
c -= w[t[i]];
}

}

template
void SelectSort(Type w[],int *t,int n)
{
Type tempArray[N+1],temp;
memcpy(tempArray,w,(n+1)*sizeof(Type));//将w拷贝到临时数组tempArray中
int min;

for(int i=1;i<=n;i++)
{
t[i] = i;
}

for(int i=1;i<n;i++)
{
min=i;
for(int j=i+1;j<=n;j++)
{
if(tempArray[min]>tempArray[j])
{
min=j;
}
}
Swap(tempArray[i],tempArray[min]);
Swap(t[i],t[min]);
}

}

template
void Swap(Type &x,Type &y)
{
Type temp = x;
x = y;
y = temp;
}

例四：单源最短路径Kruskal算法

#include
#include<stdlib.h>
#include<math.h>
#include
#include //sort()需要用到库
using namespace std;
struct point {
int x;
int y;
int v;
}; //定义结构类型，表示边
point a[9901]; //存边
int fat[101];
int n,i,j,x,m,tot,k;
int father(int x){
if (fat[x] != x)
fat[x] = father(fat[x]);
return fat[x];
}
void unionn(int x,int y){
int fa = father(x); int fb = father(y); if (fa != fb) fat[fa] = fb; }
int cmp(const point &a,const point &b) { //sort()自定义的比较函数
if (a.v < b.v) return 1;
else return 0;
}
int main(){
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
cin >> x;
m++;
a[m].x = i; a[m].y = j; a[m].v = x;
}
for (i = 1; i <= n; i++)
fat[i] = i;
sort(a+1,a+m+1,cmp);
for (i = 1; i <= m; i++) {
if (father(a[i].x) != father(a[i].y)) {
unionn(a[i].x,a[i].y);
tot += a[i].v;
k++;
}
if (k == n-1)
break;
}
cout << tot;
return 0;
}

例五：删数问题

#include
#include
using namespace std;
int main(){
string a; //n位数a
int k; //删除数字的个数
cin>>a>>k;
if (k >= a.size()) a.erase(); //如果k≥n，所有数字均被删除
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–;
}
while(a.size() > 1 && a[0] == ‘0’) //删除前导数字0
a.erase(0, 1);
cout<<a<<endl;
}

例六：汽车加油问题

#include
using namespace std;
int main(){
int n,k,i;	int *station;
cout<<“请输入加满一箱油的最大行驶路程和加油站的个数：”;
cin>>n>>k;	station=new int[k+1];
cout<<“请输入相邻的两个加油站之间的距离：”;
for(i=0;i<=k;i++)	cin>>station[i];
int s=0,number=0;//number记录加油的次数
s=station[0];//加满油后希望的行驶距离
for(i=1;i<=k;i++){ //i代表加油站编号 。1~7.代表将要到大的加油站
if(s>n)	{cout<<“No solutin!!”;	break;	}//判断能否到达i加油站
else{//能到达加油站i
s=s+station[i]; //到下一加油i+1站希望的 行使的距离
if(s>n){ //希望距离>n
number++;//加油
s=station[i];//到下一加油站的距离
cout<<“在第”<<i<<" 个加油站加油"<<endl;
}
}
}
cout<<number<<endl;
return 0;
}

5.11 ZOJ1029-Moving Tables
这层楼沿着走廊南北向的两边各有200个房间。最近，公司要做一次装修，需要在各个办公室之间搬运办公桌。
由于走廊狭窄，办公桌都很大，走廊里一次只能通过一张办公桌。必须制定计划提高搬运效率。
经理制定如下计划：一张办公桌从一个房间移到另一个房间最多用十分钟。当从房间i移动一张办公桌到房间j，两个办公室之间的走廊都会被占用。所以，每10分钟内，只要不是同一段走廊，都可以在房间之间移动办公桌。
输入
输入数据有T组测试例，在第一行给出测试例个数T。
每个测试例的第一行是一个整数N（1≤N≤200)，表示要搬运办公桌的次数。接下来N行，每行两个正整数s和t，表示一张桌子，是从房间号码s移到到房间号码t。
输出
每组输入都有一行输出数据，为一整数T，表示完成任务所花费的最小时间。
在经理给出的说明表格中，已经明确地描述了算法：
（从房间30到50）和（从房间60到90）是允许的，因为没有占用公共的走廊；
（从房间20到40）和（从房间31到80）是不允许的，因为要占用公共的走廊。
我们将每个房间之间的走廊作为一个统计单位，当所有的办公桌都搬运完成之后，看看这段走廊到底需要占用多少次？然后统计所有的走廊被占用的最大值max，这个值就是要单独安排的搬运次数，乘以10就是总的搬运时间。
int i, j;
int move[200];
int N;　　　　　　　　//搬运次数
int from, to; //每次搬运的起点和终点
scanf("%d", &N);
memset(move, 0, sizeof(move));
for(i = 0; i < N; i++){
　　scanf("%d%d", &from, &to);
　　from = (from - 1)/2; //将房间号映射为走廊号。走廊数组下标从0开始
　　to = (to - 1)/2;
　　//确保from<to，C++使用：swap(from, to)
　　if(from > to) {　int temp = from; 　from = to; 　to = temp;　}
　　//占用走廊情况
　　for(j = from; j <= to; j++)
　　　　move[j]++;
}
所有的走廊被占用的最大值
int max = 0;
for(i = 0; i < 200; i++)
　　if(move[i] > max) max = move[i];
printf("%d\n", max * 10);

算法5.19选择鱼最多的湖钓鱼的贪心算法实现
//从湖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 = 1; i <= pos; ++i)
　　　　fish[i] = f[i];
　　memset(p, 0, sizeof§);
　　……
}
//在时间time内，选择鱼最多的湖钓鱼；如果鱼都没有了，就把时间放在湖1上
for (i = 0; i < time; ++i){
　　int max = 0; //鱼最多的湖中，鱼的数量
　　int id = -1;　　　　　//鱼最多的湖的编号
　　//查找鱼最多的湖中，鱼的数量和湖的编号
　　for (j = 1; 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[1];
}
//处理最优方案
if (t > best)
{
　　best = t; 　　　　　　　　//最优值
　　memset(plan, 0, sizeof(plan));
　　for (i = 1; 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);