贪心算法（算法分析与设计）

1.活动安排问题

使剩余安排时间极大化

#include
#include
#include
using namespace std;
struct Node
{
	int s;
	int f;
};
bool cmp(Node a,Node b)
{
	return a.f &x,vector &a)
{
	int n=x.size()-1;
	int j=0;
	int count=1;
	a[0]=true;
	for(int i=1;i<=n;i++)
	{
		if(x[i].s>=x[j].f)
		{
			a[i]=true;
			j=i;
			count++;
		}
		else
		{
			a[i]=false;
		}
	} 	
	return count;
}
int main()
{
	vector n;
	vector a;
	int num;
	cin>>num;
	for(int i=0;i>temp.s>>temp.f;
		n.push_back(temp);
		a.push_back(false);
	}
	sort(n.begin(),n.end(),cmp);
	cout<

2.最优装载

#include
#include
#include
#include
using namespace std;
struct Node
{
	double w;
	int i;
};
bool cmp(Node a,Node b)
{
	return a.w &x,vector &a,double c)
{
	int i=0;
	while(i n;
	vector a;
	int num;
	double c;
	cin>>num>>c;
	for(int i=0;i

3.哈夫曼编码

#include
#include
#include
using namespace std;
struct Tree
{
	Tree* lchlid;
	Tree* rchlid;
	int f;//频率
	int data;//值 
};
struct cmp//与sort的cmp不同，结构体中重载调用操作符。也可以重载>操作符，priority_queue,greater> Q;
{
 	bool operator()(Tree a,Tree b)
 	{
 		return a.f>b.f;//>升序，<降序 
 	}
};
int random(int start,int end)
{
	return start+rand()%(end-start);
}
void HuffmanTree(priority_queue,cmp> &q) 
{
	while(q.size()>=2)
	{/*
		Tree a=q.top();
		cout<<"&a="<<&a<f<<"\t";
		}
		if(temp->lchlid!=NULL)
		{
			q.push(temp->lchlid);
		}
		if(temp->rchlid!=NULL)
		{
			q.push(temp->rchlid);
		}
	}
}
int main()
{
	int num;
	priority_queue,cmp> q;
	cin>>num;
	for(int i=0;i

4.单源最短路径

此处直接使用了书本测试数据，代码写死了。可以用vector来代替重写

#include
#include
#include
using namespace std;
int getMin(int dist[5],bool vt[5])
{
	int min=INT_MAX;
	int mark;
	for(int i=0;i<5;i++)
	{
		if(!vt[i]&&min>dist[i]&&dist[i]>0)
		{
			min=dist[i];
			mark=i;	
		}
	}
	return mark;
}
void dijkstra(int dis[5][5],bool vt[5],int dist[5],int v)
{
	int mark;
	vt[v]=true;
	for(int i=0;i<5;i++)
	{
		dist[i]=dis[v][i];
		cout<0&&dist[mark]+dis[mark][i]0)||(dist[i]<0&&dis[mark][i]>0&&dis[mark][i]>0)))
			{
				dist[i]=dist[mark]+dis[mark][i];
			}
			cout<>v;
	dijkstra(dis,vt,dist,v);
	cout<<"the distance is:"<

5.最小生成树

直接用了年前敲过的代码

A.Prim最小生成树

/************************************************************************************************************************** 
Prim最小生成树：1.从顶点0开始搜素最小权边
                2.搜索到最短边之后，将另一个顶点u加入点集，将最短边值加入ret（总边权值）
		3.判断从顶点u出发的边map[u][j](j为未加入点集的点)，是否小于原先点集的点到点j的距离，如果是就替换掉
		4.prim是遍历顶点，所以邻接矩阵比较合适
***************************************************************************************************************************/ 

#define MaxN 101

int n,ret;
int map[MaxN][MaxN];

void prim()
{
	int closet[MaxN];//该点是否加入点集，1表示加入，0表示不加入 
	int dist[MaxN];//待搜索边集，从某个顶点出发的所有带权值边 
	int i,j;
	for(i=0;i0)//点j未加入点集，点j与顶点之间的有边，且边权小于min
			{
				u=j;
				min=dist[j];
			}
		}
		closet[u]=1;//顶点u加入点集
		ret=ret+min;//总边权值
		for(j=1;j

B.Kruscal最小生成树

#include
#include
using namespace std;
#define Maxv 100+5
struct Node
{
	int v2;
	int v1;
	int len;
};
struct cmp
{
	bool operator()(Node a,Node b)
	{
		return a.len>b.len;
	}
};

int dis[Maxv][Maxv];//dis[i][j]等于0时表示不连通 ，不等于1时表示边权值 
int fa[Maxv];//father，并查集 

int Getfa(int i)//查找根节点的函数 
{
	if(fa[i]!=i)//如果不是根节点 
		fa[i]=Getfa(fa[i]);//找根节点 
	return fa[i];//返回节点i所在集合的根节点	
} 
int main()
{
   	 int sum;//最小生成树代价
     priority_queue,cmp> Q;//声明小顶堆，返回最小数 
 
 	 int vn;//图中的顶点个数 
	 int i;
	 int j;	  
 	 cin>>vn;
	//输入图
	 for(i=1;i<=vn;i++)
	 {
		for(j=1;j<=vn;j++)
		{
			cin>>dis[i][j];	
   		}
	 } 
	 for(i=1;i<=vn;i++)
	 {
		fa[i]=i;//并查集，father，一开始有vn个节点，就有vn个集合 
	 }
	 while(!Q.empty())
	 {
		Q.pop();
	 }
	 //把每条边压入堆中
	 for(i=1;i

6.贪心算法的理论基础