华为OD 2024笔试机试 - 城市聚集度/找城市 (c++ C卷D卷真题算法)

华为OD机试（C卷+D卷）2024真题目录(Java & c++ & python)

题目描述

一张地图上有n个城市，城市和城市之间有且只有一条道路相连：要么直接相连，要么通过其它城市中转相连（可中转一次或多次）。城市与城市之间的道路都不会成环。

当切断通往某个城市 i 的所有道路后，地图上将分为多个连通的城市群，设该城市i的聚集度为DPi（Degree of Polymerization），DPi = max（城市群1的城市个数，城市群2的城市个数，…城市群m 的城市个数）。

请找出地图上DP值最小的城市（即找到城市j，使得DPj = min(DP1,DP2 … DPn))

提示：如果有多个城市都满足条件，这些城市都要找出来（可能存在多个解）

提示：DPi的计算，可以理解为已知一棵树，删除某个节点后；生成的多个子树，求解多个子数节点数的问题。

输入描述

每个样例：第一行有一个整数N，表示有N个节点。1 <= N <= 1000。

接下来的N-1行每行有两个整数x，y，表示城市x与城市y连接。1 <= x, y <= N

输出描述

输出城市的编号。如果有多个，按照编号升序输出。

用例1

输入

5
1 2
2 3
3 4
4 5

输出

3

说明
输入表示的是如下地图：

对于城市3，切断通往3的所有道路后，形成2个城市群[（1，2），（4，5）]，其聚集度分别都是2。DP3 = 2。

对于城市4，切断通往城市4的所有道路后，形成2个城市群[（1，2，3），（5）]，DP4 = max（3，1）= 3。

依次类推，切断其它城市的所有道路后，得到的DP都会大于2，因为城市3就是满足条件的城市，输出是3。

用例2

输入

6
1 2
2 3
2 4
3 5
3 6

输出

2 3

说明 将通往2或者3的所有路径切断，最大城市群数量是3，其他任意城市切断后，最大城市群数量都比3大，所以输出2 3

解题思路

用图解来解释一下用例1：

要求找出地图上DP值最小的城市（即找到城市j，使得DPj = min(DP1,DP2 … DPn))，

因此DP3最小，输出DP3的3。

实际就是求解删除一个节点后求最大的联通块大小=DPi，再取其中最小的DPi。

求联通块的方法有很多，可以建图后进行BFS或者DFS来得到联通块的大小，由于题集里上一题是用的并查集，这里偷懒直接复用一些前面代码，关于并查集的知识点可以到题集找上一题的图解学习。

删除某个节点=并查集合并时，跟这个节点相关的都跳过即可。

参考代码

#include <bits/stdc++.h>
using namespace std;

// 并查集实现
class UnionFindSet {
public:
    int *fa;

    explicit UnionFindSet(int n) {
        fa = new int[n];
        for (int i = 0; i < n; i++) fa[i] = i;
    }

    int find(int x) {
        if (x != fa[x]) {
            fa[x] = find(fa[x]);
        }
        return fa[x];
    }

    void merge(int x, int y) {
        int x_fa = find(x);
        int y_fa = find(y);

        if (x_fa != y_fa) {
            fa[y_fa] = x_fa;
        }
    }

    ~UnionFindSet() {
        delete[] fa;
    }
};

int main() {
    int n;
    cin >> n;

    vector<pair<int, int>> relations(n - 1);
    for (int i = 0; i < n - 1; i++) {
        cin >> relations[i].first >> relations[i].second;
    }

    // 记录最小dpi
    int minDp = INT_MAX;
    // 记录最小dpi对应的切断城市
    vector<int> city;

    // i 是被切断城市
    for (int i = 1; i <= n; i++) {
        // 利用并查集对城市进行关联
        UnionFindSet ufs(n + 1);

        for (const auto &relation : relations) {
            int x = relation.first;
            int y = relation.second;

            // 如果x或y是被切断城市，则对应连接关系不成立
            if (x == i || y == i) continue;

            // 否则连接x和y
            ufs.merge(x, y);
        }

        vector<int> cnts(n + 1, 0);
        for (int j = 1; j <= n; j++) {
            // 对j=1~n每个城市找根fa
            int fa = ufs.find(j);
            // 根fa下的子城市个数++
            cnts[fa]++;
        }

        // cnts的最大值即最大城市群大小
        int dp = *max_element(cnts.begin(), cnts.end());

        // 和minDp比较，保留最小值
        if (dp < minDp) {
            minDp = dp;
            city.clear();
            city.emplace_back(i);
        } else if (dp == minDp) {
            city.emplace_back(i);
        }
    }

    // 如果有多个，按照编号升序输出。
    sort(city.begin(), city.end());

    for (const auto &item : city) {
        cout << item << " ";
    }
    cout << endl;

    return 0;
}