PTA 公路村村通（Prim & Kruskal）

题目描述

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数$N（\le 1000）$和候选道路数目$M（\le 3N）$；
随后的$M$行对应$M$条道路，每行给出 3 个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从 $1$ 到 $N$ 编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出 −1 ，表示需要建设更多公路。

输入样例:
6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:
12

题解一

很直白的最小生成树问题，要求输出边的和。使用Prim算法解决。

分析题意，$N（N\le 1000）$个节点，最多有 $3N$ 条边，应该是个稀疏图，所以使用邻接表来保存图。

所以还需要建一个边的封装类：

class Line
{
	int source;
	int target;
	int distance;

	public Line(int source, int target, int distance)
	{
		this.source = source;
		this.target = target;
		this.distance = distance;
	}
}

核心思路：

1. 创建邻接表List [] graph，来储存边信息。graph[i]代表与节点 i 相邻的所有边。（注意，这是个无向图，应该双向赋值）
2. 根据题目需求，创建辅助结构。包括check数组：记录某个节点是否被收录；lineCount，统计目前被收录的边数量；resultNum记录收录边之和。
3. 随机选择一个节点收录，并作初始化（通常情况取第一个节点做起始节点，check[i] = 1）。
4. 进入Prim算法核心逻辑，遍历已收录节点的所有邻边，找到一个满足距离最小，而且边的目标节点未被收录这两个条件的边。将这条边和边连接的节点收录进来。循环这步操作，直到收录的边数lineCount比节点数 N 小一。
5. 如果循环中没有找到合适的边，说明存在孤儿节点（或局部图）， 那就可以肯定无法生成最小生成树了。

实现代码：

public class MinTree
{
	private static final int MAX = 0x3f3f3f3f;

	class Line
	{
		int source;
		int target;
		int distance;

		public Line(int source, int target, int distance)
		{
			this.source = source;
			this.target = target;
			this.distance = distance;
		}
	}

	public static void main(String[] args)
	{
		new MinTree().minTree();
	}

	public void minTree()
	{
		// 构建邻接表
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		int M = in.nextInt();

		ArrayList<Line>[] graph = new ArrayList[N + 1];
		for (int i = 1 ; i <= N ; i++) {
			graph[i] = new ArrayList<>();
		}
		int a, b, c;
		for (int i = 0 ; i < M ; i++)
		{
			a = in.nextInt();
			b = in.nextInt();
			c = in.nextInt();
			graph[a].add(new Line(a, b, c));
			graph[b].add(new Line(b, a, c));
		}
		in.close();

		// Prim算法
		int result = 0;
		int [] checked = new int[N + 1];
		checked[1] = 1;
		int lineCount = 0;

		while (lineCount < N - 1)
		{
			// 找到最小边
			int tempMin = MAX;
			int tempIndex = -1;
			for (int i = 1 ; i <= N ; i++)
			{
				// 未确认的节点相邻的边跳过
				if (checked[i] == 0) {
					continue;
				}

				for (Line line : graph[i])
				{
					if (checked[line.target] == 0 && line.distance < tempMin)
					{
						tempMin = line.distance;
						tempIndex = line.target;
					}
				}
			}

			if (tempIndex == -1) {
				System.out.println(-1);
				return;
			}

			// 找到了满足条件的边和节点
			checked[tempIndex] = 1;
			result += tempMin;
			lineCount++;
		}

		System.out.println(result);
	}

}

$N$为节点数，$M$为边数。

时间复杂度：$O(N^2)$。
外层循环$N$次，找最小边的过程耗时$O(N)$，实际比这个值要小，跟边的关系很大。图比较稀疏时找最小边耗时接近$O(1)$。

空间复杂度：$O(N+M)$。
邻接表需要记录所有节点的所有邻边，由于无向图，边需要存储两份，空间开销为$N+2M$。

题解二

相比Prim算法，这种稀疏图更适合用Kruskal解法。

因为Kruskal算法通过按顺序遍历边来选择，图边比较少的情况下，很容易找到$N-1$条合适边。

当然，也需要题解一中的Line类来存放边的信息。

核心思路：

1. 读入所有边，装入List lines中，并按每条边的distance从小到大排序。
2. 遍历排序好的lines，判断line.source和line.target连不连通（并查集找跟节点）。如果连通，说明这条边不能收录，不然会形成环。否则将这条边收录，并将两个集合合并。
3. 重复第二步的过程，直到收录边的数量达到$N-1$，最小生成树就生成完毕。
4. 如果遍历完了边，还是没有让收录边的数量达到$N-1$，说明存在孤儿节点（或局部图），可以肯定无法生成最小生成树了。

实现代码：

public void minTree() throws Exception
{
	// 读入所有的边
	Scanner in = new Scanner(System.in);
	int N = in.nextInt();
	int M = in.nextInt();

	List<Line> lists = new ArrayList<>();
	int a, b, c;
	for (int i = 0 ; i < M ; i++)
	{
		a = in.nextInt();
		b = in.nextInt();
		c = in.nextInt();
		lists.add(new Line(a, b, c));
	}
	// 将所有的边按distance排序
	lists.sort(Comparator.comparingInt(o -> o.distance));
	in.close();

	// Kruskal算法
	int result = 0;
	// 并查集，根节点的值为-1
	int [] set = new int[N + 1];
	Arrays.fill(set, -1);
	int lineCount = 0;
	for (Line line : lists)
	{
		int s, t;
		// 找到source和target的根节点
		for (s = line.source ; set[s] > 0 ; s = set[s]);
		for (t = line.target ; set[t] > 0 ; t = set[t]);

		// source和target为同一集合，说明该边不能取，取了就成环啦！
		if (s == t)
			continue;

		// 到这一步，说明这两个集合不属于一个集合
		// 将target集和source集合并
		set[t] = s;

		lineCount++;
		result += line.distance;

		if (lineCount == N - 1) {
			System.out.println(result);
			return;
		}
	}

	// 正常情况应该在循环中就结束，如果到了这里，说明遍历了所有边后还没收录 N - 1 条
	System.out.println(-1);
}

$N$为节点数，$M$为边数。

时间复杂度：$O(MlogM)$。
将边按距离排序耗时$O(MlogM)$，找$N-1$条满足source和target不在一个集合里的边一共耗时$O(N+M)$，证明过程参考算法导论。

空间复杂度：$O(N+M)$。
存储所有边空间开销$O(M)$，并查集空间开销$O(N)$。