Bellman-Ford 求含负权最短路

该算法详解请看   https://www.cnblogs.com/tanky_woo/archive/2011/01/17/1937728.html

单源最短路   当图中存在负权边时 迪杰斯特拉就不能用了 该算法解决了此问题 时间复杂度O(nm)

注意   图中含有负圈时不成立。当判定存在负圈时，这只说明s可以到达一个负圈，并不代表s到每个点的最短路都不存在。

另外，如果图中有其他负圈但是s无法达到这个负圈，该算法也无法找到，解决方法加一个节点（还不会。。。）

该算法可以用 队列 优化 名为spfa

下面给出 有向图 的代码

 #include <stdio.h>
 #include <math.h>
 #include <string.h>
 #include <stdlib.h>
 #include <iostream>
 #include <sstream>
 #include <algorithm>
 #include <string>
 #include <queue>
 #include <ctime>
 #include <vector>
 using namespace std;
 const int maxn= 1e3+;
 const int maxm= 1e3+;
 const int inf = 0x3f3f3f3f;
 typedef long long ll;
 int n,m,s;   //n m s 分别表示 点数-标号从1开始 边数-标号从0开始 起点
 struct edge
 {
     int u,v,w;    //u为边的起点 v为边的终点 w为边的权值
 }edges[maxm];
 int d[maxn];   //d[i]表示 i 点到源点 s 的最短距离
 int p[maxn];    //p[i]记录最短路到达 i 之前的节点
 int Bellman_Ford(int x)
 {
     for(int i=;i<=n;i++)
         d[i]=inf;
     d[x]=;
     for(int i=;i<n;i++)                //  n-1次迭代
         for(int j=;j<m;j++)            //  检查每条边
         {
             if(d[edges[j].u]+edges[j].w<d[edges[j].v])    // 松弛操作
             {
                 d[edges[j].v]=d[edges[j].u]+edges[j].w;
                 p[edges[j].v]=edges[j].u;           //记录路径
             }
         }
     int flag=;
     for(int i=;i<m;i++)                       //判断是否有负环
         if(d[edges[i].u]+edges[i].w<d[edges[i].v])
         {
             flag=;
             break;
         }
     return flag;            //返回最短路是否存在
 }
 void Print_Path(int x)
 {
     while(x!=p[x])          //逆序输出 正序的话用栈处理一下就好了
     {
         printf("%d ",x);
         x=p[x];
     }
     printf("%d\n",x);
 }
 int main()
 {
     while(scanf("%d %d %d",&n,&m,&s)!=EOF)
     {
         for(int i=;i<m;i++)
             scanf("%d %d %d",&edges[i].u,&edges[i].v,&edges[i].w);
         p[s]=s;
         if(Bellman_Ford(s)==)
             for(int i=;i<=n;i++)
             {
                 printf("%d %d\n",i,d[i]);
                 Print_Path(i);
             }
         else
             printf("sorry\n");
         return ;
     }
 }

输入

6 9 1
1 2 2
1 4 -1
1 3 1
3 4 2
4 2 1
3 6 3
4 6 3
6 5 1
2 5 -1

输出
1 0
1
2 0
2 4 1
3 1
3 1
4 -1
4 1
5 -1
5 2 4 1
6 2
6 4 1

太菜了 wa~~