最短路模板

1、floyd-warshall

思路

枚举中转站
时间复杂度：(O(n^3))
使用范围：多源点最短路

#include<bits/stdc++.h>
using namespace std;
int e[100][100],k,i,j,n,m,t1,t2,t3;
const int inf=99999;
int main()
{
	cin>>n>>m;
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j)e[i][j]=0;
				else e[i][j]=inf;
    for(i=1;i<=m;i++)
    {
    	cin>>t1>>t2>>t3;
    	e[t1][t2]=t3;
	}
	
	for(k=1;k<=n;k++)
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
				if(e[i][j]>e[i][k]+e[k][j])
				e[i][j]=e[i][k]+e[k][j];
	for(i=1;i<=n;i++)
	{
		for(j=1;j<=n;j++)
		{
			printf("%ld ",e[i][j]);
		}
	}
	return 0;
}

2、Dijkstra算法

思路：

bfs的思路，从s的邻边开始，选出最短边，再从下一个起点开始，选最短边，期间不停地更新dis，
，此时按照贪心的原理，每次选择离s最短的作为起点，标记后dis不必更新。
使用范围：无负权值的单源点最短路
时间复杂度：(O(n^2))

#include <iostream>
#include <vector>
using namespace std;
struct edge{int to;int cost;};
vector<edge>g[50005];//相当于一个二维数组，存储edge 
int d[50005];
int vis[50005];
int n;
const int inf=2147483647;
int djs(int s)
{   
    int min1,k;
    for(int i=1;i<=n;i++) d[i]=inf;
        d[s]=0;//初始化 
        for(int i=1;i<n;i++)
        {
            min1=inf;k=s;

            for(int j=1;j<=n;j++)//寻找离源点最近的且未标记点
            if (!vis[j]&&min1>d[j])
                {min1=d[j];k=j;}
            vis[k]=1;//标记
            for(int j=0;j<g[k].size();j++)//重点j从0开始更新未标记的终点to
            {  
				int tm=g[k][j].to;
                if(!vis[tm]&& min1+g[k][j].cost<d[tm])
                    d[tm]=min1+g[k][j].cost; 
            }
        }
     return 0;

}

int main()
{   
	ios::sync_with_stdio(false);
    int m,s,x;
    cin>>n>>m>>s;//输入点边源
    edge tmp;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>tmp.to>>tmp.cost;
        g[x].push_back(tmp);//压入g[起点]
    }
    djs(s);
    for(int i=1;i<=n;i++)
        cout<<d[i]<<" ";

    return 0;
}

堆优化的djs

djs的思路是每次取出dis最小的点，以它为起点更新dis，并且把这个点标记为已知，那么就可以用堆得数据结构降低时间复杂度，取出最小点，并将与之连接的点放入堆中，直至堆空

#include<bits/stdc++.h>
#define re register
using namespace std;
struct edge
{
    int to,cost;
};
vector<edge>g[500005];//定义路径结构体
int n,m,s;
int dis[500005];
struct node//定义堆结构体
{
	//（如果看不懂）https://www.cnblogs.com/ZERO-/p/9347296.html
	int u,d;
	bool operator<(const node&rhs)const
	{
		return d>rhs.d;
	}
};
inline void djs()
{
	for(re int i=1;i<=n;i++)dis[i]=2147483647;
	dis[s]=0;
	priority_queue<node>Q;//初始化
	
	node a ={s,0};
	Q.push(a);//第一个node
	
	while(!Q.empty())
	{
		node fr=Q.top();Q.pop();
		int u=fr.u,d=fr.d;
		//取出并记录
		if(d!=dis[u])continue;//避免处理无用数据，也就是dis[u]已经更新，之前未更新数据直接出栈，比如有一组数据 2 5，但是后面又入栈一组数据2 3，则2 5是无用数据
		for(re int j=0;j<g[u].size();j++)
		{
			int tm=g[u][j].to;
			if(dis[u]+g[u][j].cost<dis[tm])
			{			 
            	dis[tm]=dis[u]+g[u][j].cost;
				Q.push((node){tm,dis[tm]});
			}
		}
	}
}
int main()
{
	cin>>n>>m>>s;
	int x;
	for (re int i=1;i<=m;i++)
	{
        edge tmp;
      	cin>>x>>tmp.to>>tmp.cost;
        g[x].push_back(tmp);   
    }
    djs();
 	for (re int i=1;i<=n;i++)
  	printf("%d ",dis[i]);    
	return 0;
}

3、动态规划

思路

更新更新

