1142 繁忙的都市（kruskal算法、二分）

1. 问题描述：

城市C是一个非常繁忙的大都市，城市中的道路十分的拥挤，于是市长决定对其中的道路进行改造。城市C的道路是这样分布的：城市中有 n 个交叉路口，编号是 1∼n，有些交叉路口之间有道路相连，两个交叉路口之间最多有一条道路相连接。这些道路是双向的，且把所有的交叉路口直接或间接的连接起来了。每条道路都有一个分值，分值越小表示这个道路越繁忙，越需要进行改造。但是市政府的资金有限，市长希望进行改造的道路越少越好，于是他提出下面的要求：
1．改造的那些道路能够把所有的交叉路口直接或间接的连通起来。
2．在满足要求1的情况下，改造的道路尽量少。
3．在满足要求1、2的情况下，改造的那些道路中分值最大值尽量小。
作为市规划局的你，应当作出最佳的决策，选择那些道路应当被修建。

输入格式

第一行有两个整数 n，m 表示城市有 n 个交叉路口，m 条道路。接下来 m 行是对每条道路的描述，每行包含三个整数u，v，c 表示交叉路口 u 和 v 之间有道路相连，分值为 c。

输出格式

两个整数 s，max，表示你选出了几条道路，分值最大的那条道路的分值是多少。

数据范围

1 ≤ n ≤ 300，
1 ≤ m ≤ 8000，
1 ≤ c ≤ 10000

输入样例：

4 5
1 2 3
1 4 5
2 4 7
2 3 6
3 4 8

输出样例：

3 6
来源：https://www.acwing.com/problem/content/description/1144/

2. 思路分析：

分析题目可以知道已知的是n个点，m条边的无向图，由要求1和2可以知道我们构造的道路一定是一棵树，这样才可以使得道路的数量最少，也即至少需要使用n - 1条边才可以将n个点联通，n - 1条边是最少的道路数目，而我们需要使得选择的n - 1条道路中最大的分值最小，并且我们知道最小生成树的n - 1条边构成的就是一种方案，最后一条边的权值是最大的，第n - 1条边是最小生成树中的边一定是最大分支中最小的值，所以最后一条边就是我们要求解的答案，我们做一遍kruskal算法并且在求解的过程中使用一个变量res来记录最小生成树的最后一条边即可。除了这种方法解决之外，我们可以根据"最小化最大分值"关键字可以得出这是一个最小最大问题所以还可以使用二分来解决，因为求解的是道路的分值，所以我们可以枚举道路的分值mid，使用check函数判断图中所有小于等于这个分值的道路是否处于同一个连通块中，如果在同一个连通块中说明答案在左边，那么更新右端点的值否则更新左端点的值，检查是否在同一个连通块中可以使用dfs，bfs或者并查集的方法，这里使用并查集的方法最容易写。

3. 代码如下：

kruskal：

from typing import List


class Solution:
    # 并查集的find函数查找x的父节点
    def find(self, x: int, fa: List[int]):
        if x != fa[x]:
            fa[x] = self.find(fa[x], fa)
        return fa[x]

    def process(self):
        n, m = map(int, input().split())
        w = list()
        for i in range(m):
            a, b, c = map(int, input().split())
            w.append((a, b, c))
        w.sort(key=lambda x: x[2])
        fa = [i for i in range(n + 1)]
        res = 0
        for i in range(m):
            a, b, c = w[i][0], w[i][1], w[i][2]
            t1, t2 = self.find(a, fa), self.find(b, fa)
            if t1 != t2:
                fa[t1] = t2
                # 到最后w存储的是最后一条边
                res = c
        # 因为需要最少的道路而且需要联通所以至少需要n - 1条边才可以将n个点联通
        print(n - 1, res, sep=" ")


if __name__ == "__main__":
    Solution().process()

二分：

from typing import List


class Solution:
    def find(self, x: int, fa: List[int]):
        if x != fa[x]:
            fa[x] = self.find(fa[x], fa)
        return fa[x]

    def check(self, n: int, mid: int, w: List[tuple]):
        fa = [i for i in range(n + 1)]
        for x in w:
            # 因为w是排好序的所以当发现有值大于mid之后说明后面的边权都是大于mid的直接break
            if x[2] > mid: break
            a, b = self.find(x[0], fa), self.find(x[1], fa)
            if a != b:
                fa[a] = b
        # 判断所有点是否在同一个连通块中
        p = self.find(1, fa)
        for i in range(2, n + 1):
            if self.find(i, fa) != p: return False
        # 只有当所有点在一个连通块中才符合要求
        return True

    def process(self):
        n, m = map(int, input().split())
        w = list()
        for i in range(m):
            a, b, c = map(int, input().split())
            w.append((a, b, c))
        w.sort(key=lambda x: x[2])
        l, r = 1, 10000
        while l < r:
            mid = l + r >> 1
            if self.check(n, mid, w):
                r = mid
            else:
                l = mid + 1
        print(n - 1, r, sep=" ")


if __name__ == "__main__":
    Solution().process()