ACM HDOJ 1863 (畅通工程)

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
while (scn.hasNext()) {
int edgesNumber = Integer.parseInt(scn.next());
if (0 == edgesNumber) {
break;
}
int pointsNumber = Integer.parseInt(scn.next());
Kruskal kruskal = new Kruskal(pointsNumber);
for (int i = 0; i < edgesNumber; ++i) {
int start = Integer.parseInt(scn.next()) - 1;
int end = Integer.parseInt(scn.next()) - 1;
int distance = Integer.parseInt(scn.next());
kruskal.addEdge(start, end, distance);
}
int distance = kruskal.calculateDistance();
if (kruskal.isConnected()) {
System.out.println(distance);
} else {
System.out.println("?");
}
}
scn.close();
}
}

class Kruskal {

private int[] flag;
private Queue<Edge> edges;

private int find(int r) {
while (r != flag[r]) {
r = flag[r];
}
return r;
}

public Kruskal(int pointsNumber) {
flag = new int[pointsNumber];
for (int i = 0; i < pointsNumber; ++i) {
flag[i] = i;
}
edges = new PriorityQueue<Edge>();
}

public void addEdge(int start, int end, int distance) {
edges.offer(new Edge(start, end, distance));
}

public int calculateDistance() {
int sumDistance = 0;
while (!edges.isEmpty()) {
Edge edge = edges.poll();
int start = edge.getStart();
int end = edge.getEnd();
int distance = edge.getDistance();
int startRoot = find(start);
int endRoot = find(end);
if (startRoot != endRoot) {
flag[startRoot] = endRoot;
sumDistance += distance;
}
}
return sumDistance;
}

public boolean isConnected() {
int count = 0;
for (int i = 0; i < flag.length; ++i) {
if (i == flag[i]) {
++count;
if (2 == count) {
return false;
}
}
}
return true;
}

}

class Edge implements Comparable<Edge> {

private int start;
private int end;
private int distance;

public Edge(int start, int end, int distance) {
this.start = start;
this.end = end;
this.distance = distance;
}

public int getStart() {
return start;
}

public int getEnd() {
return end;
}

public int getDistance() {
return distance;
}

@Override
public int compareTo(Edge edge) {
if (this.distance > edge.distance) {
return 1;
} else if (this.distance < edge.distance) {
return -1;
} else {
return 0;
}
}

}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner scn = new Scanner(System.in);
while (scn.hasNext()) {
int edgesNumber = Integer.parseInt(scn.next());
if (0 == edgesNumber) {
break;
}
int pointsNumber = Integer.parseInt(scn.next());
Prim prim = new Prim(pointsNumber);
for (int i = 0; i < edgesNumber; ++i) {
int start = Integer.parseInt(scn.next()) - 1;
int end = Integer.parseInt(scn.next()) - 1;
int distance = Integer.parseInt(scn.next());
prim.addEdge(start, end, distance);
}
int distance = prim.calculateDistance();
if (prim.isConnected()) {
System.out.println(distance);
} else {
System.out.println("?");
}
}
scn.close();
}

}

class Prim {

private final int INF = Integer.MAX_VALUE / 2;
private int pointsNumber;
private int[][] matrix;
private Edge[] edges;
private boolean connected;

public Prim(int pointsNumber) {
this.pointsNumber = pointsNumber;
matrix = new int[pointsNumber][pointsNumber];
for (int i = 0; i < pointsNumber; ++i) {
Arrays.fill(matrix[i], INF);
matrix[i][i] = 0;
}
edges = new Edge[pointsNumber];
connected = false;
}

public void addEdge(int start, int end, int distance) {
if (matrix[start][end] > distance) {
matrix[start][end] = matrix[end][start] = distance;
}
}

public int calculateDistance() {
int sumDistance = 0;
for (int i = 0; i < pointsNumber - 1; ++i) {
edges[i] = new Edge(0, i + 1, matrix[0][i + 1]);
}
for (int i = 0; i < pointsNumber - 1; ++i) {
int minPoint = i, minDistance = edges[i].getDistance();
for (int j = i + 1; j < pointsNumber - 1; ++j) {
if (edges[j].getDistance() < minDistance) {
minDistance = edges[j].getDistance();
minPoint = j;
}
}
if (INF == minDistance) {
return INF;
}
if (i != minPoint) {
Edge edge = edges[i];
edges[i] = edges[minPoint];
edges[minPoint] = edge;
}
sumDistance += edges[i].getDistance();
for (int j = i + 1; j < pointsNumber - 1; ++j) {
if (matrix[edges[i].getEnd()][edges[j].getEnd()] < edges[j]
.getDistance()) {
edges[j].setDistance(matrix[edges[i].getEnd()][edges[j]
.getEnd()]);
edges[j].setStart(edges[i].getEnd());
}
}
}
connected = true;
return sumDistance;
}

public boolean isConnected() {
return connected;
}

}

class Edge {

private int start;
private int end;
private int distance;

public Edge(int start, int end, int distance) {
this.start = start;
this.end = end;
this.distance = distance;
}

public void setStart(int start) {
this.start = start;
}

public int getEnd() {
return end;
}

public int getDistance() {
return distance;
}

public void setDistance(int distance) {
this.distance = distance;
}

}