Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Minimum Spanning Tree

For a given weighted graph $G = (V, E)$, find the minimum spanning tree (MST) of $G$ and print total weight of edges belong to the MST.

Input

In the first line, an integer $n$ denoting the number of vertices in $G$ is given. In the following $n$ lines, a $n \times n$ adjacency matrix $A$ which represents $G$ is given.
$a_{ij}$ denotes the weight of edge connecting vertex $i$ and vertex $j$. If there is no edge between $i$ and $j$, $a_{ij}$ is given by -1.

Output

Print the total weight of the minimum spanning tree of $G$.

Constraints

$1 \leq n \leq 100$

$0 \leq a_{ij} \leq 2,000$ (if $a_{ij} \neq -1$)

$a_{ij} = a_{ji}$

$G$ is a connected graph

Sample Input 1

5
-1 2 3 1 -1
2 -1 -1 4 -1
3 -1 -1 1 1
1 4 1 -1 3
-1 -1 1 3 -1

Sample Output 1

5

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in JAVA (judge verdict: Accepted)

import java.util.LinkedList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Iterator;

class Edge {
    private int srcVertex;
    private int destVertex;

    public Edge (int src, int dest) {
        srcVertex = src;
        destVertex = dest;
    }

    public boolean equals(Object other) {
        return (other instanceof Edge) && (((Edge) other).srcVertex == srcVertex) && (((Edge) other).destVertex == destVertex);
    }

    public int hashCode() {
        return srcVertex + destVertex * destVertex;
    }
}

class Graph {
	private int totalVertex;
    private LinkedList<LinkedList<Integer>> adjList;
    private HashMap<Edge, Integer> edgeMap;
    private int[][] adjMatrix;

    public Graph() {
        adjList = new LinkedList<>();
        edgeMap = new HashMap<>();
    }

    public void initializeAdjList() {
        Scanner input = new Scanner(System.in);
        totalVertex = input.nextInt();

        for (int i = 0; i < totalVertex; i++) {
            LinkedList<Integer> neighborList = new LinkedList<>();
            input.nextInt();
            int numNeighbors = input.nextInt();
            for (int j = 0; j < numNeighbors; j++) {
                int neighbor = input.nextInt();
                neighborList.add(neighbor);
                edgeMap.put(new Edge(i, neighbor), input.nextInt());
            }
            adjList.add(neighborList);
        }

        input.close();
    }

    public void initializeAdjMatrix() {
        Scanner input = new Scanner(System.in);
        totalVertex = input.nextInt();
        adjMatrix = new int[totalVertex][totalVertex];

        for (int i = 0; i < totalVertex; i++) {
            for (int j = 0; j < totalVertex; j++) {
                adjMatrix[i][j] = input.nextInt();
            }
        }
        input.close();
    }

    public void Dijkstra() {
        int[] distances = new int[totalVertex];
        boolean[] visited = new boolean[totalVertex];

        for (int i = 1; i < distances.length; i++) {
            distances[i] = Integer.MAX_VALUE;
        }

        int currVertex = 0;
        for (int i = 0; i < totalVertex && distances[currVertex] < Integer.MAX_VALUE; i++) {
            currVertex = findMinVertex(distances, visited);
            visited[currVertex] = true;
            LinkedList<Integer> neighborList = adjList.get(currVertex);

            for (Integer neighbor : neighborList) {
                if (!visited[neighbor]) {
                    relax(currVertex, neighbor, distances, edgeMap.get(new Edge(currVertex, neighbor)));
                }
            }
        }

        for (int i = 0; i < totalVertex; i++) {
            System.out.println(i + " " + distances[i]);
        }
    }

    public int findMinVertex(int[] distances, boolean[] visited) {
        int minIndex = 0;
        for (int i = 0; i < visited.length; i++) {
            if (!visited[i]) {
                minIndex = i;
                break;
            }
        }

        for (int i = 1; i < distances.length; i++) {
            if (!visited[i] && distances[i] < distances[minIndex]) {
                minIndex = i;
            }
        }

        return minIndex;
    }

    public void relax(int src, int dest, int[] distances, int weight) {
        int newDistance = distances[src] + weight;
        if (newDistance < distances[dest]) {
            distances[dest] = newDistance;
        }
    }

    public void Prim() {
        int[] distances = new int[totalVertex];
        boolean[] visited = new boolean[totalVertex];

        for (int i = 1; i < distances.length; i++) {
            distances[i] = Integer.MAX_VALUE;
        }

        int currVertex = 0;
        for (int i = 0; i < totalVertex && distances[currVertex] < Integer.MAX_VALUE; i++) {
            currVertex = findMinVertex(distances, visited);
            visited[currVertex] = true;
            
            int[] neighborsArray = adjMatrix[currVertex];

            for (int j = 0; j < neighborsArray.length; j++) {
                if (!visited[j] && neighborsArray[j] != -1) {
                    primRelax(j, distances, neighborsArray[j]);
                }
            }
        }

        int sum = 0; 
        for (int i = 0; i < distances.length; i++) {
            sum += distances[i];
        }

        System.out.println(sum);
    }

    public void primRelax(int dest, int[] distances, int weight) {
        if (weight < distances[dest]) {
            distances[dest] = weight;
        }
    }
}

//change class name GraphRepresentation to Main() for submission to AIZU
public class Main {
	public static void main(String argv[]) {
	Graph g = new Graph();
        g.initializeAdjMatrix();
        g.Prim();
	}
}