最短路径问题（详细求解）

最短路径求解大纲

单源最短路问题

1. 所有边权都为正数

朴素版Dijkstra算法（时间复杂度 O(n^2+m)）

Dijkstra算法的3个步骤
1、找到当前未标识的且离源点最近的点t
2、对t号点点进行标识
3、用t号点更新其他点的距离

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < n - 1; i ++ )
    {
        int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

堆优化版Dijkstra算法（时间复杂度 O(mlogn)）

typedef pair<int, int> PII;
vector<vector<PII>>v; //稀疏图用邻接表存储
int st[N], d[N];
int n, m;
//注意：v要v.resize();
void Dijkstra() {
    memset(d, 0x3f, sizeof d);
    priority_queue<PII, vector<PII>, greater<PII>>heap; //用小根堆存储每个点到起始点的最短距离
    heap.push({0, 1}); //第一个值为距离，第二位点
    d[1] = 0;
    while(heap.size()) {
        PII ww = heap.top();
        heap.pop();
        int dot = ww.second, distance = ww.first;
        if(st[dot])
            continue; //此点已确定最短距离，跳过
        st[dot] = 1; //将点存入st中

        for(int i = 0; i < v[dot].size(); i++) { //用dot点更新其他点的距离
            int dd = v[dot][i].second, ee = v[dot][i].first;
            if(d[ee] > dd + distance ) {
                d[ee] = dd + distance;
                heap.push({d[ee], ee});
            }
        }
    }
}

过渡：

问：为什么Dijkstra算法不适用于负权边的情况？
答：
如图，倘若按照Dijkstra算法的思路，此最短路径为1->2->4->5,长度为5，但实际上还有一条路径1->3->4->5,长度为4.因此，此方法失效

2.存在负权边

Bellman-Ford(O(nm))（适合限制最短路径边数时使用）

struct node{
  int x, y, z;
}edges[N];
int n,m,k;
int dist[N],backup[N];

void Bellman_Ford(){
    memset(dist,0x3f,sizeof dist);
    dist[1] = 0;
    for(int i=0; i<k; i++){  //每次循环更新一条边
        memcpy(backup,dist,sizeof(dist));
        for(int j=1; j<=m; j++){  //遍历每一条边，进行松弛操作
           int x = edges[j].x,y=edges[j].y,z=edges[j].z;
            dist[y] = min(dist[y],backup[x]+z);
        }
    }
    if(dist[n]>0x3f3f3f3f/2){
        puts("impossible");
    }else{
        cout << dist[n];
    }

}

问题一：为什么需要存一个backup?

初始时：
dist[1]=0,dist[2] = dist[3] = INF;
倘如直接更新，会发生串联现象，dist[3]在第一次时就会变为2.
2. 为什么(dist[n]>0x3f3f3f3f/2，而不是dist[n]==0x3f3f3f3f？


此时1，2 dist都是INF,3是INF-2，但是此图是无最短路径的，当用dist[n]==0x3f3f3f3f判断时，dist[3]==0x3f3f3f3f-2，会判断出错。

SPFA(一般O（m），最坏O(m*n))

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = true;

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

判断是否有环

时间复杂度是 O(nm)O(nm), nn 表示点数，mm 表示边数
int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

    while (q.size())
    {
        auto t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

多源最短路问题

初始化：
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
    for (int k = 1; k <= n; k ++ )
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}