04最短路

Dijkstra求最短路 I

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

朴素版Dijkstra

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510;

int n, m;
int g[N][N];
int dist[N]; // 节点到原点的最短距离
bool st[N];

// 1到n的最短距离
int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 0; i < n; i ++ ) { // 每次找到一个点的最短距离
        // 找到未被确定，且dist最短的点
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        
        st[t] = true; // 该节点最短路已经确定
        
        // 更新t的下面节点距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }
    
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main() {
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g); // 初始化为无穷大
    
    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(c, g[a][b]); // 选择重边中最短的一个
    }
    
    cout << dijkstra() << endl;
    return 0;
}

Dijkstra求最短路 II

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

堆优化版的Dijkstra

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 150010;

int n, m;
int h[N], e[N], w[N], ne[N], idx; // 数组邻接矩阵来储存图
int dist[N];
bool st[N];

// 头插法
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap; // 定义优先队列
    heap.push({0, 1}); // first存距离，second存节点
    
    // 用优先队列（堆）优化dijkstra算法
    while (!heap.empty()) {
        auto t = heap.top();
        heap.pop();
        
        int va = t.second, distance = t.first;
        if (st[va]) continue; // 可能一个点被多次更新
        st[va] = true;
        
        for (int i = h[va]; i != -1; i = ne[i]) {
            int j = e[i];
            if (distance + w[i] < dist[j]) { // 如果节点需要更新，就将其加入到队列中
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    
    cout << dijkstra() << endl;
    
    return 0;
}

有边数限制的最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路。

bellman_ford算法

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 510, M = 100010;

// 存边的结构体
struct Edge
{
    int a, b, c;
}edges[M];

int n, k, m;
int dist[N], last[N]; // last用来备份当前最短路径状态

void bellman_ford() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 0; i < k; i ++ ) { // 不超过k条边的最短路径
        memcpy(last, dist, sizeof dist);

        for (int j = 0; j < m; j ++ ) { // 遍历每条边
            auto e = edges[j];
            dist[e.b] = min(dist[e.b], last[e.a] + e.c); // 更新节点的最短距离
        }
    }
}

int main() {
    cin >> n >> m >> k;
    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        edges[i] = {a, b, c};
    }

    bellman_ford();

    if (dist[n] < 0x3f3f3f3f / 2) cout << dist[n] << endl; // 可能dist[n]由于负权边被更新了，但仍然代表无穷大
    else cout << "impossible" << endl;
    return 0;
}

spfa求最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。

数据保证不存在负权回路。

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++ ;
}

// 不存在负权回路，在bellman-ford算法上做了优化
void spfa() {
    memset(dist, 0x3f, sizeof dist);
    queue<int> q;
    q.push(1);
    dist[1] = 0;
    st[1] = true;

    // 只判断更新后的节点，与其相连的节点是否需要更新
    while (!q.empty()) {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i]; // t -> j
            if (dist[t] + w[i] < dist[j]) {
                dist[j] = dist[t] + w[i];
                if (!st[j]) {
                    q.push(j);
                    st[j] = true; // 防止重复将节点加入队列
                }
            }
        }
    }
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }

    spfa();

    if (dist[n] != 0x3f3f3f3f) cout << dist[n] << endl; // spfa只会更新所有能从起点走到的点，所以不需要用inf / 2
    else cout << "impossible" << endl;

    return 0;
}

spfa判断负环

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。

请你判断图中是否存在负权回路。

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N], cnt[N]; // cnt[x]记录当前x点到虚拟源点最短路的边数，初始每个点到虚拟源点的边数为0
bool st[N];

void add(int a, int b, int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++ ;
}

// 判断是否存在负环
bool spfa() {
    queue<int> q;
    // 初始化过程可以看做，在原图的基础上新建一个虚拟源点，从该点向其他所有点连一条权值为0的有向边。
    for (int i = 1; i <= n; i ++ ) {
        q.push(i);
        st[i] = true;
    }

    while (!q.empty()) {
        int t = q.front();
        q.pop();

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i]; // t -> j
            if (dist[t] + w[i] < dist[j]) {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true; // 节点最短路大于n，根据鸽笼原理，有负环
                if (!st[j]) {
                    q.push(j);
                    st[j] = true; // 防止重复将节点加入队列
                }
            }
        }
    }
    return false;
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }

    if (spfa()) printf("Yes\n");
    else printf("No\n");

    return 0;
}

Floyd求最短路

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出 impossible。

数据保证图中不存在负权回路。

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 210, INF = 0x3f3f3f3f;

int n, m, q;
int d[N][N]; // d[i][j]表示i到j的最短距离

// 由动态规划的空间优化而来
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]);
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    // 初始化
    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;

    for (int i = 0; i < m; i ++ ) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        d[a][b] = min(d[a][b], c);
    }

    floyd();

    for (int i = 0; i < q; i ++ ) {
        int a, b;
        scanf("%d%d", &a, &b);
        if (d[a][b] > INF / 2) printf("impossible\n");
        else printf("%d\n", d[a][b]);
    }
    return 0;
}