c++ 最小生成数

class Solution {
public:
    int prim(int n, vector<vector<int>>& matrix) {
        int ans = 0;
        vector<int> used(n), cost(n, INT_MAX);
        cost[0] = 0;
        while (true) {
            int v = -1;
            for (int u = 0; u < n; u++) {
                if (!used[u] and (v == -1 or cost[u] < cost[v])) {
                    v = u;
                }
            }
            if (v == -1) break;
            used[v] = 1;
            ans += cost[v];
            for (int u = 0; u < n; u++) {
                cost[u] = min(cost[u], matrix[v][u]);
            }
        }
        return ans;
    }

    int minCostConnectPoints_prim(vector<vector<int>>& points) {
        int n = points.size();
        vector<vector<int>> matrix(n, vector<int>(n));
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int d = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]);
                matrix[i][j] = matrix[j][i] = d;
            }
        }
        return prim(n, matrix);
    }

    struct Edge {
        int d, i, j;

        bool operator< (const Edge& e) const {
            return d < e.d;
        }
    };

    int kruskal(int n, vector<Edge>& edges) {
        vector<int> p(n);
        iota(p.begin(), p.end(), 0);

        auto find = [&](auto&& find, int v) {
            if (p[v] == v) {
                return v;
            }
            return p[v] = find(find, p[v]);
        };

        auto merge = [&] (int v, int w) {
            int pv = find(find, v);
            int pw = find(find, w);
            if (pv == pw) return;
            p[pv] = pw;
        };

        auto is_connected = [&](int v, int w) {
            return find(find, v) == find(find, w);
        };

        int ans = 0;
        for (auto& e : edges) {
            if (is_connected(e.i, e.j)) {
                continue;
            }
            ans += e.d;
            merge(e.i, e.j);
        }
        return ans;
    }

    int minCostConnectPoints(vector<vector<int>>& points) {
        int n = points.size();
        vector<Edge> edges;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int d = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]);
                edges.push_back({d, i, j});
            }
        }
        sort(edges.begin(), edges.end());
        return kruskal(n, edges);
    }
};