图论之 最短路

图论之最短路
一、求最短路方法（对于一个包含环的图）
1、Dijkstra
2、Bellman-ford
3、SPFA
4、Floyd
二、Dijkstra思想（求单源点最短路，不含负边权）
1、设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径, 就将其加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。

在加入的过程中，总保持从源点v 到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。

此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。

2、Dijkstra步骤
（1）初始时，S只包含源点，即S＝v，距离为0。

U包含除v外的其他顶点，U 中顶点u距离为边上的权；
（2）从U中选取一个距离v最小的顶点k，把k加入S中（该选定的距离就是v到k的最短路径长度）；
（3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值为经过顶点k的值（松弛操作）；
（4）重复步骤（2）和（3）直到所有顶点都包含在S中。

3、Dijkstra两种实现方法
（1）邻接矩阵+找最小边
（2）邻接表+优先队列
关键：松弛操作
if(d[v]>d[u]+e[u][v].w)
d[v]=d[u]+e[u][v].w
4、Dijkstra 稠密图的邻接矩阵
for(int i=0;i<n;i++)//一共寻找n个点的最小dis
{
int x,m=inf;
for(int y=0;y<n;y++)if(!vis[y]&&dis[y]<=m)
m=dis[y];x=y;
vis[x]=1;
for(int y=0;y<n;y++)if(dis[y]>dis[x]+w[x][y])
dis[y]=dis[x]+w[x][y];
}
5、邻接链表+优先队列
memset(dis,127,sizeof(dis));
dis[1]=0;
q.push(make_pair(dis[1],1));
while(!q.empty())
{
int u=q.top().second;q.pop();
if(vis[u]) continue;
vis[u]=1;
for(int k=head[u];k!=-1;k=e[k].next)
{ if(dis[e[k].v]>dis[u]+e[k].w)
{ dis[e[k].v]=dis[u]+e[k].w;
q.push(make_pair(dis[e[k].v],e[k].v));
}
}
}
6、路径输出
方法一：从终点出发，不断顺着dis[y]==dis[x]+w[x][y]的边从y回到x，直到回到起点，但更好的方法是
方法二：在更新时维护father指针
for(int y=0;y<n;y++)
if(dis[y]>dis[x]+w[x][y])
father[y]=x;
7、邻接表+优先队列的dijkstra
（1）根据算法，我们需要在找到最短dis的节点序号v，所以入队的一个元素包含dis和v两部分，那么我们使用pair将捆绑两个整形:typedef pair <int,int> pii （2）然后定义一个pii型的从小到大排列的优先队列(priority_queue <pii,vector<pii>,greater<pii> > q; )
（3）注意：此时在元素入队时要加make_pair。

如将(d[1],0)入队：q.push(make_pair(d[1],0));
（4）邻接矩阵的算法显然是O(N^2)的
稀疏图的邻接表
如果一个图的顶点很多，那它往往是稀疏图，那么使用邻接表和优先队列可以优化到O(MlogN)。

三、Bellman-ford（思想求单源点最短路，可含负边权）
1、算法步骤：
（1）初始化：将除源点外的所有顶点最短距离估计值d[v]=inf,d[s]=0；
（2）迭代求解：反复对边集E中每条边进行松弛操作，使得顶点集V中每个顶点v的最短距离估计值逐步逼近其最短距离；
（3）检验负权回路：如果有存在点v，使得d[v]>d[u]+w[u][v],则有负权回路，返回false；
（4）返回true，源点到v的最短距离保存在d[v]中。

2、伪代码
bool bellman-ford(G,w,s)
{
for each vertex in V(G)d[v]=inf;d[s]=0;
for(i=1;i<v;i++)//执行v-1次操作
for if(d[v]>d[u]+w[u][v])d[v]=d[u]+w[u][v];
for each edge(u,v) in E(G)//v-1次松弛结束若还可以松弛，则有负环
if(d[v]>d[u]+w[u][v])return false;
return true;
}
四、SPFA思想（使用队列优化后的Bellman-ford）
1、用一个队列来进行维护。

流程：初始时，将源点入队，每次从队列中取出一个元素，并对其所有与他相邻的点进行松弛，若某个相邻的点松弛成功，则将其入队，直到队列为空时算法结束。

可以证明用队列维护的Bellman-Ford最坏情况下时间为O(nm)，通常时间为O(km)，其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

2、伪代码
q.push(s);vis[s]=1;
void spfa()
{
while(!q.empty())
u=q.front();q.pop();vis[u]=0;//出队标记
for each v in adj(u)
{if(dis[v]>d[u]+w[u][v])
{
dis[v]=d[u]+w[u][v];
if(!vis[v]){q.push(v);vis[v]=1;}
}
}
五、floyd思想（求各点间的最短路，可含负边权）
1、动态规划原理
设d(i,j)为从i到j的只以(1…k)集合中的节点为中间点的最短路的长度；
（1）若经过k，d(i,j)=d(i,k)+d(k,j)
（2）若不经过k(可能经过1~k-1中的点），d(i,j)=d(i,j)
则d(i,j)=min(d(i,k)+d(k,j), d(i,j))
2、伪代码
for(k=0;k<n;k++)//k代表中间点必须放最外层
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if(d[i][j]>d[i][k]+d[k][j])
d[i][j]= d[i][k]+d[k][j];
注：初始时，d[i][i]=0,其他d值为inf
六、三种最短路算法
1、dijkstra(单源点最短路)：贪心的思想，每次从集合U中找一个离源点最近的点加入到集合S中，并以新加入的点作为中间点松弛U中的点到源点的距离。

直到U为空算法结束。

使用优先队列优化。

队列中存储的是U中点的子集。

不能处理负权存在的情况。

复杂度远小于O(M*N)，因为贪心所以速度三者中最快,用二项堆优化到O(ElogV)。

2、Bellman-Ford (单源点最短路)：对所有边，进行k遍松弛操作，就会计算出与源点最多由k条边相连的点的最短路。

因为最短路一定不含环，所以最多包含n-1条边，那么我们进行n-1遍松弛操作就可以计算出所有点的最短路。

每次计算时，那些已经算出来最短路的点不用重复计算，可使用队列优化(SPFA)。

可含负边权。

复杂度为远小于O(M*N)
3、Floyd(多源点最短路)：点i到j的最短路有两种情况，1：i直接到j，2：i经过k到j，所以对于每个中间点k，枚举它的起点和终点，进行松弛操作，最终将得到所有点的最短路。

邻接矩阵存储，可含负边权。

复杂度O(N^3)，
七、传递闭包
1、有向图的传递闭包表示由邻接矩阵A求得的所有节点间的路径可达情况，无向图同样适用。

因为要求各点间的可达情况，所以使用Floyd。

for(k=0;k<n;k++)//中间点放最外层
for(i=0;i<n;i++)
for(j=0;j<n;j++)
d[i][j]=d[i][j]||(d[i][k]&&
d[k][j]);
2、如果把检查所有节点k放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把i到j的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。

3、图中红色的数字代表边的权重。

如果我们在最内层检查所有节点X，那么对于A->B，我们只能发现一条路径，就是A->B，路径距离为9。

而这显然是不正确的，真实的最短路径是A->D->C->B，路径距离为6。

造成错误的原因就是我们把检查所有节点X放在最内层，造成过早的把A到B的最短路径确定下来了，当确定A->B的最短路径时Dis(AC)尚未被计算。