【图论】基础算法实现笔记 （最小生成树和最短路）

1、mst 没有堆优化的prim算法

原题链接： http://hihocoder.com/problemset/problem/1097 

//原题链接： http://hihocoder.com/problemset/problem/1097

#include <iostream>
#include <cstdio>
#include <set>
#include <cstring>
#include <climits>
using namespace std;

int gra[1010][1010];
int vis[1010];
int min_dis[1010]; //图上的每个节点到mst的距离

int main() {
    memset(gra, 0x7f, sizeof(gra));
    memset(vis, 0, sizeof(vis));
    memset(min_dis, 0x7f, sizeof(min_dis));
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            scanf("%d", &gra[i][j]);
        }
    }
    //初始化
    vis[0] = 1;
    int left = n - 1;
    min_dis[0] = 0; //第0个节点就是树开始计算的第一个结点
    for (int i = 1; i < n; ++i) {
        min_dis[i] = gra[0][i];
    }

    int min_cost = 0;

    while (left) {
        int vertex = 1,  minn_dis = INT_MAX;
        //从没有访问过的所有节点中找出距离树的距离最小的一个.
        for (int i = 0; i < n; ++i) {
            if (!vis[i] && min_dis[i] < minn_dis) {
                vertex = i, minn_dis = min_dis[i];
            }
        }
        vis[vertex] = true;
        min_cost += minn_dis;
        left--;
        //printf("%d : vertex: %d; minn_dis[%d] 
", n - left - 1, vertex, minn_dis);

        //把找到的新的点加到mst中，然后更新每个没有访问过的结点到mst的距离
        for (int i = 0; i < n; ++i) {
            if (!vis[i] && min_dis[i] > gra[vertex][i]) {
                min_dis[i] = gra[vertex][i];
            }
        }
    }
    printf("%d
", min_cost);
    return 0;
}

2、并查集优化的kruskal算法

原题链接：https://hihocoder.com/problemset/problem/1098

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

using namespace std;

int u[1000100], v[1000100], w[1000100], r[1000100];
int fa[100020];

bool cmp (const int x, const int y) {
    return w[x] < w[y];
}

void initSet(const int n) {
    for (int i = 0; i < n; ++i) {
        fa[i] = i;
    }
}

int find(int x) {
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);

    initSet(n); //初始化并查集
    for (int i = 0; i < m; ++i) {
        scanf("%d %d %d", &u[i], &v[i], &w[i]);
        r[i] = i; //初始化边的序号
    }
    sort(r, r + m, cmp); //把边按照边的权重间接排序

    /*
    //打印sort之后的值
    for(int i = 0; i < m; ++i) {
        int idx = r[i];
        printf("%d %d %d
", u[idx], v[idx], w[idx]);
    }
    */

    int ans = 0;
    int cnt = 0;
    for(int i = 0; i < m; ++i) {
        int e = r[i];
        int x = find(u[e]), y = find(v[e]);  //找出当前两个端点所在的集合编号
        if (x != y) {  //不在同一个集合则合并
            ans += w[e];
            fa[x] = y;
            cnt++;
            if (cnt == n-1) {
                break;
            }
        }
    }
    printf("%d
", ans);
    return 0;
}

3、求最短路的算法

（1）floyed （O（N^3））

（2）Dijkstra（O(nlogn)）堆优化之后的算法

例题：https://www.luogu.org/problemnew/show/P3366

#include <iostream>
#include <vector>
#include <cstdio>
#include <queue>

using namespace std;
int graph[1005][1005];
int n, m;
int res = 1;
struct HeapNode {
    int u, d;
    HeapNode(int node, int weight): u(node), d(weight) {}
    bool operator<(const HeapNode& rhs) const {
        return d > rhs.d;
    }
};
void dijkstra(int src) {
    vector<int> dis(n, INT_MAX);
    dis[0] = 0;
    priority_queue<HeapNode> que;
    que.push(HeapNode(src, 0));
    while (!que.empty()) {
        HeapNode cur = que.top(); que.pop();
        int u = cur.u, d = cur.d;
        if (dis[u] != d) {continue;}
        for (int v = 0; v < n; ++v) {
            if (graph[u][v] == -1) {continue;}
            if (dis[u] + graph[u][v] < dis[v]) {
                dis[v] = dis[u] + graph[u][v];
                que.push(HeapNode(v, dis[v]));
            }
        }
    }
    for (auto d : dis) {
        printf("%d ", d);
    }
    printf("
");
    
}
int main(int argc, char *argv[]) {
    cin >> n >> m;
    memset(graph, -1, sizeof(graph));
    for (int k = 0; k < m; ++k) {
        int u, v, w;
        cin >> u >> v >> w;
        graph[u-1][v-1] = w;
    }
    dijkstra(0);
}