Bellman-Ford 算法及SPFA优化简单笔记

（简要笔记，仅供参考，可能存在瑕疵或者不正确的地方，望指正）

Bellman-Ford 算法

（1）基于松弛操作求最短路径，可以求出有负权的最短路径，也可以判断不存在最短路径

（2）用于解决单源问题（指定一个点到其他点的距离）

（3）主要松弛操作为dis[v] = min(dis[v],dis[u] + w(u,v))//假定一个点，这个点到v的距离和先到u再到v的距离进行比较，由此缩短到达v的距离。

（4）Bellman-Ford 算法就是不断的松弛。

实现

1组成

（1）图的存储，这里用邻接表。

struct node{
int to;//终点
int w;//权值
}
vector<node>vv[N]//邻接表

（2）

int dis[N]//某个点到另外点的距离。

（3）初始化

for(i=1;i<=n;i++)//清除邻接表，以多次使用
{
vv[i].clear();
}
for(i=1;i<=n;i++)
dis[i]=inf //inf这里很大，可以取0x3f3f3f3f。
dis[s]=0;//s为指定的点，全部代码为了求s到其他点的距离。

2代码构筑

（1）输入

cin>>u>>v>>w;//u为起点，v为终点，w为权值。
vv[u].push_back(node{v,w})//加入邻接表。

(2)Bellman_Ford函数

void Bellman_Ford();
{
int k,i,j;
int to;//终点
int w;//起点
for(k=1;k<n;k++) /*最多进行n-1轮松弛，如果第n轮还有变化，那么求存在负环（一个环，路径和为负数，一直走路程会无限变小）*/
{
        for(i=1;i<=n;i++)
        for(j=0;j<vv[i].size();j++)
        {
        to=vv[i][j].to;//以i为起点的第j条边的终点
        w=vv[i][j].w;//以i为起点的第j条边的权
        if(dis[to]>dis[i]+w)//如果先到i再到to比直接到to点距离短，进行松弛
        dis[to]=dis[i]+w;
        }
}
}

SPFA

（1）SPFA是Bellman-Ford 算法的优化。

（2）可以用于判断是否存在负环

实现

1组成

(1)queue<int>q      //用于存储被成功松弛的点。

(2)int inqueue[N]//用于标记各点是否已经加入队列。

剩下的和之前差不多一样

 (3)vector<node>vv[N]//邻接表

（4）dis[N]//某个点到另外点的距离。

（5）初始化

for(i=1;i<=n;i++)//清除邻接表，以多次使用
{
vv[i].clear();
}
for(i=1;i<=n;i++){
dis[i]=inf //inf这里很大，可以取0x3f3f3f3f。
inqueue[i]=0      //初始化为0，表示点未进入队列。
}
dis[s]=0;//s为指定的点，全部代码为了求s到其他点的距离。

2代码构筑

无负权情况（有负环会死循环）

（1）输入

cin>>u>>v>>w;//u为起点，v为终点，w为权值。
vv[u].push_back(node{v,w})//加入邻接表。

（2）SPFA函数

void spfa(){
q.push(s);//将指定的点加入队列。
inqueue[s]=1;//代表s已加入队列。
while(!q.empty())
{
int p=q.front();//取出队列第一个点。
q.pop;//删掉队列第一个点。
inqueue[p]=0;//此时该点不在队列里了。
        for(int i=0;i<vv[p].size();i++)                //遍历和p相连所有的路径
        {
                int to=vv[p][i].to;                //得到与p相连的第i条路径的终点。
                int w=vv[p][i].w;                //得到与p相连的第i条路径的权。
                if(dis[to]>dis[p]+w)                //比较s直接到to和s先到再到to的路径。
                {
                        dis[to]=dis[p]+w;//缩小
                        if(!inqueue[to])                //判断终点to是否在队列里。
                        {
                                inqueue[to]=1;                //如果不在则加入队列。
                                q.push(to);
                        }
                }
        }
}
}

用SPFA判断是否有负环（和之前的函数差不多）

int cnt[N];//记录到达当前点最短路径所含的边数，如果大于等于n，说明存在负环。
int spfa(){
q.push(s);//将指定的点加入队列。
inqueue[s]=1;//代表s已加入队列。
while(!q.empty())
{
int p=q.front();//取出队列第一个点。
q.pop;//删掉队列第一个点。
inqueue[p]=0;//此时该点不在队列里了。
        for(int i=0;i<vv[p].size();i++)                //遍历和p相连所有的路径
        {
                int to=vv[p][i].to;                //得到与p相连的第i条路径的终点。
                int w=vv[p][i].w;                //得到与p相连的第i条路径的权。
                if(dis[to]>dis[p]+w)                //比较s直接到to和s先到再到to的路径。
                {
                        dis[to]=dis[p]+w;//缩小
                        cnt[to]=cnt[p]+1;                //到to点所需要的边比到p点多1。
                        if(cnt[to]>=n)                //判断边数是否大于n。
                        return 1;                //说明存在负环。
                        if(!inqueue[to])                //判断终点to是否在队列里。
                        {      
                                inqueue[to]=1;                //如果不在则加入队列。
                                q.push(to);
                        }
                }
        }
}
return 0;              //返回无负环。
}