最短路算法的证明_最短路四大算法证明以及分析（Flord Bijkstra Bellman-ford SPFA）...

此博文不具体给出其算法的代码，只对其中算法进行分并且给予证明

PS：这些算法我不用证明都是它是正确的(上世纪的数学家看着这些都不用证明，为啥，很简单的)，但是我坚持重新证明一遍实际是为了加深印象，并且理解其中的道理和思想，这样在以后的运用中才能灵活运用，当然证明这些算法也

算法一：Flord 算法，也是传说中的只用五行就可以解决的多源最短路径问题

采用邻接矩阵来储存图，时间复杂度为O(n^3)，能解决含正权，负权的最短路径，不能解决含有负环的最短路径(负环也没有最短路径)

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];

当k=1时进行一个嵌套的for循环求出来的是任意两点之间只允许经过点1的最短路径，这个都可以理解吧。

(￣▽￣)"

当k=2时，经过一个if else的判断最终求出来的是任意两个顶点之间只允许经过1 2号顶点的最短路径。

这时候可能有人说在进行 if      else 之后判断的是i->j通过2号顶点路径后路径能否缩小，那么如果i->j还能通过1号顶点再次缩小路径，那还能体现出来吗？

好的下面咱们来证明

假设咱们判断过之后i->j之间通过2号顶点可以缩小路径，此时i与j的路径为i->2->j，假设还可以通过1号顶点缩小路径(也就是上面所说的情况)

此时1号顶点肯定在i->j之间，也就是i->2或2->j之间 ，而咱们在第一次for循环之后的意义上面已经说过了，即任意两点可以经过1号顶点后更新的最短路径，那么回过来即i->2之间或者2->j之间若可以经过1号顶点在缩短路径，那么铁定在第一次循环后就已经在i->2或2->j之间添加1号顶点了，所以上面的担心是多余的(●'◡'●)

当k=2的循环结束后，得到的意义便是任意两个顶点只允许经过1 2号顶点的最短路径

当k=n时  循环结束后便是任意两点之间允许经过1~n个顶点后的最短路径，(如果有疑问，那么再按着刚刚在2号顶点的证明过程比较一下)

算法二：dijkstra算法 (求单源最短路径，只允许正权)

这个是比较常用的算法，其常用的储存图的方式有邻接矩阵，邻接表两种。采用邻接矩阵的时间复杂度为O(n^2)

在此用邻接矩阵来举例子

先说一下算法原理，初始化就不说了吧(任意两点之间之间路径为INF，自己与自己的路径为0)随后输入图。

用一个dis[]数组记录源点到其他点的直接路径。假设源点号为S，并且用数组book[]来表示s->其他点的最短路径是否确定，确定的点令其值为1(book[s]=1)。

然后从dis[]数组找s->v最小的值，假设为这个顶点为u，那么s->u的最短路径肯定就确定了。为啥 ？因为s->u若再经过其他点所成的路径一定比s->u的路径的大。

已经确定s->u是最短路径后，松弛u点到其他点的路径,令book[u]=1。(这点是关键)

所以算法分三个步骤

1.然后再从dis[]从最短路径未确定的路径找出的最小值，令其为确定的最短路径(假设这个顶点是u)，令book[u]=1;(证明下面在说)

2.从u点松弛

3.重复以上1. 2点直至所有点的最短路径确定。

也许有很多人对第1步有些不解。为什么从中找出的符合条件的u的最短路径一定确定了呢？别急下面来证明

看这个图

第一次  找出s->a最小，那么令此时s->a的路径为最短路径，令book[2]=1，(这个都没疑问吧)...... 然后松弛a->b得到mid=dis[a]+map[a][b]b的路径变小了

第二次，再次按步骤1找出最小的为dis[b]，此时的dis[b]为s->b的最短路径。为啥？假设此时dis[b]的值不是s->b的最短路径，那么要想找s->b的更小路径至少中转至一个顶点v，且s->v的距离满足dis[v]b的路径一定>=dis[b]，

也就是下面这个原理

u为此时经过步骤1确定的点，假设s->u的距离不是最短路径，即存在另一条路径s->v->u(你也可以假设s->v之间还有许多点，但是我们要确保v->u是直接的，即不经过任何一个中转点)使得路径长度mid

又因为假设的路径中v是在s->u之间，所以v的最短路径已经确定且v经过松弛，即v到任何点的都经过松弛(包括点u)，所以此时我们找的mid是一定>=dis[u]的，即假设不成立。

所以你就默认他们是最短路径这一事实吧(￣▽￣)"

代码：

附上dijkstr算法

/*

dijkstr 算法

二步：

1.初始化

2.每次找出dis最小值则为确定对短路

注意：minn=INF 或者找到答案这一提前跳出

*/

#include

#include

#include

#include

#include

#include

#include

#define N 1010

#define INF 0x3f3f3f3f

#define MOD 1000000007

#define WC 1e-6

typedef long long LL;

using namespace std;

int book[N],dis[N],map[N][N];

void dijkstr(int n)

{

int t=n,minn,u,to;

memset(book,0,sizeof(book));

for(int i=1;i<=n;i++)

dis[i]=INF;

dis[1]=0;

while(t--)

{

minn=INF;

for(int i=1;i<=n;i++)

{

if(!book[i]&&dis[i]

{

u=i;

minn=dis[i];

}

}

book[u]=1;

for(int i=1;i<=n;i++)//松弛

{

if(!book[i])

{

to=dis[u]+map[u][i];

if(to

dis[i]=to;

}

}

}

}

int main()

{

//cin map 就OK

}

有时间再补充另两个算法的证明

附上SPFA代码/*

SPFA

三步

1.初始信息 将初始点加入队列

2.每次从队列的第一个点进行松弛，可以更新另一个点则将其加入队列(已经加入队列则不需要再次加入)

2.队列为空结束

*/

#include

#include

#include

#include

#include

#include

#include

#include

#define N 1010

#define INF 0x3f3f3f3f

#define WC 1e-6

typedef long long LL;

using namespace std;

int book[N],dis[N],map[N][N];//存信息

queuemmp;

void SPFA(int n)//n得出范围 输入map就OK

{

int to;

memset(book,0,sizeof(book));

for(int i=1;i<=n;i++)

dis[i]=INF;

dis[1]=0;

while(!mmp.empty())

mmp.pop();

mmp.push(1);

while(!mmp.empty())

{

int u=mmp.front();//出队伍

mmp.pop();

book[u]=0;

for(int i=1;i<=n;i++)//松弛

{

to=dis[u]+map[u][i];

if(to

{

dis[i]=to;

if(!book[i])

{

mmp.push(i);

book[i]=1;

}

}

}

}

}

int main()

{

//cin map

}

附上bellman算法/*

bellman算法 可以判断负环

1.初始化dis (struct)edge

2.遍历所有边

2.更新成功则进行下一次

*/

#include

#include

#include

#include

#include

#include

#include

#define N 4010

#define INF 0x3f3f3f3f

#define WC 1e-6

typedef long long LL;

using namespace std;

int dis[N];

struct node{

int u,v,w;

}e[N];

void bellman(int n,int cnt)

{

int to,t,flag;

for(int i=2;i<=n;i++)

dis[i]=INF;

dis[1]=0;

t=n-1;

while(t--)

{

flag=0;

for(int i=0;i

{

to=dis[e[i].u]+e[i].w;

if(to

{

dis[e[i].v]=to;

flag=1;

}

}

if(!flag)

break;

}

// if(flag)//最后一次用于判断负环

}

int main()

{

//cin edge

}