[AcWing Base, Graph Dijkstra]

Author: houhuawei23

Graph/ShortestPath/AW849Dijkstra1.cpp

@@ -0,0 +1,69 @@
+/*
+Dijkstra
+https://www.acwing.com/problem/content/description/851/
+1. find next point (p) closest to source.
+2. the shortest path length from source to p is determined.
+3. update all other points, as p is determined: min(dist[k], dist[p] + g[p][k])
+
+n <= 500
+m <= 10^5
+朴素版: for 稠密图
+O(n^2) = 2.5e5
+
+输入样例：
+3 3
+1 2 2
+2 3 1
+1 3 4
+输出样例：
+3
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+const int N = 510;
+const int INFBYTE = 0x3f;
+const int INFINT = 0x3f3f3f3f;
+int n, m;
+int g[N][N]; /* g[i][j]: distance between i and j */
+int dist[N]; /* dist[i]: 1 to i shortest path distance */
+bool st[N];  /* true if dist[i] is determined */
+
+int dijistra() {
+    memset(dist, 0x3f, sizeof(dist));
+    dist[1] = 0;
+    for(int i = 0; i < n - 1; i++) { /* n */
+        int t = -1;
+        for(int j = 1; j <= n; j++) {
+            /* find closeset point that not determined */
+            if(!st[j] and (t == -1 or dist[t] > dist[j])) {
+                t = j;
+            }
+        }
+        st[t] = true;
+        /* 1 -> t determined, find next point j,
+        ** min 1->t->j = dist[t] + min(g[t][j]) */
+        for(int j = 1; j <= n; j++) {
+            dist[j] = min(dist[j], dist[t] + g[t][j]);
+        }
+    }
+    if(dist[n] == INFINT) {
+        return -1;
+    } else {
+        return dist[n];
+    }
+}
+
+int main() {
+    cin >> n >> m;
+    memset(g, INFBYTE, sizeof(g));
+    while(m--) {
+        int x, y, z;
+        cin >> x >> y >> z;
+        /* repeat edge */
+        g[x][y] = min(g[x][y], z);
+    }
+    cout << dijistra() << endl;
+    return 0;
+}

Graph/ShortestPath/AW849_noted.cpp

@@ -0,0 +1,71 @@
+/*
+总结起来核心就三步，肥肠煎蛋
+
+首先寻找目前状态下离第一个结点距离最小的结点
+
+然后将这个结点加入已经确定距离的结点中
+
+接着更新状态，即加入新的结点后看看是否因为这个新加的结点而出现一条更短的距离，如果有，就更新距离
+*/
+
+#include <iostream>
+#include <cstring>
+#include <algorithm>
+using namespace std;
+const int N = 510;
+int n, m;
+int g[N][N];  // g[ 1 ][ 2 ]是指从1节点指向2节点的距离，也可以表示不存在
+int dist[N];  // distance（距离）的缩写，代表每一个点到源点的距离
+bool st[N];
+// state(状态)的缩写,当st[n]为true时说明这个点到源点的距离最小值就已经确定了
+int dijkstra() {
+    memset(dist, 0x3f, sizeof(dist));  // 存储每一个点到源点的距离
+    // 比较大的数
+    dist[1] = 0;  // 源点到自己的距离为0
+    for (int i = 0; i < n - 1; i++) {
+        // 其实这条语句唯一的作用就是循环n-1次（优化了）
+        // 所以写成for(int i=0;i<n;i++)也可以，
+        // 因为如果下面的语句循环了n-1次的话，那么所有点都能得到最小值了
+        // 可以这么理解，每次循环都会确定一个最小值，还会再创造一个最小值（留给下一次循环去确定）
+        // 当循环n-1次时，情况是已经确定了n-1个点的最小值了，还创造了一个最小值(此时还有1个点等着下一次去确定)
+        // 那么就不需要下一次循环了，毕竟剩下的就一个点，在1个点的集合中知道有一个点是最小值，顺理成章了
+        // 当然你想写成for(int i=0;i<n;i++)也能AC~~小声说~~
+        int t = -1;
+        for (int j = 1; j <= n; j++) {
+            if (!st[j] and (t == -1 or dist[t] > dist[j])) {
+                t = j;
+                //! st[j]指的是最近距离还没有确定的点，and后面就是找符合！st[j]条件的距离最小的点
+                // 这一个操作就是找到未确定最小值的
+                // `点集`中的最小点,t==-1是当第一次遇到未确定~的点时能够被初始化
+            }
+        }
+        //(1)
+        for (int j = 1; j <= n; j++) {
+            // 现在找到t了，遍历一遍所有点，有一下几种情况
+            // 1.j点和t点之间无连接，那么g[t][j]=0x3f3f3f3f,特别大，会被pass
+            // 2.dist[j]<=dist[t]+g[t][j],源点到j点的距离，如果经过t后距离更长了，那么不考虑
+            // 3.dist[j]<=dist[t]+g[t][j],，~~，经过t点距离更短了，那么修改dist[j]的值
+            dist[j] = min(dist[j], dist[t] + g[t][j]);
+        }
+        st[t] = true;
+        // 当前t点已经把其余点全部遍历了一遍，此点变成确定距离为最小的点了,这条语句放在（1）处也能AC
+    }
+    if (dist[n] == 0x3f3f3f3f) {
+        // 当前点n没被修改，说明到不了点n，输出-1
+        return -1;
+    } else {
+        return dist[n];  // 易证
+    }
+}
+int main() {
+    cin >> n >> m;  // n存点数，m存边数
+    memset(g, 0x3f, sizeof(g));
+    // 将点之间的距离的每一个值设置成很大的数，此知识点之前讲过
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        g[a][b] = min(g[a][b], c);  // 有效解决多条边的问题，保留最短边
+    }
+    cout << dijkstra() << endl;
+    return 0;
+}

