Hi guys, my code is giving wrong result in test case 5 and 6. I could not find the reason. Could ou tell me what is wrong in my code? Thanks

// A Java program for Prim's Minimum Spanning Tree (MST) algorithm. // The program is for adjacency matrix representation of the graph

import java.util.; import java.lang.; import java.io.*;

class MST { // Number of vertices in the graph // private static final int V=5;

// A utility function to find the vertex with minimum key
// value, from the set of vertices not yet included in MST
int minKey(int key[], Boolean mstSet[], int V)
{
    // Initialize min value
    int min = Integer.MAX_VALUE, min_index=-1;

    for (int v = 0; v < V; v++)
        if (mstSet[v] == false && key[v] < min)
        {
            min = key[v];
            min_index = v;
        }

    return min_index;
}

// A utility function to print the constructed MST stored in
// parent[]
void printMST(int parent[], int n, int graph[][])
{
    //System.out.println("Edge   Weight");
    int sum=0;
    for (int i = 1; i < n; i++)
       // System.out.println(parent[i]+" - "+ i+"    "+

    sum+=graph[i][parent[i]];
    System.out.println(sum);
}


// Function to construct and print MST for a graph represented
//  using adjacency matrix representation
void primMST(int graph[][], int V)
{
    // Array to store constructed MST
    int parent[] = new int[V];

    // Key values used to pick minimum weight edge in cut
    int key[] = new int [V];

    // To represent set of vertices not yet included in MST
    Boolean mstSet[] = new Boolean[V];

    // Initialize all keys as INFINITE
    for (int i = 0; i < V; i++)
    {
        key[i] = Integer.MAX_VALUE;
        mstSet[i] = false;
    }

    // Always include first 1st vertex in MST.
    key[0] = 0;     // Make key 0 so that this vertex is
                    // picked as first vertex
    parent[0] = -1; // First node is always root of MST

    // The MST will have V vertices
    for (int count = 0; count < V-1; count++)
    {
        // Pick thd minimum key vertex from the set of vertices
        // not yet included in MST
        int u = minKey(key, mstSet,V);

        // Add the picked vertex to the MST Set
        mstSet[u] = true;

        // Update key value and parent index of the adjacent
        // vertices of the picked vertex. Consider only those
        // vertices which are not yet included in MST
        for (int v = 0; v < V; v++)

            // graph[u][v] is non zero only for adjacent vertices of m
            // mstSet[v] is false for vertices not yet included in MST
            // Update the key only if graph[u][v] is smaller than key[v]
            if (graph[u][v]!=0 && mstSet[v] == false &&
                graph[u][v] <  key[v])
            {
                parent[v]  = u;
                key[v] = graph[u][v];
            }
    }

    // print the constructed MST
    printMST(parent, V, graph);
}

public static void main (String[] args)
{
  Scanner scan=new Scanner(System.in);
    int num_of_nodes=scan.nextInt();
    int num_edge=scan.nextInt();
    int graph[][] = new int[num_of_nodes][num_of_nodes];       

    MST t = new MST();
     for(int j=0;j<num_of_nodes;j++){
            for(int k=0;k<num_of_nodes;k++){
              graph[j][k]=0;
            }
        }

        for(int j=0;j<num_edge;j++){
            int row=scan.nextInt();
            int col=scan.nextInt();
            int distance=scan.nextInt();
            if(graph[row-1][col-1]==0){
                graph[row-1][col-1]=distance;
                graph[col-1][row-1]=distance;
            }
            else{
                if(distance<graph[col-1][row-1]){
                 graph[row-1][col-1]=distance;
                graph[col-1][row-1]=distance;
                }


            }


        }

    //int start_node=scan.nextInt();

    // Print the solution
    t.primMST(graph,num_of_nodes);
}

}