#include<bits/stdc++.h>
using namespace std;
long long dis[10100];
int u[500100],v[500100],w[500100],n,m,s,check;//我们定义一个check，优化用 
const int inf=2147483647;
int main()
{
    cin>>n>>m>>s;//输入 
    for(int i=1;i<=m;i++)
        cin>>u[i]>>v[i]>>w[i];//读入边 
    for(int i=1;i<=n;i++)
        dis[i]=inf;//dis数组初始化 
    dis[s]=0;
    for(int k=1;k<=n-1;k++)
    {
        check=0;//check归零 
        for(int i=1;i<=m;i++)
        {
            if(dis[v[i]]>dis[u[i]]+w[i])
            {
                dis[v[i]]=dis[u[i]]+w[i];
                check=1;//如果dis数值改变，check赋值为1 
            }   
        }
        if(check==0)
            break;//如果没变，直接跳出循环，不要浪费时间 
    }
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";//输出 
    return 0;//好习惯
}

4、SPFA算法

P3385 【模板】负环

#include<bits/stdc++.h>
const long long inf=2147483647;
const int maxn=10005;
const int maxm=500005;
using namespace std;
int n,m,s,num_edge=0;
int dis[maxn],vis[maxn],head[maxm];
struct Edge
{
  int next,to,dis;
}edge[maxm]; //结构体表示静态邻接表
void addedge(int from,int to,int dis) //邻接表建图
{ //以下是数据结构书上的标准代码，不懂翻书看解释
  edge[++num_edge].next=head[from]; //链式存储下一条出边
  edge[num_edge].to=to; //当前节点编号
  edge[num_edge].dis=dis; //本条边的距离
  head[from]=num_edge; //记录下一次的出边情况
}
void spfa()
{
  queue<int> q; //spfa用队列，这里用了STL的标准队列
  for(int i=1; i<=n; i++) 
  {
    dis[i]=inf; //带权图初始化
    vis[i]=0; //记录点i是否在队列中，同dijkstra算法中的visited数组
  }
  q.push(s); dis[s]=0; vis[s]=1; //第一个顶点入队，进行标记
  while(!q.empty())
  {
    int u=q.front(); //取出队首
    q.pop(); vis[u]=0; //出队标记
    for(int i=head[u]; i; i=edge[i].next) //邻接表遍历，不多解释了（也可用vector代替）
    {
      int v=edge[i].to; 
      if(dis[v]>dis[u]+edge[i].dis) //如果有最短路就更改
      {
        dis[v]=dis[u]+edge[i].dis;
        if(vis[v]==0) //未入队则入队
        {
          vis[v]=1; //标记入队
          q.push(v);
        }
      }
    }
  }
}
int main()
{
  cin>>n>>m>>s;
  for(int i=1; i<=m; i++)
  {
    int f,g,w;
    cin>>f>>g>>w; 
    addedge(f,g,w); //建图，有向图连一次边就可以了
  }
  spfa(); //开始跑spfa
  for(int i=1; i<=n; i++)
    if(s==i) cout<<0<<" "; //如果是回到自己，直接输出0
      else cout<<dis[i]<<" "; //否则打印最短距离
  return 0;
} //结束

vector版本的spfa

struct edge
{
	int v,w;
};
vector<edge>g[10001];
int d[10001];
int times[10001];
bool vis[10001];
queue<int>q;
int n;
void spfa(int s)
{
	memset(vis,0,sizeof(vis));
	memset(d,inf,sizeof(d));
	memset(times,0,sizeof(times));
	while(!q.empty())q.pop();
	q.push(s);
	vis[s]=1;
	d[s]=0;
	times[s]=1;
	while(!q.empty())
	{
		int now=q.front();
		q.pop();
		vis[now]=0;
		for(int j=0;j<g[now].size();j++)
		{
			edge p=g[now][j];
			if(d[p.v]>d[now]+p.w)
			{
				d[p.v]=d[now]+p.w;
				times[p.v]++;
				debug(times[p.v]);
				if(times[p.v]>n)
				{
					puts("YES");
					return;
				}
				if(!vis[p.v])
				{
					q.push(p.v);
					vis[p.v]=1;;
				}
			}
		}
	}
	puts("NO");
}
main(void)
{
	int t=read(),m;
	for(re int i=1;i<=t;i++)
	{
		n=read();
		m=read();
		int u,v,w;
		for(re int j=1;j<=m;j++)
		{
			edge t;
			u=read(),v=read(),w=read();
			t.v=v;
			t.w=w;
			g[u].push_back(t);
			t.v=u;
			if(w>=0)g[v].push_back(t);
		}
		spfa(1);
		for(int j=1;j<=n;j++)
			g[j].clear();
	}
}

参考：题解