ACM HDOJ 1301 (Jungle Roads)

題目鏈接 http://acm.hdu.edu.cn/showproblem.php?pid=1301

程序一 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 pointsNumber = Integer.parseInt(scn.next());
			if (0 == pointsNumber) {
				break;
			}
			Kruskal kruskal = new Kruskal(pointsNumber);
			for (int i = 1; i < pointsNumber; ++i) {
				int start = getIndex(scn.next());
				int roadsNumber = Integer.parseInt(scn.next());
				while (0 <= --roadsNumber) {
					int end = getIndex(scn.next());
					int distance = scn.nextInt();
					kruskal.addEdge(start, end, distance);
				}
			}
			System.out.println(kruskal.calculateDistance());
		}
		scn.close();
	}

	public static int getIndex(String str) {
		return "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(str);
	}

}

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

}

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 pointsNumber = Integer.parseInt(scn.next());
			if (0 == pointsNumber) {
				break;
			}
			Prim prim = new Prim(pointsNumber);
			for (int i = 1; i < pointsNumber; ++i) {
				int start = getIndex(scn.next());
				int roadsNumber = Integer.parseInt(scn.next());
				while (0 <= --roadsNumber) {
					int end = getIndex(scn.next());
					int distance = Integer.parseInt(scn.next());
					prim.addEdge(start, end, distance);
				}
			}
			System.out.println(prim.calculateDistance());
		}
		scn.close();
	}

	public static int getIndex(String str) {
		return "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(str);
	}

}

class Prim {

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

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

	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());
				}
			}
		}
		return sumDistance;
	}

}

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

}