bellman_ford与spfa求最短路算法(笔记)

bellman_ford:

非常简单的算法，想象一下，给你n条边，你要怎么去求从点1点n的最短路呢？最简单的方法就是遍历每一条边了，每一条边都有起点与终点，每遍历一次，相当于从其起点到终点走过了一次，而每次都可以计算从从起点到终点的最短距离就这样反复遍历，就可以找出最短路了, 更新公式：$dist[边的起点]=min（dist[边的终点]+权重，dist[边的起点]）$。

题目：求有限制边数的最短路

注意：

1. bellman_ford可以处理负权边，也可以用于找负环(但一般不用他用spfa)。
2. bellman_ford每遍历一次都相当于从起点向前走了一步，遍历n次相当于经过了n条边复杂度是$O(n^2)$
3. 每次用来操作的最短数(即记录当前最短距离的dist数组)不能用于更新本次数据，举个例子，有两条边，1 -> 2 and 2 ->3如果我第一次遍历：更新了1 -> 2就会改变dist[2]的值，然后我就又会用2更新dist[3], (注意：刚开始只有dist[1] = 0，其他的点都应该是正无穷)这一样一来dist[2]和dist[3]都不是正无穷的，而我一次只能走一条边，这显然错了。

代码&解释

#include<bits/stdc++.h>
#define eps 1e-8
#define ll long long
#define INF 0X3f3f3f3f
using namespace std;
const ll maxn = 1e6 + 5;
ll a[maxn],b[maxn],w[maxn];
ll n,m,k,dist[maxn],cp[maxn];
void bellman_ford()
{
    for(int i = 1; i <= n; i++)
        dist[i] = INF;
    //初始距离都为正无穷
    dist[1] = 0;
    //自身到自身的距离为零
    for(int i = 0; i < k; i++)
    {
        //拷贝一份dist到cy，cy用于更新dist
        memcpy(cp,dist,sizeof dist);
        for(int j = 0; j < m; j++)
            dist[b[j]] = min(dist[b[j]],cp[a[j]] + w[j]);
            //更新dist
    }
    //如果仍是正无穷则说明无法在k步到达
    if(dist[n] > INF / 2)
        cout << "impossible" << endl;
    else
        cout << dist[n] << endl;
}
int main()
{
    cin >> n >> m >> k;
    for(int i = 0; i < m; i++)
        cin >> a[i] >> b[i] >> w[i];
    //输入边，由于只是遍历边，所以不需要用邻接表
    bellman_ford();
    return 0;
}

spfa:

spfa实际上就是优化了的bellman_ford，这里用一个队列进行优化，由于bellman_ford每次都需要遍历所有的边，所以总是有不需要被更新的点被更新，所以我们可以用一个队列记录所有可以用来更新下一个点的点就可以了，复杂度：$O(nlogn)$

题目：spfa求最短路

代码：

#include<bits/stdc++.h>
#define eps 1e-8
#define ll long long
#define INF 0X3f3f3f3f
using namespace std;
const ll maxn = 1e6 + 5;
ll h[maxn],e[maxn],w[maxn],nex[maxn],cnt = 1;
ll n,m,k,dist[maxn],book[maxn];
//这里要该用邻接表储存了，因为不是每次都遍历全部边了
void add(ll a, ll b,ll c)
{
    e[cnt] = b;
    w[cnt] = c;
    nex[cnt] = h[a];
    h[a] = cnt++;
}
void spfa()
{
    queue<int> qu;
    for(int i = 1; i <= n; i++)
        dist[i] = INF;
    dist[1] = 0;
    book[1] = 1;
    //book用于标记该点是否在队列中
    qu.push(1);
    while(qu.size())
    {
        ll temp = qu.front();
        book[temp] = 0;
        qu.pop();
        for(int i = h[temp]; i != 0; i = nex[i])
        {
            ll t = e[i];
            if(dist[t] > dist[temp] + w[i])
            {
                //如果该点可以被更新就加入更新其他点的队列中
                dist[t] = dist[temp] + w[i];
                if(!book[t])
                    qu.push(t),book[t] = 1;
            }
        }
    }
    if(dist[n] > INF / 2)
        cout << "impossible" << endl;
    else
        cout << dist[n] << endl;
}
int main()
{
    cin >> n >> m;
    ll a,b,c;
    for(int i = 0; i < m; i++)
    {
        cin >> a >> b >> c;
        add(a,b,c);
    }
    spfa();
    return 0;
}