图论之最短路与最小生成树算法模板

拓扑排序

//把入度为0的点逐个删除 
//应用判断一个有向图是否有环 
//复杂度O(n+m) 
#include<bits/stdc++.h>
using namespace std;
const int N = 500010;
int n,m,tot=0;
//vis表示入度 
int head[N],vis[N];
struct ty{
	int t,next;
}edge[N];
void addedge(int x,int y){
	edge[++tot].t = y;
	edge[tot].next = head[x];
	head[x] = tot;
}
queue<int> q;
void tuopu()
{
	for(int i=1;i<=n;i++){
		//入读为0则入队 
		if(vis[i] == 0) q.push(i);
	}
	int t=0;
	while(!q.empty())
	{
		int x = q.front();
		cout << x << " " << endl;
		q.pop();
		//输出点的个数 
		t++;
		for(int i=head[x];i != -1;i = edge[i].next)
		{
			vis[edge[i].t]--;
			//减完后没有入度了就入队 
			if(vis[edge[i].t]==0) q.push(edge[i].t);
		}
	}
	if(t != n) cout << -1;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin >> n >>m;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++){
		int x,y;
		cin >> x >> y;
		addedge(x,y);	
		vis[y]++;
	}
	tuopu();
	return 0;
}

 

---

最短路

dijkstra

//用确认的最短边去更新其他的点
//复杂度O((n+m)logm) 
//松弛：同一个点不同路，第二条路多一个点加起来比第一条短
//则要更新 
#include<bits/stdc++.h>
using namespace std;
#define maxm 500005
#define maxn 100005
int n,m,s,t,tot;
//每个点离起点的长度 
int dis[maxn];
//最短距离是否确认 
bool vis[maxn];
//存第i个点为起点的最后新增的边(edge下标) 
int head[maxn];

struct ty{
	//next存的是同一起点的不同边的edge下标
	//l为边长度
	//t存该边指向哪个点 
	int t,l,next;
}edge[maxm];

void addedge(int x,int y,int z)
{
	//长度 
	edge[++tot].l = z;
	//指向哪个点 
	edge[tot].t = y;
	//指向同一起点的最后加进来的边 
	edge[tot].next = head[x];
	//更新同一起点的最后加进来的边
	head[x] = tot;
}

struct ty2{
	//x表示该点 和 dis表示该点到下一个点的距离 
	int x,dis;
	//优先队列为大根堆 重载小于号
	//让路最短的排前面 
	bool operator < (const ty2 &a) const
	{
		return dis > a.dis; 
	}
}; 
priority_queue<ty2> q;
void dij()
{
	//for(int i=1;i<=n;i++) dis[i] = INT_MAX;
	memset(dis,0x3f,sizeof(dis));
	//设置为0x3f可以满足无穷大加无穷大等于无穷大
	//且可以用memset(是靠字节来初始化的而0x3f3f3f四个都是3f) 
	memset(vis,0,sizeof(vis));
	dis[s] = 0;
	q.push((ty2){s,0});
	while(!q.empty())
	{
		ty2 tmp = q.top();
		q.pop();
		if(vis[tmp.x]) continue;
		//确定该点的最短路了 
		vis[tmp.x] = 1;
		//用该点去更新其他点 
		for(int i=head[tmp.x]; i ;i = edge[i].next)
		{
			int y = edge[i].t;
			if(vis[y]) continue;
			//如果到x的最短路加上x到y的边的长度如果更小
			//则更新 
			if(dis[y] > dis[tmp.x] + edge[i].l)
			{
				dis[y] = dis[tmp.x] + edge[i].l;
				q.push((ty2){y,dis[y]}); 
			}
		} 
	}
} 

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin >> n >> m >> s;
	for(int i=1;i <= m;i++)
	{
		int x,y,z;
		cin >> x >> y >> z;
		addedge(x,y,z);
		//addedge(y,x,z); 
	}
	dij();
	for(int i=1;i<=n;i++) cout<<dis[i]<<" "; 
	return 0;
}

 

 SPFA

//Bellman-ford的队列优化
//Bellman-ford即无脑对每个点都入队做松弛 
//时间复杂度O(km) k为每个点的平均入队次数 
//SPFA可以处理负边权
//dij没办法 但没有负权边则同dij 
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000010,maxm = 5000010;
int n,m,s,t,tot;
//SPFA的vis是判断该点是否在队列里面
//dij是判断该点是否为最短路 
int dis[maxn],vis[maxn],head[maxn];
struct ty{
	int t,l,next;
}edge[maxm];

queue<int> q;

void addedge(int x,int y,int z)
{
	edge[++tot].l = z;
	edge[tot].t = y;
	edge[tot].next = head[x];
	head[x] = tot;
}

