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+5;
const int maxm= 1e3+5;
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=1;i<=n;i++)
        d[i]=inf;
    d[x]=0;
    for(int i=1;i<n;i++)                //  n-1次迭代
        for(int j=0;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=1;
    for(int i=0;i<m;i++)                       //判断是否有负环
        if(d[edges[i].u]+edges[i].w<d[edges[i].v])
        {
            flag=0;
            break;
        }
    return flag;            //返回最短路是否存在
}
void Print_Path(int x)
{
    while(x!=p[x])          //逆序输出 正序的话用栈处理一下就好了
    {
        printf("%d ",x);
        x=p[x];
    }
    printf("%d
",x);
}
int main()
{
    while(scanf("%d %d %d",&n,&m,&s)!=EOF)
    {
        for(int i=0;i<m;i++)
            scanf("%d %d %d",&edges[i].u,&edges[i].v,&edges[i].w);
        p[s]=s;
        if(Bellman_Ford(s)==1)
            for(int i=1;i<=n;i++)
            {
                printf("%d %d
",i,d[i]);
                Print_Path(i);
            }
        else
            printf("sorry
");
        return 0;
    }
}

输入

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~~