Алгоритм Краскала

#include <iostream>
#include <vector>
#include <fstream>
 
using namespace std;
 
int p[100000];
int rk[100000];
 
struct edge {
    int a, b, cost;
};
 
void init_dsu() {
    for (int i = 0; i < 100000; i++) {
        p[i] = i;
        rk[i] = 1;
    }
}
 
int get_root(int v) {
    if (p[v] == v) {
        return v;
    }
    else {
        return p[v] = get_root(p[v]); 
    }
}
 
bool merge(int a, int b) {
    int ra = get_root(a), rb = get_root(b);
 
    if (ra == rb) {
        return false;
    }
    else {
        if (rk[ra] < rk[rb]) {
            p[ra] = rb;
        }
        else if (rk[rb] < rk[ra]) {
            p[rb] = ra;
        }
        else {
            p[ra] = rb;
            rk[rb]++;
        }
 
        return true;
    }
}
 
void sort(edge** p, int N) {
    for (int i = 0; i < N - 1; i++) {
        for (int j = 0; j < N - i - 1; j++)
            if (p[j]->cost > p[j + 1]->cost)
                swap(p[j], p[j + 1]);
    }
}
 
 
 
int main()
{
    fstream input("input.txt");
    ofstream output("output.txt");
    int n, k = 1;
    input >> n;
    edge* Edges = new edge[k];
    int** A = new int* [n];
    for (int i = 0; i < n; i++) {
        A[i] = new int[n];
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            input >> A[i][j];
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = n - 1; j > i; j--) {
            if (A[i][j] > 0) {
                Edges[k-1].a = i;
                Edges[k-1].b = j;
                Edges[k-1].cost = A[i][j];
                k++;
            }
        }
    }
 
    init_dsu();
 
    edge** p = new edge*[k-1];
    for (int i = 0; i < k-1; i++)
        p[i] = &Edges[i];
 
    sort(p, k-1);
 
    int mst_weight = 0;
 
    init_dsu();
    int z = 0;
    for (int i = 0; z < n - 1; i++) {
        if (merge(p[i]->a, p[i]->b)) {     
            mst_weight += p[i]->cost;    
            output << p[i]->a +1 << " " << p[i]->b +1;
            output << endl;
            z++;
        }
    }
    output << endl;
 
    output << "Minimum: " << mst_weight << endl;
    return 0;
}

output << p[i]->a +1 << " " << p[i]->b +1;