最短路模板

朴素版Dijkstra

#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
#define inf 0x3f3f3f
const int N=510;
int n,m;
int mp[N][N];
int dis[N];
bool vis[N];
int dijkstra()
{
	memset(vis,0,sizeof vis);
	for(int i=1;i<=n;i++)
		dis[i]=mp[1][i];
	vis[1]=1;
	for(int i=1;i<n;i++)
	{
		int mini=inf,u;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&dis[j]<mini)
			{
				mini=dis[j];
				u=j;
			}
		}
		vis[u]=1;
		for(int j=1;j<=n;j++)
		{
			if(!vis[j]&&dis[j]>dis[u]+mp[u][j])
				dis[j]=dis[u]+mp[u][j];
		}
	}
	for(int i=1;i<=n;i++)
	{
		if(dis[i]==inf) printf("%d:-1\n",i);
		else printf("%d:%d\n",i,dis[i]);
	}
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
			mp[i][j]=inf;
		mp[i][i]=0;
	}
	for(int i=0;i<m;i++)
	{
		int a,b,v;
		scanf("%d%d%d",&a,&b,&v);
		mp[a][b]=mp[b][a]=v;
	}
	dijkstra();
	return 0;
}

堆优化版

#include<iostream>
#include<algorithm>
#include<string.h>
#include<queue>
#include<cmath>
#include<cstdio>
#define inf 0x3f3f3f
using namespace std;
typedef long long ll;
const int N = 1e3+5;
struct Edge{
	int next,to,val;
}edge[N*N];
struct node{
	int dis,id;
	node(){}
	node(int a,int b)
	{
		dis = a;
		id = b;
	}
};
bool operator < (const node a,const node b)
{
	return a.dis > b.dis;
}
int cnt=0,head[N*N],n,m,dis[N],vis[N];
void add(int u,int v,int val)
{
	edge[cnt].to = v;
	edge[cnt].val = val;
	edge[cnt].next = head[u];
	head[u] = cnt++;
}
void dijkstra()
{
	priority_queue<node> q;
	node temp;
	q.push(node(0,1));
	memset(dis,inf,sizeof(dis));
	dis[1] = 0;
	while(!q.empty())
	{
		temp = q.top();
		q.pop();
		if(vis[temp.id])
			continue;
		vis[temp.id] = 1;
		for(int i=head[temp.id];i!=-1;i=edge[i].next)
		{
			int num = edge[i].to;
			if(!vis[num] && dis[num] > dis[temp.id] + edge[i].val)
			{
				dis[num] = dis[temp.id] + edge[i].val;
				q.push(node(dis[num],num));
			}
		}
	}
}
int main()
{
	scanf("%d%d",&m,&n);
	memset(head,-1,sizeof(head));//勿忘 
	for(int i=0;i<m;i++)
	{
		int u,v,val;
		scanf("%d%d%d",&u,&v,&val);
		add(u,v,val);
		add(v,u,val);
	}
	dijkstra();
	printf("%d",dis[n]);
	return 0;
}

bellman_ford

#include<iostream>
#include<cstdio>
#include<string.h>
using namespace std;
#define inf 0x3f3f3f3f
int n,m,cnt;
int dis[510];
struct Edge{
	int a,b,w;//起点，终点，权值 
}edge[10005];
void add(int a,int b,int w)
{
	edge[cnt].a = a;
	edge[cnt].b = b;
	edge[cnt].w = w;
	cnt++;
}
int bellman_ford()
{
	memset(dis,inf,sizeof dis);
	dis[1] = 0;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<cnt;j++)
		{
			int a = edge[j].a;
			int b = edge[j].b;
			int w = edge[j].w;
			dis[b] = min(dis[b],dis[a]+w);
		}
	}
	if(dis[n] == inf) return -1;
	return dis[n];
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--)
	{
		cnt=0;
		scanf("%d%d",&n,&m);
		for(int i=0;i<m;i++)
		{
			int a,b,w;
			scanf("%d%d%d",&a,&b,&w);
			add(a,b,w);
			add(b,a,w);
		}
		int ans = bellman_ford();
		if(ans == -1) printf("impossible\n");
		else printf("%d\n",ans);
	}
	return 0;
}

spfa

#include<iostream>
#include<cstdio>
#include<string.h>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3f
const int N=1e3+5;
int n,m,cnt,dis[N],head[N*N];
bool vis[N];
struct Edge{
	int to,w,nxt;
}edge[N*N];
void add(int a,int b,int w)
{
	edge[cnt].to = b;
	edge[cnt].w = w;
	edge[cnt].nxt = head[a];
	head[a] = cnt++;
}
int spfa()
{
	memset(vis,0,sizeof vis);
	memset(dis,inf,sizeof dis);
	dis[1] = 0;
	queue<int> q;
	q.push(1);
	vis[1] = 1;
	while(!q.empty())
	{
		int t = q.front();
		q.pop();
		vis[t] = 0;
		for(int i=head[t];i!=-1;i=edge[i].nxt)
		{
			int j = edge[i].to;
			if(dis[j] > dis[t] + edge[i].w)
			{
				dis[j] = dis[t] + edge[i].w;
				if(!vis[j])
				{
					q.push(j);
					vis[j] = 1;
				}
			}
		}
	}
	if(dis[n] == inf) return -1;
	return dis[n]; 
}
int main()
{
	cnt = 0;
	scanf("%d%d",&m,&n);
	memset(head,-1,sizeof head);
	for(int i=0;i<m;i++)
	{
		int a,b,w;
		scanf("%d%d%d",&a,&b,&w);
		add(a,b,w);
		add(b,a,w);
	}
	int ans = spfa();
	if(ans == -1) printf("impossible\n");
	else printf("%d\n",ans);
	return 0;
}