关于图论的几大算法(持续更新中)

dijstra的一般实现：

#include<stdio.h>
#include<vector>
#include<string.h>
#include<algorithm>
using namespace std;
typedef struct node{
	int num,value;
	node(int num,int value):num(num),value(value){
	}
}node;
vector<node> v[10000];
int n;
int dis[10000];
int pre[10000];
int vis[10000];
void dijstra(int num)
{
	memset(dis,-1,sizeof(dis));
	memset(pre,-1,sizeof(pre));
	dis[num]=0;
	for(int i=0;i<=n-1;i++)
	{
		int min=0x3f3f3f3f;
		int u;
		for(int j=0;j<=n-1;j++)
		{
			if(dis[j]<min&&dis[j]!=-1&&!vis[j])
			{
				min=dis[j];
				u=j;
			}
		}
		if(min==0x3f3f3f3f)
			break;
		vis[u]=1;
		for(int j=0;j<=v[u].size()-1;j++)
		{
			int num=v[u][j].num;
			int value=v[u][j].value;
			if(dis[num]>dis[u]+value||dis[num]==-1)
			{
				dis[num]=dis[u]+value;
				pre[num]=u;
			}
		}
	}
}
void find(int num,bool flag)
{
	if(pre[num]!=-1)
	{
		find(pre[num],0);
		printf("%d",num);
	}
	else
	{
		printf("%d",num);
	}
	if(!flag)
	{
		printf("->");
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<=n-1;i++)
	{
		for(int j=0;j<=n-1;j++)
		{
			int value;
			scanf("%d",&value);
			if(value>0)
			{
				v[i].push_back(node(j,value));
				v[j].push_back(node(i,value));
			}
		}
	}
	dijstra(0);
	for(int i=0;i<=n-1;i++)
	{
		printf("第%d个点的最短路径长: %d ,",i,dis[i]);
		printf("路径为: ");
		find(i,1);
		printf("\n");
	}
	return 0;
}

dijstra的二叉堆优化实现：

#include<stdio.h>
#include<vector>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
typedef struct node{
	int num,value;
	node(int num,int value):num(num),value(value){
	}
	friend bool operator<(const node &a,const node &b);
}node;
bool operator<(const node &a,const node &b)
{
	return a.value<b.value;
}
vector<node> v[10000];
int n;
int dis[10000];
int pre[10000];
int vis[10000];
void dijstra(int num)
{
	memset(dis,-1,sizeof(dis));
	memset(pre,-1,sizeof(pre));
	dis[num]=0;
	priority_queue<node> q;
	q.push(node(num,0));
	while(!q.empty())
	{
		node tmp=q.top();
		q.pop();
		if(vis[tmp.num])continue;
		for(auto iter=v[tmp.num].begin();iter!=v[tmp.num].end();iter++)
		{
			if(dis[iter->num]>dis[tmp.num]+iter->value||dis[iter->num]==-1)
			{
				dis[iter->num]=dis[tmp.num]+iter->value;
				pre[iter->num]=tmp.num;
				q.push(node(iter->num,dis[iter->num]));
			}
		}
	}
}
void find(int num,bool flag)
{
	if(pre[num]!=-1)
	{
		find(pre[num],0);
		printf("%d",num);
	}
	else
	{
		printf("%d",num);
	}
	if(!flag)
	{
		printf("->");
	}
}
int main()
{
	scanf("%d",&n);
	for(int i=0;i<=n-1;i++)
	{
		for(int j=0;j<=n-1;j++)
		{
			int value;
			scanf("%d",&value);
			if(value>0)
			{
				v[i].push_back(node(j,value));
				v[j].push_back(node(i,value));
			}
		}
	}
	dijstra(0);
	for(int i=0;i<=n-1;i++)
	{
		printf("第%d个点的最短路径长: %d ,",i,dis[i]);
		printf("路径为: ");
		find(i,1);
		printf("\n");
	}
	return 0;
}

