最小生成树

Prim算法：

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int N;
vector<vector<int>> graph;
vector<int> lowcost;
vector<int> closest;

void solve() {
    int u = 0;
    int cost = 0;
    for (int i = 0; i < N; ++i) {
        lowcost[i] = graph[0][i];
        closest[i] = 0;
    }
    closest[0] = -1;
    for (int i = 0; i < N; ++i) {
        int tmp_min = INT_MAX;
        for (int j = 0; j < N; ++j) {
            if (lowcost[j] != 0 && tmp_min > lowcost[j]) {
                tmp_min = lowcost[j];
                u = j;
            }
        }
        cost += lowcost[u];
        lowcost[u] = 0;
        for (int j = 0; j < N; ++j) {
            if (lowcost[j] > graph[u][j]) {
                lowcost[j] = graph[u][j];
                closest[j] = u;
            }
        }
    }
    cout << cost << endl;
}

int main() {
    while (cin >> N) {
        graph.assign(N, vector<int>(N));
        lowcost.resize(N);
        closest.resize(N);
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                cin >> graph[i][j];
            }
        }
        solve();
    }
    return 0;
}

Prim算法堆优化：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int INF = 1e9;

struct edge {
    int idx;
    int dist;
    edge(int _idx, int _dist) : idx(_idx), dist(_dist) {}
};

struct cmp {
    bool operator () (const edge &a, const edge &b) { return a.dist > b.dist; }
};

int N, M;
vector<vector<edge>> graph;

void solve() {
    int S = 1;
    priority_queue<edge, vector<edge>, cmp> heap;
    vector<int> lowcost(N + 1, INF);
    vector<bool> visit(N + 1, false);
    lowcost[S] = 0;
    visit[S] = true;
    int res = 0;
    for (int i = 0; i < graph[S].size(); ++i) {
        auto v = graph[S][i];
        lowcost[v.idx] = min(lowcost[v.idx], v.dist);
        heap.push(edge(v.idx, lowcost[v.idx]));
    }
    while (!heap.empty()) {
        auto u = heap.top();
        heap.pop();
        if (visit[u.idx]) continue;
        visit[u.idx] = true;
        res += lowcost[u.idx];
        lowcost[u.idx] = 0;
        for (int i = 0; i < graph[u.idx].size(); ++i) {
            auto v = graph[u.idx][i];
            if (!visit[v.idx] && lowcost[v.idx] > lowcost[u.idx] + v.dist) {
                lowcost[v.idx] = lowcost[u.idx] + v.dist;
                heap.push(edge(v.idx, lowcost[v.idx]));
            }
        }
    }
    cout << res << endl;
}

int main() {
    while (cin >> N >> M) {
        int u, v, len;
        graph.resize(N + 1);
        for (int i = 0; i < M; ++i) {
            cin >> u >> v >> len;
            graph[u].push_back(edge(v, len));
            graph[v].push_back(edge(u, len));
        }
        solve();
    }
    return 0;
}

Kruscal算法：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct edge {
    int a;
    int b;
    int cost;
};

vector<edge> graph;
vector<int> father;
int N, M;

int findFather(int i) {
    while (i != father[i]) i = father[i];
    return i;
}

void solve() {
    sort(graph.begin(), graph.end(),
            [](const edge &a, const edge &b) { return a.cost < b.cost; });
    for (int i = 1; i <= N; ++i) father[i] = i;
    int cost = 0;
    for (int i = 0; i < M; ++i) {
        int fa = findFather(graph[i].a);
        int fb = findFather(graph[i].b);
        if (findFather(fa) != findFather(fb)) {
            cost += graph[i].cost;
            if (fa < fb) 
                father[fb] = fa;
            else 
                father[fa] = fb;
        }
    }
    cout << cost << endl;
}

int main() {
    while (cin >> N >> M) {
        father.resize(N + 1);
        graph.resize(M);
        for (int i = 0; i < M; ++i) {
            cin >> graph[i].a >> graph[i].b >> graph[i].cost;
        }
        solve();
    }
    return 0;
}