关于Bellman-Ford算法的个人理解

坦白而言，这一次学习确实比原来更深入不少，对于算法的内容和大致执行的流程也有了一个更深入的了解；

Bellman-Ford算法也是最短路径生成算法，但是其和迪杰斯特拉算法不一样的是可以进行负权值路径的判别。而迪杰斯特拉算法所使用的前提条件之一就是不能出现负权值路径。

其实从这个算法收获的有两个东西：

1.算法本身的思路，和迪杰斯特拉不同；

2.负权值路径和负权值回路会出现什么样的问题；

 

Bellman-Ford算法思路也很简单，对于N个点，进行N次循环，每次循环依次更新路径。

在更新路径的操作上，和迪杰斯特拉算法大同小异，但是不同于迪杰斯特拉算法，他不是选取最小的边进行选择，而是根据每一条边，依次对Distence数组进行更新，所以会访问很多访问过的点，借此重复不遗漏的更新距离数组，也就是规划起点到当前访问的相邻点的问题。思路很简单，也很好理解，但是有一个疑惑就是N次循环是怎么规定出来的，这个存疑，书上证明没看太懂，但是当出现负权值环的时候，确实可以通过再次更新距离数组进行判断；

对于负权值回路，是不可能有最短路径的。原因就是当经过一个负权值回路环的时候，这条路径到达的点虽然仍相同，但是权值经过每次迭代必然下降，所以无论是迪杰斯特拉还是Bellman-Ford算法都没法解决这个问题。同时，Bellman-Ford算法判定条件之一就是经过足够次迭代，仍然无法满足更新权值存在，此时，必有负权值回路存在。

大致代码如下所示：

前半部分为循环嵌套，目的是更新路径；

后半部分为负权值环的判断；

struct Node{
    int v,dis;
};
vector<Node> Adj[MAXV];
int n;
int d[MAXV];

bool Bellman(int s){
    fill(d,d+MAXV,INF);
    d[s]=0;
    for(int i=0;i<n-1;i++){
        for(int u=0;u<n;u++){
            for(int j=0;j<Adj[u].size();j++){
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v]){
                    d[v]=d[u]+dis;
                }
            }
        }
    }
    for(int u=0;u<n;u++){
            for(int j=0;j<Adj[u].size();j++){
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v]){
                    return false;
            }
        }
    }
    return true;
}