Bellman-Ford的一般实现：

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;
#define INF 0x3f3f3f3f
typedef struct edge{
	int u,v,w;
	edge(int u,int v,int w):u(u),v(v),w(w){
	}
}edge;
vector<edge> E;
int dis[10000];
int pre[10000];
int n,m;
bool BF(int s)
{
	memset(pre,-1,sizeof(pre));
	for(int i=0;i<=n-1;i++)
	{
		if(i!=s)
		{
			dis[i]=INF;
		}
		else
		{
			dis[i]=0;
		}
	}
	for(int i=1;i<=n-1;i++)
	{
		bool flag=false;
		for(auto it=E.begin();it!=E.end();it++)
		{
			if(dis[it->v]>dis[it->u]+it->w)
			{
				dis[it->v]=dis[it->u]+it->w;
				pre[it->v]=it->u;
				flag=1;
			}
		}
		if(!flag)return true;
	}
	for(auto it=E.begin();it!=E.end();it++)
	{
		if(dis[it->v]>dis[it->u]+it->w)
			return false;
		
	}
	return true;
}
void find(int x,bool end)
{
	if(pre[x]==-1)
	{
		printf("%d",x);
	}
	else
	{
		find(pre[x],0);
		printf("%d",x);
	}
	if(!end)
	{
		printf("->");
	}
}
int main()
{
	scanf("%d %d",&n,&m);
	for(int i=0;i<=m-1;i++)
	{
		int u,v,w;
		scanf("%d %d %d",&u,&v,&w);
		E.push_back(edge(u,v,w));
	}
	if(BF(0))
	{
		for(int i=0;i<=n-1;i++)
		{
			printf("第%d点的最短路径: %d ,路径为: ",i,dis[i]);
			find(i,1);
			printf("\n");
		}
	}
	else
	{
		printf("含负权回路\n");
	}
	return 0;
}

kruskal的一般实现：

#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
int fa[10000];
int n,m;
typedef struct edge{
	int u,v,w;
	edge(int u,int v,int w):u(u),v(v),w(w){
	}
}edge;
priority_queue<edge> q;
int tot,cnt;
bool operator<(const edge &a,const edge &b)
{
	return a.w>b.w;
}
void init()
{
	for(int i=0;i<=n-1;i++)fa[i]=i;
	
}
int find(int x)
{
	if(fa[x]==x)return x;
	return fa[x]=find(fa[x]);
}
void merge(int x,int y)
{
	fa[find(y)]=find(x);
}
int kruskal()
{
	init();
	int res=0;
	while(!q.empty())
	{
		edge tmp=q.top();
		q.pop();
		int x1=tmp.u;
		int x2=tmp.v;
		if(find(x1)==find(x2))
			continue;
		merge(x1,x2);
		cnt++;
		res+=tmp.w;
		if(cnt==n-1)
			break;
	}
	return res;
}
int main()
{
	scanf("%d %d",&n,&m);
	for(int i=0;i<=m-1;i++)
	{
		int u,v,w;
		scanf("%d %d %d",&u,&v,&w);
		q.push(edge(u,v,w));
	}
	
	int res=kruskal();
	printf("%d",res);
	return 0;
}

prim的二叉堆优化实现

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<vector>
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
typedef struct edge{
	int v,w;
	edge(int v,int w):v(v),w(w){
	}
}edge;
bool operator<(const edge&a,const edge&b)
{
	return a.w>b.w;
}
priority_queue<edge> q;
vector<edge> G[10000];
bool vis[10000];
int prim()
{
	int ans=0,cnt=0;
	q.push(edge(0,0));
	while(!q.empty())
	{
		edge tmp=q.top();
		q.pop();
		if(vis[tmp.v])
			continue;
		vis[tmp.v]=1;
		cnt++;
		ans+=tmp.w;
		if(cnt==n)
			break;
		for(auto it=G[tmp.v].begin();it!=G[tmp.v].end();it++)
		{
			if(!vis[it->v])
			{
				q.push(edge(it->v,it->w));
			}
		}
	}
	return ans;
	
}
int main()
{
	scanf("%d %d",&n,&m);
	for(int i=0;i<=m-1;i++)
	{
		int u,v,w;
		scanf("%d %d %d",&u,&v,&w);
		G[u].push_back(edge(v,w));
		G[v].push_back(edge(u,w));
	}
	int res=prim();
	printf("%d",res);
	return 0;
}