Graph/ShortestPath/AW850Dijkstra2.cpp

@@ -0,0 +1,76 @@
+/*
+n points, m edges
+repeat edges, circul, weight >= 0
+find shortest distance between 1 and n, else -1
+
+n, m <= 1.5e5
+normal Dijkstra: O(N^2), TLE
+Heap Optimization: O(m logm), for 稀疏图, 邻接表存
+
+输入样例：
+3 3
+1 2 2
+2 3 1
+1 3 4
+输出样例：
+3
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+typedef pair<int, int> PII;
+const int N = 1.5e5 + 10;
+const uint8_t INFBYTE = 0x3f;
+const int INFINT = 0x3f3f3f3f;
+
+int firstEdge[N], endPoint[N], nextEdge[N], weight[N], idx;
+int dist[N];
+bool st[N];
+
+int n, m;
+void add(int a, int b, int c) {
+    weight[idx] = c;
+    endPoint[idx] = b;
+    nextEdge[idx] = firstEdge[a];
+    firstEdge[a] = idx;
+    idx++;
+}
+
+int dijkstra() {
+    memset(dist, INFBYTE, sizeof(dist));
+    dist[1] = 0;
+    priority_queue<PII, vector<PII>, greater<PII>> heap;
+    // 这里heap中为什么要存pair呢，首先小根堆是根据距离来排的，所以有一个变量要是距离，
+    // 其次在从堆中拿出来的时候要知道知道这个点是哪个点，不然怎么更新邻接点呢？所以第二个变量要存点。
+    heap.push({ 0, 1 }); /* first: distance, second: point id*/
+    while(heap.size()) {
+        PII p = heap.top();
+        heap.pop();
+        int distance = p.first, cur = p.second;
+        if(st[cur]) continue;
+        /* mark as determined */
+        st[cur] = true;
+        for(auto edge = firstEdge[cur]; edge != -1; edge = nextEdge[edge]) {
+            int end = endPoint[edge];
+            if(dist[end] > distance + weight[edge]) {
+                dist[end] = distance + weight[edge];
+                heap.push({ dist[end], end });
+            }
+        }
+    }
+    if(dist[n] == INFINT) {
+        return -1;
+    } else {
+        return dist[n];
+    }
+}
+int main() {
+    cin >> n >> m;
+    memset(firstEdge, -1, sizeof(firstEdge));
+    while(m--) {
+        int x, y, z;
+        cin >> x >> y >> z;
+        add(x, y, z);
+    }
+    cout << dijkstra() << endl;
+}

Graph/ShortestPath/AW851SPFA.cpp

@@ -0,0 +1,69 @@
+/*
+
+https://www.acwing.com/problem/content/855/
+
+作者：yxc
+链接：https://www.acwing.com/activity/content/code/content/48523/
+来源：AcWing
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+负权图最短路, 限制 k
+
+输入样例：
+3 3 1
+1 2 1
+2 3 1
+1 3 3
+输出样例：
+3
+
+
+*/
+
+#include <cstring>
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+const int N = 510, M = 10010;
+
+struct Edge {
+    int a, b, c;
+} edges[M];
+
+int n, m, k;
+int dist[N];
+int last[N];
+
+void bellman_ford() {
+    memset(dist, 0x3f, sizeof dist);
+
+    dist[1] = 0;
+    for (int i = 0; i < k; i++) {
+        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() {
+    scanf("%d%d%d", &n, &m, &k);
+
+    for (int i = 0; i < m; i++) {
+        int a, b, c;
+        scanf("%d%d%d", &a, &b, &c);
+        edges[i] = {a, b, c};
+    }
+
+    bellman_ford();
+
+    if (dist[n] > 0x3f3f3f3f / 2)
+        puts("impossible");
+    else
+        printf("%d\n", dist[n]);
+
+    return 0;
+}

Graph/ShortestPath/AW853BFord.cpp

@@ -0,0 +1,54 @@
+/*
+多源汇最短路问题-具有多个源点
+
+Floyd算法 O(n^3)-动态规划
+
+给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。
+
+再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。
+
+数据保证图中不存在负权回路。
+
+作者：郡呈
+链接：https://www.acwing.com/solution/content/6976/
+来源：AcWing
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+*/
+#include <iostream>
+using namespace std;
+
+const int N = 210, M = 2e+10, INF = 1e9;
+
+int n, m, k, x, y, z;
+int d[N][N];
+
+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() {
+    cin >> n >> m >> k;
+    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;
+    while(m--) {
+        cin >> x >> y >> z;
+        d[x][y] = min(d[x][y], z);
+        // 注意保存最小的边
+    }
+    floyd();
+    while(k--) {
+        cin >> x >> y;
+        if(d[x][y] > INF / 2) puts("impossible");
+        // 由于有负权边存在所以约大过INF/2也很合理
+        else
+            cout << d[x][y] << endl;
+    }
+    return 0;
+}