ACM HDOJ 1863 (畅通工程)

题目链接 http://acm.hdu.edu.cn/showproblem.php?pid=1863

程序一 kruskal 算法

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;
		}
	}

}

程序二 prim 算法

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;
	}

}