Алгоритм Крускала минимальный выход связующего дерева

Question

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

typedef pair<int,int> intPair;
typedef vector<double> doubleVector; 
typedef vector<intPair> intPairVector; 

// Union-Find Disjoint Sets Library written in OOP manner, using both path compression and union by rank heuristics
class UnionFind {                                          
private:
        doubleVector p, rank, setSize;               
        int numSets;
public:
        UnionFind(int N) {
        setSize.assign(N, 1);
        numSets = N;
        rank.assign(N, 0);
        p.assign(N, 0);
        for (int i = 0; i < N; i++)
                p[i] = i;
        }
        int findSet(int i) {
                 return (p[i] == i) ? i : (p[i] = findSet(p[i]));
        }
        bool isSameSet(int i, int j) {
                return findSet(i) == findSet(j);
        }
        void unionSet(int i, int j) {
                if (!isSameSet(i, j)) {
                        numSets--;
                        int x = findSet(i), y = findSet(j);
 if (rank[x] > rank[y]) {
                                p[y] = x;
                                setSize[x] += setSize[y];
                        }
                        else{
                                p[x] = y;
                                setSize[y] += setSize[x];
                                if (rank[x] == rank[y])
                                        rank[y]++;
                        }
                }
        }
        int numDisjointSets() {
                return numSets;
        }
        int sizeOfSet(int i) {
                return setSize[findSet(i)];
        }
};

vector<intPairVector> AdjList;

int  main() {
        int num_verts=0;
        cin >> num_verts;


        //Pre-allocate a vector of num_verts rows, each of which is a vector
        //of num_verts copies of 0.0
        vector<vector<double> > matrix(num_verts, vector<double>(num_verts,0.0));

        for(int row = 0; row<num_verts;++row) {
                for(int col = 0; col<num_verts; ++col){
                        cin >> matrix[row][col];
                }
        }

        /*
        //print out the matrix we just read
        for(int row = 0; row<num_verts; ++row) {
for(int col=0; col<num_verts;++col){
                        cout << setprecision(2) << fixed <<  matrix[row][col] << "\t";
                }
                cout << "\n";
        }
        */


        vector< pair<double, intPair> > MST;

        //vector<intPairVector> MST;

        // Kruskal's algorithm merged
        AdjList.assign(num_verts, intPairVector());
        vector< pair<double, intPair> > EdgeList;   // (weight, two vertices) of the edge
        for (int row = 0; row<num_verts; ++row) {
                for(int col=0; col<num_verts;++col){
                        EdgeList.push_back(make_pair(matrix[row][col], intPair(row,col)));
                        AdjList[row].push_back(intPair(row,matrix[row][col]));
                        AdjList[col].push_back(intPair(col,matrix[row][col]));
                }
        }

        sort(EdgeList.begin(), EdgeList.end()); // sort by edge weight O(E log E)
                      // note: pair object has built-in comparison function

        MST = EdgeList;
        double  mst_cost = 0.0;
        UnionFind UF(num_verts);   // all V are disjoint sets initially
      **f**or (int i = 0; i < num_verts*num_verts; i++) {   // for each edge, O(E)
                pair<double,intPair> front = EdgeList[i];
                if (!UF.isSameSet(front.second.first, front.second.second)) {
                        // check
                        mst_cost += front.first; UF.unionSet(front.second.first, front.second.second);
                }
                else {
                        for(int j = 0; j<num_verts; j++) {
                        MST.erase(MST.begin()+j);
                        }
                        }
                                                              }
                        }
        }****

        //display the weight of the MST
        cout << setprecision(2) << fixed << mst_cost << "\n";

        //display the size of the matrix
        cout << matrix.size() << "\n";

        //display MST
        for(int row = 0; row<num_verts; ++row) {
                for(int col = 0; col<num_verts; ++col) {
                        cout << setprecision(2) << fixed << MST[row].first << "\t";
                }
                cout << "\n";

        }
  return 0;
}

Я пытаюсь реализовать MST для матрицы, мой код компилируется и выполняется. Тем не менее, я пытаюсь отслеживать MST, чтобы я мог отобразить его в конце. Всякий раз, когда я пытаюсь удалить элемент из матрицы, чтобы реализовать MST, я получаю неправильный ответ. Примером моего ввода является 4 0 2 2 6 2 0 5 1 2 5 0 1 6 1 1 0

Мой желаемый результат 4 4 0 2 0 0 2 0 0 1 0 0 0 1 0 1 1 0

Как я могу изменить этот код, чтобы сделать его правильным выводом? Заранее спасибо.