int spfa(int s,int t)
{
	memset(dis,0x3f,sizeof(dis));
	memset(vis,0,sizeof(vis));
	dis[s] = 0;
	vis[s] = 1;
	q.push(s); 
	while(!q.empty())
	{
		int x = q.front();
		q.pop();
		vis[x] = 0;
		for(int i=head[x];i != -1;i = edge[i].next)
		{
			int y = edge[i].t;
			if(dis[y] > dis[x] + edge[i].l)
			{
				//更新 
				dis[y] = dis[x] + edge[i].l;
				//接下来要用该点去更新其接下来的点
				//首先判断是否在队列里面
				//如果在队列里面则不用重复放进去
				//如果不在则插进去 
				if(!vis[y])
				{
					q.push(y);
					vis[y] = 1;
				}
			}
		}
	}
	if(dis[t] >= 0x3f3f3f3f) return -1;
	else return dis[t];
}
int main()
{
	ios::sync_with_stdio(false);
	cout.tie(0),cin.tie(0);
	memset(head,-1,sizeof(head));
	cin >> n >> m >> s >> t;
	for(int i=1;i<=m;i++){
		int x,y,z;
		cin >> x >> y >> z;
		addedge(x,y,z);
		//addedge(y,x,z);
	}
	cout << spfa(s,t);
	return 0;
}

 

---

最小生成树 

prim 

//在最小生成树里的点去拓展其他最短边的点 
//最小生成树 
//复杂度O((n+m)logm)
#include<bits/stdc++.h>
using namespace std;
int n,m,tot;
struct ty{
	int t,l,next;
}edge[2*500000+100];
int head[100010],dis[100010],ans=0;
//判断该点是否在最小生成树里面 
bool vis[100010];

struct ty2{
	int x,len;
	bool operator < (const ty2 &a) const{
		return len > a.len;
	}
};

priority_queue<ty2> q;
void addedge(int a,int b,int v)
{
	edge[++tot].t = b;
	edge[tot].l = v;
	edge[tot].next = head[a];
	head[a] = tot;
}
void prim()
{
	memset(dis,0x7f,sizeof(dis));
	vis[1] = 1;
	//把与起点相关的点都放进队列 
	for(int i=head[1];i != -1;i = edge[i].next)
	{
		//记录去该点的长度 方便与后来的边对比 
		dis[edge[i].t] = edge[i].l;
		q.push((ty2){edge[i].t,edge[i].l});
	}
	
	while(!q.empty())
	{
		ty2 tmp = q.top();
		q.pop();
		int x = tmp.x;
		if(vis[x])  continue;
		vis[x] = 1;
		ans += tmp.len;
		//把x相关的点扔进队列 
		for(int i=head[x];i != -1;i = edge[i].next)
		{
			//如果点已经在最小生成树里面就不用加 
			if(vis[edge[i].t]) continue;
			//优化 如果同一个点后来的那条边没有前面的短
			//则没有必要放进队列里面 
			if(dis[edge[i].t] > edge[i].l){
				q.push((ty2){edge[i].t,edge[i].l});
				dis[edge[i].t] = edge[i].l;
			}
		}
	}
	cout << ans;
}
int main()
{
	ios::sync_with_stdio(false);
	cout.tie(0),cin.tie(0);
	cin >> n >> m;
	memset(head,-1,sizeof(head));
	for(int i=1;i<=m;i++){
		int a,b,v;
		cin >> a >> b >> v;
		addedge(a,b,v);
		addedge(b,a,v);
	}
	prim();
	return 0;
} 

Kruskal 

//并查集 + 排序
//最小生成树 
//将最短的边排序
//若不构成环 
//则将最短边的两点连在一起 
//复杂度O(m*log(m)) 
#include<bits/stdc++.h>
using namespace std;
const int maxm = 5000010;
int n,m,ans=0;
int fa[100010];
struct ty{
	int x,y,z;
}edge[maxm];
bool comp(ty a,ty b)
{
	return a.z < b.z;
}
int find(int x)
{
	return fa[x] == x ? x : fa[x] = find(fa[x]);
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0),cout.tie(0);
	cin >> n >> m;
	for(int i=1;i<=n;i++) fa[i] = i;
	for(int i=1;i<=m;i++){
		cin >> edge[i].x >> edge[i].y >> edge[i].z;
	}
	sort(edge+1,edge+1+m,comp);
	for(int i=1;i<=m;i++){
		int fx = find(edge[i].x);
		int fy = find(edge[i].y);
		//如果成环(祖先已经相连)则跳过 
		if(fx == fy) continue;
		ans += edge[i].z;
		fa[fx] = fy;
	}
	cout << ans;
	return 0;
}