图论总结（6）最短路问题

最短路就是求图中两点的最短距离

最短路的算法这里写三种

一.Floyed-Warshall算法(O(N^3))

这是求最短路最简单的算法（求出所有点的最短路，适用于负权边，但不适用与负权回路）

int G[maxn][maxn],pre[maxn][maxn];int n;void print(int x,y){if(pre[x][y]==0)return;print(x,pre[x][y]);cout<<"->"<<y;}void floyed(){for(int k=1;k<=n;i++)for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(i!=j&&j!=k&&k!=j)if(d[i][j]>d[i][k]+d[k][j]){d[i][j]=d[i][k]+d[k][j];pre[i][j]=pre[k][j];}}

邻接矩阵储存，pre记录路径,注意将d数组初始化为一个很大的数。

还可以用floyed来判断连通性。

void floyed(){for(int k=1;k<=n;i++)for(int i=1;i<=n;i++)for(int j=1;j<=n;j++)if(i!=j&&j!=k&&k!=j)d[i][j]=d[i][j]||(d[i][k]&&d[k][j]);} 

二.Dijkstra(O(N^2))

单源最短路。

不能处理负权边。

算法原理就不讲了，教科书上有，直接上模板

（可以用优先队列优化，这里就不优化了）

int w[maxn][maxn],pre[maxn];int n,s,e;bool b[maxn],d[maxn];void print(int x){if(pre[x]==0)return ;print(pre[x]);cout<<"->"<<x;}void Dijkstra(){memset(b,0,sizeof(b));for(int i=1;i<=n;i++)d[i]=INF;d[s]=0;for(int i=1;i<=n;i++){int minl=INF;int k=0;for(int j=1;j<=n;j++)if(!b[j]&&(d[j]<minl)){minl=d[j];k=j;}if(k==0)break;b[k]=true;for(int j=1;j<=n;j++)if(d[k]+w[k][j]<d[j]){d[j]=d[k]+w[k][j];pre[j]=k;}}}

我反正一般不用Dijkstra算法，觉得BellmanFord更好，特别是优化了过后。

三.Bellman-Ford算法O（NE）

单源最短路 

可以处理负权边，不能处理负权回路。

直接给优化成SPFA常用的算法。

模板：

struct Edge{int from,to,dist;Edge(int f,int t,int d):from(f),to(t),dist(d){}};vector<Edge>edges;vector<int>G[maxn];int vis[maxn],d[maxn],cnt[maxn],pre[maxn],n;void add_Edge(int f,int t,int d){edges.push_back(Edge(f,t,d));int m=edges.size();G[f].push_back(m-1);}bool Bellman_Ford(int s){queue<int>q;memset(cnt,0,sizeof(cnt));memset(vis,0,sizeof(vis));for(int i=1;i<=n;i++)d[i]=INF;d[s]=0;vis[s]=true;q.push(s);while(!q.empty()){int u=q.front();vis[u]=false;for(int i=0;i<G[u].size();i++){Edge& e=edges[G[u][i]];if(d[u]<INF&&d[e.to]>d[u]+e.dist){d[e.to]=d[u]+e.dist;pre[e.to]=G[u][i];if(!vis[e.to]){vis[e.to]=1;q.push(e.to);if(++cnt[e.to]>n)return false;}}}}return true;}

用cnt数组判断是否有负权回路，应为每个点入队了n次时则有负权回路