每周题解：繁忙的都市

题目链接

繁忙的都市

题目描述

城市 C 是一个非常繁忙的大都市，城市中的道路十分的拥挤，于是市长决定对其中的道路进行改造。城市 C 的道路是这样分布的：城市中有 $n$ 个交叉路口，有些交叉路口之间有道路相连，两个交叉路口之间最多有一条道路相连接。这些道路是双向的，且把所有的交叉路口直接或间接的连接起来了。每条道路都有一个分值，分值越小表示这个道路越繁忙，越需要进行改造。但是市政府的资金有限，市长希望进行改造的道路越少越好，于是他提出下面的要求：

1. 改造的那些道路能够把所有的交叉路口直接或间接的连通起来。
2. 在满足要求 1 的情况下，改造的道路尽量少。
3. 在满足要求 1、2 的情况下，改造的那些道路中分值最大的道路分值尽量小。

任务：作为市规划局的你，应当作出最佳的决策，选择哪些道路应当被修建。

输入格式

第一行有两个整数 $n,m$ 表示城市有 $n$ 个交叉路口，$m$ 条道路。

接下来 $m$ 行是对每条道路的描述，$u,v,c$ 表示交叉路口 $u$ 和 $v$ 之间有道路相连，分值为 $c$。

输出格式

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

样例 #1

样例输入 #1

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

样例输出 #1

3 6

提示

数据范围及约定

对于全部数据，满足 $1\le n\le 300$，$1\le c\le 10^4$，$1\le m\le 8000$。

算法思想

根据题目描述，道路改造后所有交叉路口依然保持连通，改造的道路尽量少，并且改造的那些道路中分值最大的道路分值尽量小。

为了保证改造后依旧是连通的，可以在图中生成一棵树，也就是选择$n-1$条边使图依然保持连通，并且此时改造的道路最少。

那么如何保证分值最大的那条道路分值尽量小呢？这里有两种思路。

二分答案

求分值最大的那条道路分值最小，通常可以用二分答案来解决。基本思想是：

• 对所有边按边权从小到大排序
• 在$1\sim m$中选择中间位置$mid$，检查用$1\sim mid$的所有边能否将$n$个交叉路口连接起来
  • 如果能够连通，再到$1\sim mid$查找答案
  • 否则不能连通，再到$mid+1\sim m$查找答案

检查过程中，可以使用并查集的思想来统计连通块中点的个数，判断是否通过若干条边将$n$个点连接起来。

时间复杂度

将所有边排序的排序时间复杂度为$O(mlogm)$，二分答案的时间复杂度为$O(mlogm)$。

代码实现

#include <bits/stdc++.h>
using namespace std;
const int M = 16005;
struct E {
    int a, b, c;
    bool operator < (const E &e) const
    {
        return c < e.c;
    }
}e[M];
int n, m, p[M];
int find(int x)
{
    if(x != p[x]) p[x] = find(p[x]);
    return p[x];
}
bool check(int mid)
{
    for(int i = 1; i <= mid; i ++) p[i] = i; //并查集初始化
    int cnt = 1; //连通块中的点数初始化为1
    for(int i = 1; i <= mid; i ++)
    {
        int a = e[i].a, b = e[i].b, c = e[i].c;
        a = find(a), b = find(b);
        if(a != b) //如果a和b不连通，则将它们连通起来
        {
            p[a] = b;
            cnt ++; //连通块的点数+1
        }
    }
    return cnt == n; //如果连通块中的点数为n，说明所有点连通起来了
}
int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        e[i] = {a, b, c};
    }
    sort(e + 1, e + m + 1);
    int L = 1, R = m;
    while(L < R)
    {
        int mid = (L + R) / 2;
        if(check(mid)) R = mid;
        else L = mid + 1;
    }
    cout << n - 1 << " " << e[L].c << endl;
    return 0;
}

最小生成树

与一般意义的（所有边权和最小的）最小生成树不同，本题中要求的是最大的边权最小的最小生成树。考虑使用Kruskal算法求最小生成树的基本思想：

• 将所有边按边权从小到大排序
• 从小到大依次枚举每条边，$a,b,c$，其中边权为$c$：
  • 如果 $a$和$b$已经连通，那么直接跳过
  • 如果 $a$和$b$不连通，那么就将当前边选出来，将$a$和$b$纳入一个连通块
• 当所有点都在同一个连通块时，最小生成树建立完毕。

在这个过程中，由于边权是按从小到大排序的，因此连通最后一个点所使用的边，就是生成树中边权最大的边。

由此可见，Kruskal 算法求出的最小生成树，不但总权值和最小，而且最大边的边权一定是所有的生成树最大边中最小的。

时间复杂度

将所有边排序的排序时间复杂度为$O(mlogm)$，Kruskal时间复杂度为$O(m)$。

代码实现

#include <bits/stdc++.h>
using namespace std;
const int M = 16005;
struct E {
    int a, b, c;
    bool operator < (const E &e) const
    {
        return c < e.c;
    }
}e[M];
int n, m, p[M];
int find(int x)
{
    if(x != p[x]) p[x] = find(p[x]);
    return p[x];
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        e[i] = {a, b, c};
    }
    sort(e + 1, e + m + 1);
    for(int i = 1; i <= m; i ++) p[i] = i;
    int ans;
    for(int i = 1; i <= m; i ++)
    {
        int a = find(e[i].a), b = find(e[i].b), c = e[i].c;
        if(a != b) {
            p[a] = b;
            ans = c;
        }
    }
    cout << n - 1 << " " << ans << endl;
    return 0;
}