贪心算法

                                  **贪心算法**
                                 活动安排问题

设有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相容。
活动安排问题就是在所给的活动集合中选出最大的相容活动子集合。

活动安排问题的贪心特性（贪心的体现：最多的活动）。
如何在有限的时间内安排更多的活动（贪心策略）？
需要先安排结束时间早的活动（剩余时间多） 。
因此，需要根据活动的结束时间对活动进行排序
在排序的基础上，依次来寻找相容的活动

数据结构
struct action{
int s; //起始时间
int f; //结束时间
int index; //活动的编号
};
活动的集合E记为数组：
action a[1000];
按活动的结束时间升序排序
排序比较因子：
bool cmp(const action &a, const action &b)
{
if (a.f<=b.f) return true;
return false;
}
使用标准模板库函数排序（下标0未用）：
sort(a, a+n+1, cmp);

void Greedy(vector &v,int n){
v[0].select=1;
int select=0;
for(int i=1;i<n;i++) {
if(v[i].gets()>=v[select].gete()){
v[i].select=1;
select=i;
}
}
cout<<“可以安排如下的活动：”<<endl;
for(i=0;i<n;i++)
if(v[i].select)
v[i].display();

}

void Greedy(vector &v,int n){
v[0].select=1;
int select=0;
for(int i=1;i<n;i++) {
if(v[i].gets()>=v[select].gete()) {
v[i].select=1;
select=i;
}
}
cout<<“可以安排如下的活动：”<<endl;
for(i=0;i<n;i++)
if(v[i].select)
v[i].display();

}

背包问题

给定一个载重量为M的背包，考虑n个物品，其中第i个物品的重量 wi ，价值vi （1≤i≤n），要求把物品装满背包，且使背包内的物品价值最大。
有两类背包问题（根据物品是否可以分割），如果物品不可以分割，称为0-1背包问题（动态规划）；如果物品可以分割，则称为背包问题（贪心算法）。

（1）当作0-1背包问题，用动态规划算法，获得最优值220；
（2）当作0-1背包问题，用贪心算法，按性价比从高到底顺序选取物品，获得最优值160。由于物品不可分割，剩下的空间白白浪费。
（3）当作背包问题，用贪心算法，按性价比从高到底的顺序选取物品，获得最优值240。由于物品可以分割，剩下的空间装入物品3的一部分，而获得了更好的性能。

struct bag{
int w; //物品的重量
int v; //物品的价值
double c; //单位重量的价值，v/w
}a[1001]; //存放物品的数组
排序因子（按性价比降序）：
bool cmp(bag a, bag b){
return a.c >= b.c;
}
使用标准模板库函数排序：
sort(a, a+n, cmp);

如果要获得解向量 ，则需要在数据结构中加入物品编号：
struct bag{
int w;
int v;
double c; //单位重量的价值，v/w
double x; //装入背包的量，0≤x≤1
int index; //物品编号
}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; //因为形参数组a已经排序
　　　　i++;
　　}
　　if (i<n)　{
　　　　a[a[i].index].x = 1.0cleft/a[i].w;
　　　　b += a[a[i].index].xa[i].v;
　　}
　　return b;
}

最优装载问题

有一批集装箱要装上一艘载重量为c的轮船，其中集装箱i的重量为wi。最优装载问题要求确定在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船（件数最多）。
该问题的形式化描述为：

其中xi∈{0，1}，1≤i≤n。

最优装载问题可用贪心算法求解。采用重量最轻者先装的贪心选择策略，可产生最优装载问题的最优解。
template
void Loading(int x[], Type w[], Type c, int n){
int *t = new int [n+1];
Sort(w, t, n);//t 存储的是按重量排好序的集装箱的序号
for (int i = 1; i <= n; i++)
x[i] = 0;
for (int i = 1; i <= n && w[t[i]] <= c; i++) {
x[t[i]] = 1; c - = w[t[i]];
}
}
单源最短路径

Dijkstra算法是解单源最短路径问题的一个贪心算法。
设置顶点集合S并不断地做贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。
初始时，S中仅含有源。
设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。
Dijkstra算法每次从V - S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。(贪心策略)
一旦S包含了所有V中顶点，dist就记录了从源到所有其它顶点之间的最短路径长度。

最小生成树

最小生成树不是唯一的，用边ah替代边bc构成另外一棵最小生成树

Kruskal算法
设G=(V,E)是连通带权图，V＝{v1，v2 ，…，vn}。
Kruskal算法构造G的最小生成树的基本思想：
将G的n个顶点看成n个孤立的连通分量，将所有的边按权从小到大排序。
从第一条边开始，依边权递增的顺序查看每一条边，并按下述方法连接两个不同的连通分量：
当查看到第i条边（u，v）时，如果端点u和v分别是当前两个不同的连通分量T1和T2中的顶点时，就用边(u，v)将T1和T2连接成一个连通分量，然后继续查看第i＋1条边；
如果端点u和v在当前的同一个连通分量中，就直接再查看第i＋1条边。
这个过程一直进行到只剩下一个连通分量时为止，该连通分量就是G的一棵最小生成树。
Kruskal算法构造最小生成树的过程

当查看到第i条边（u，v）时，如果端点u和v分别是当前两个不同的连通分量T1和T2中的顶点时，就用边(u，v)将T1和T2连接成一个连通分量，然后继续查看第i＋1条边；
如果端点u和v在当前的同一个连通分量中，直接查看第i＋1条边。
Kruskal算法思想

1. 初始化：U=V； TE={ }；
2. 循环直到T中的连通分量个数为1
   2.1 在E中寻找最短边(u，v);
   2.2 如果顶点u、v位于T的两个不同连通分量，则
   2.2.1 将边(u，v)并入TE；
   2.2.2 将这两个连通分量合为一个；
   2.3 在E中标记边(u，v)，使得(u，v)不参加后续最短边的选取；

并查集的基本思想

1、什么叫并查集
并查集（union-find set）是一抽象数据类型。它所处理的是“集合”之间的关系，即动态地维护和处理集合元素之间复杂的关系，
当给出两个元素的一个无序对(a,b)时，需要快速“合并”a和b分别所在的集合，这其间需要反复“查找”某元素所在的集合。“并”、“查”和“集”三字由此而来。

#include
　　#include
　　using namespace std;
　　#define maxn 20001
　　int father[maxn];
　　int m,n,i,x,y,q;
　　
　　int find(int x){ //用递归的实现
　　 if (father[x] != x)
return find(father[x]);
　　 else
return x;
　　}