最短路总结+最小生成树

对最短路问题的总结：

1.多源汇最短路：Floyd
2.k条边最短路：Bellman_ford
3.带负权的边、判重边：SPFA
4.稠密图：朴素版dijkstra
5.稀疏图：堆优化dijkstra
6.当没有故意卡SPFA的时候SPFA比dijkstra快。
SPFA强👍

最小生成树

一、Prim算法

实现方式：可以类比Dijkstra算法，用一个数组标记节点是否属于已生成的树林T。每次从未标记的节点中选出dist最小的，把它标记（加入T中），同时扫描所有出边，更新另一个端点的dist值。

算法复杂度：$O(n^2)$

prim堆优化意义不大，一般稀疏图的话直接就用kruscal算法了。

#include <cstdio>
#include <iostream>
#include <cstring>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
int dist[N];
bool st[N];

int prim() {
    memset(dist, 0x3f, sizeof(dist));
    int ans = 0;
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[j] < dist[t])) t = j;
        if (i && dist[t] == INF) return INF;
        st[t] = true;
        if (i) ans += dist[t];
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], g[t][j]);
    }
    return ans;
}

int main() {
    scanf("%d %d", &n, &m);
    memset(g, 0x3f, sizeof(g));
    for (int i = 0; i < m; i++) {
        int a, b, c;
        scanf("%d %d %d", &a, &b, &c);
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    int t = prim();
    if (t == INF) printf("impossible\n");
    else printf("%d\n", t);
    return 0;
}

二、Kruskal算法

实现方式：再任何时候，Kruskal算法都是从剩余的边中选出一条权值最小的并与生成的森林不联通的边，加入其中。
实现流程：
1.建立并查集，每个点各自构成一个集合。
2.把所有边按照权值从小到大排序，依次扫描每一条边。
3.若边 $x,y$属于同一集合，则忽略这条边，继续扫描下一条。
4.否则，合并 $x,y$ 所在的集合。
5.所有边扫描结束后，所有加入的边就构成了最小生成树。

时间复杂度：$O(mlogm)$

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

using namespace std;

const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f;

struct node {
    int x, y, z;
    bool operator < (const node &a) const {
        return z < a.z;
    } 
} e[M];

int n, m;
int f[N];

int find(int x) {
    if (f[x] == x) return x;
    else return f[x] = find(f[x]);
}

int kruskal() {
    sort(e, e + m);
    for (int i = 1; i <= n; i++) f[i] = i;
    int ans = 0, cnt = 0;
    for (int i = 0; i < m; i++) {
        int a = find(e[i].x), b = find(e[i].y);
        if (a != b) {
            f[a] = b;
            ans += e[i].z;
            cnt++;
        }
    }
    if (cnt < n - 1) return INF;
    else return ans;
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < m; i++)
        scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].z);
    int t = kruskal();
    if (t == INF) printf("impossible\n");
    else printf("%d\n", t);
    return 0;
}

小知识：

同样是从小到大排序，sort 与 priority_queue 中的重载运算符是不同的。

sort ：

bool operator < (const node &a) const {
    return x < a.x;
} 

priority_queue:

bool operator < (const node &a) const {
    return x > a.x;
}

小结：

通过今天的学习，我发现我对算法的掌握还不够熟练。今天把最短路的代码写了很多遍，虽然能写出来，但总要需要改来改去，还是太慢了。不能一直在模板上死磕了，还是要多写写其他题。正好明天有一场CSP模拟赛，练练手。可能这次又要爆零咯，但还是要加油的呀！哦，对了，明天也是考教师资格证的考试呢，考教师资格证的你们也要加油呀！虽然我不认识“你们”。