【一看就会一写就废 指间算法】需要教语言的最少人数 —— 贪心、哈希表

指尖划过的轨迹，藏着最细腻的答案~

题目：

在一个由 m 个用户组成的社交网络里，我们获取到一些用户之间的好友关系。两个用户之间可以相互沟通的条件是他们都掌握同一门语言。

给你一个整数 n ，数组 languages 和数组 friendships ，它们的含义如下：

• 总共有 n 种语言，编号从 1 到 n 。
• languages[i] 是第 i 位用户掌握的语言集合。 friendships[i] = [u​​​​​​i​​​, v​​​​​​i] 表示 u​​​​​​​​​​​i​​​​​ 和 vi 为好友关系。
• 你可以选择 一门 语言并教会一些用户，使得所有好友之间都可以相互沟通。请返回你 最少 需要教会多少名用户。

请注意，好友关系没有传递性，也就是说如果 x 和 y 是好友，且 y 和 z 是好友， x 和 z 不一定是好友。

示例 1：

输入：n = 2, languages = [[1],[2],[1,2]], friendships = [[1,2],[1,3],[2,3]]
输出：1
解释：你可以选择教用户 1 第二门语言，也可以选择教用户 2 第一门语言。

示例 2：

输入：n = 3, languages = [[2],[1,3],[1,2],[3]], friendships = [[1,4],[1,2],[3,4],[2,3]]
输出：2
解释：教用户 1 和用户 3 第三门语言，需要教 2 名用户。

提示：

2 <= n <= 500
languages.length == m
1 <= m <= 500
1 <= languages[i].length <= n
1 <= languages[i][j] <= n
1 <= u​​​​​​i < v​​​​​​i <= languages.length
1 <= friendships.length <= 500
所有的好友关系 (u​​​​​i, v​​​​​​i) 都是唯一的。
languages[i] 中包含的值互不相同。

分析：

假如有10个无法沟通的人，他们可能会各种不同的语言，但有8个人都会中文，所以我们只需要教10 - 8 = 2 个人即可。

即我们总是贪心的寻找会的语言最多的人，因此我们需要统计如下信息：

• 无法沟通的总人数
• 无法沟通的所有人中会的最多的语言

具体的，在判断两个人是否可以沟通时，我们可以提前使用哈希表进行处理，这样可以在O(1)的时间复杂度内判断两个人是否可以沟通。

AC代码：

class Solution {
public:
    int minimumTeachings(int n, vector<vector<int>>& languages, vector<vector<int>>& friendships) {
        int m = languages.size();
        vector learned(m, vector<int8_t>(n + 1));
        for (int i = 0; i < m; i++) {
            for (int x : languages[i]) {
                learned[i][x] = true;
            }
        }

        unordered_set<int> noTalk;
        int total = 0; // 无法沟通的人的数量
        for (auto& f : friendships) {
            int u = f[0] - 1, v = f[1] - 1;
            bool ok = false;
            for (int l : languages[u]) {
                if (learned[v][l]) {
                    ok = true;
                    break;
                }
            }

            if (!ok) {
                noTalk.insert(u);
                noTalk.insert(v);
            }
        }

        vector<int> languagesCnt(n + 1);
        int maxCnt = 0;
        for (auto t : noTalk) {
            for (int l : languages[t]){
                languagesCnt[l]++;
                maxCnt = max(maxCnt, languagesCnt[l]);
            }
        }

        return noTalk.size() - maxCnt;
    }
};