算法设计与分析基础3 贪心算法

说明

留个纪念，记录部分大连理工大学算法设计与分析课程源代码。
本人代码水平有限，可能会有错误，请评论区交流讨论。
给学弟学妹一些方便，或者是有基础算法需求的朋友。编程语言c++。

本系列总目录

注意：参考书：王晓东《算法设计与分析第四版》

1. 递归与分治算法
2. 动态规划
3. 贪心算法
4. 回溯算法

本部分目录

1.贪心算法理解

贪心算法的特征是最优子结构性质和贪心选择性质。

最优子结构性质：原问题的最优解包含着子问题的最优解。

贪心选择性质：问题整体的最优解是通过一系列局部的最优选择得到的，这种选择叫做贪心选择。贪心选择可以依赖于已经做过的选择，但是绝对不会依赖于将来的选择，也不依赖于子问题的解。

贪心选择一般没有一个通用的框架。只要用数学归纳法证明贪心选择性质（严谨），一般可以进行排序，或者维护一个最大堆最小堆，运用并查集等等实现每部选择都贪心。

2.贪心：dijkstra求单元最短路径

//给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。
//请你求出1号点到n号点的最短距离，如果无法从1号点走到n号点，则输出-1
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

const int N=510;
int g[N][N];//存储图 
int dist[N];//存储最终结果 
bool isVisited[N]; //记录是否访问过该节点,初始均为0代表没有访问过 
int n,m;

int Dijkstra()
{
	memset(dist,0x3f,sizeof(dist));
	
	dist[1]=0;
	
	for(int i=0;i<n;i++)
	{
		int t=-1;
		
		for(int j=1;j<=n;j++)
		{
			if(!isVisited[j]&&(t==-1||dist[t]>dist[j]))
			{
				t=j;//每轮选一个最贪心的结果 
			 } 
		}
		
		isVisited[t]=true;
		
		for(int j=1;j<=n;j++)
		{
			dist[j]=min(dist[j],dist[t]+g[t][j]);
		 } 
	}
	
	if(dist[n]==0x3f3f3f3f) return -1;
	return dist[n];
}


int main()
{
	
	cin>>n>>m;
	
	memset(g,0x3f,sizeof(g));
	
	for(int i=0;i<m;i++)
	{
		int x,y,z;
		cin>>x>>y>>z;
		
		g[x][y]=min(g[x][y],z);//处理重复 
	}
	
	cout<<Dijkstra()<<endl;

	return 0; 
 } 

3.贪心：kruskal最小生成树

//个人认为最小生成树是一种比较简单的贪心算法
//克鲁斯卡尔就是比较简单粗暴，每次都选最小的边进行拼装，只要不成为环就可以
//直观上看就是众树合一
//一般处理稀疏图 
//这里比较巧妙地运用了并查集的手段 
//并查集这种数组结构顾名思义，主要有合并和查询两个功能。 
//并查集：每个集合用一颗树来表示，树根的编号是整个集合的编号，每个节点存储他的父节点。 
//例子：  1    2    3    4    元素编号 
//      p[1] p[2] p[3] p[4]   值 
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

const int N=200010,M=100010;
int p[N];//用作并查集 
int n,m;

struct Edge
{
	int a,b,w;//从a到b权值为w 
	
	bool operator< (const Edge &t)const//重载一下小于号 
	{
		return w<t.w;
	}
}edges[N];

int find(int x)//用来找祖宗 ，并查集的查询功能，这里的p可以代表parent的意思 
{
	if(x!=p[x]) p[x]=find(p[x]);//我们定义祖宗是那种p[i]==i的 
	else return x;
}


int Kruskal()
{
	int res=0,count=0;
	for(int i=0;i<m;i++)//已经按升序排好的边 
	{
		int a=edges[i].a,b=edges[i].b,w=edges[i].w;
		
		
		//用并查集的原理是这样
		/*
		我想实现一个判断是否成环的功能。
		并查集是这样做的：按升序添加边，小树生长，没生长一条边就把这些边锁链的顶点放入
		一个集合之中。如果这时候下一条边我们判断一下属于一个集合，则产生了闭环，不能要 
		*/ 
		if(find(a)!=find(b))//判断是否再同一个集合中
		
		{
			p[find(a)]=p[find(b)];//并查集合并操作 
			count++;
			res+=w;
		}
	}
	
	if(count==n-1) return res;
	else return 0x3f3f3f3f;
 } 


int main()
{
	cin>>n>>m;//n个节点m条边 
	
	for(int i=0;i<n;i++)
	{
		p[i]=i;//大家都作为自己的独立集合，自己就是祖宗 
	}
	
	for(int i=0;i<m;i++)
	{
		int a,b,w;
		cin>>a>>b>>w;
		edges[i]={a,b,w};
	}
	
	sort(edges,edges+m);
	
	int res=Kruskal();
	
	if(res==0x3f3f3f3f) cout<<"impossible"<<endl;
	else cout<<res<<endl;
	
	return 0; 
 } 

4.贪心：Prim算法求最小生成树

//给定一个n个点m条边的有向图，图中可能存在重边和自环，所有边权均为正值。
//请你求出最小生成树，和dijkstra像，就是d是与源点的最小，prim是与已选集合的最小 
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;

const int N=510;
int g[N][N];//存储图 
int dist[N];//存储最终结果 
bool isVisited[N]; //记录是否访问过该节点,初始均为0代表没有访问过 
int n,m;

int prim()
{
	memset(dist,0x3f,sizeof(dist));
	int res=0;
	
	for(int i=0;i<n;i++)
	{
		int t=-1;
		
		for(int j=1;j<=n;j++)
		{
			if(!isVisited[j]&&(t==-1||dist[t]>dist[j]))
			{
				t=j;//每轮选一个最贪心的结果 
			 } 
		}
		
		if (i && dist[t] == 0x3f3f3f3f) return 0x3f3f3f3f;
		
		if(i) res+=dist[t];
		
		isVisited[t]=true;
		
		for(int j=1;j<=n;j++)
		{
			dist[j]=min(dist[j],g[t][j]);
		 } 
	}
	
	return res;
}


int main()
{
	
	cin>>n>>m;
	
	memset(g,0x3f,sizeof(g));
	
	for(int i=0;i<m;i++)
	{
		int x,y,z;
		cin>>x>>y>>z;
		
		g[x][y]=g[y][x]=min(g[x][y],z);//处理重复 
	}
	
	int t=prim();
	if(t==0x3f3f3f3f) cout<<"impossible";
	else cout<<t;

	return 0; 
 } 

5.贪心：哈夫曼果子

#include<iostream>
#include<algorithm>
#include<vector>
#include<queue> 
using namespace std;

int main()
{
	int n;
	cin>>n;
	
	priority_queue<int,vector<int>,greater<int> > heap;//优先队列制造小顶堆
	
	for(int i=0;i<n;i++)
	{
		int x;
		cin>>x;
		heap.push(x);//自动维护小顶堆 
	 } 
	 
	int res=0;
	while(heap.size()>1)
	{
		int a=heap.top(); heap.pop();
		int b=heap.top(); heap.pop();
		res+=(a+b);
		heap.push(a+b);
	}
	
	cout<<res;
	return 0; 
 }