LeetCode 1615.最大网络秩

题目描述

n 座城市和一些连接这些城市的道路 roads 共同组成一个基础设施网络。每个 roads[i] = [ai, bi] 都表示在城市 ai 和 bi 之间有一条双向道路。

两座不同城市构成的 城市对 的 网络秩 定义为：与这两座城市 直接 相连的道路总数。如果存在一条道路直接连接这两座城市，则这条道路只计算 一次 。

整个基础设施网络的 最大网络秩 是所有不同城市对中的 最大网络秩 。

给你整数 n 和数组 roads，返回整个基础设施网络的 最大网络秩 。

示例 1：

输入：n = 4, roads = [[0,1],[0,3],[1,2],[1,3]]
输出：4
解释：城市 0 和 1 的网络秩是 4，因为共有 4 条道路与城市 0 或 1 相连。位于 0 和 1 之间的道路只计算一次。

示例 2：

输入：n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]]
输出：5
解释：共有 5 条道路与城市 1 或 2 相连。

示例 3：

输入：n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]]
输出：5
解释：2 和 5 的网络秩为 5，注意并非所有的城市都需要连接起来。

提示：

• 2 <= n <= 100
• 0 <= roads.length <= n * (n - 1) / 2
• roads[i].length == 2
• 0 <= ai, bi <= n-1
• ai != bi
• 每对城市之间 最多只有一条 道路相连

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/maximal-network-rank

题目分析

数据范围看上去也不大，直接暴搜会怎么样

class Solution {
public:
    int maximalNetworkRank(int n, vector<vector<int>>& roads) {
        vector<vector<int>> g(n); //记录与各个城市相连的城市
        int ans=0;
        int temp=0;
        for(int i=0;i<roads.size();i++){
            g[roads[i][0]].push_back(roads[i][1]);
            g[roads[i][1]].push_back(roads[i][0]);
        }
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                temp = g[i].size()+g[j].size();
                if(find(g[j].begin(),g[j].end(),i)!=g[j].end()) temp--; //减去重复的一条边
                ans=max(temp,ans);
            }
        }
        return ans;
    }
};

时间复杂度是$O(n^2)$，空间复杂度也是$O(n^2)$。但是结果感觉还行啊，甚至没有优化的兴趣了
还是再看看。
如果直接查找连接数量最多的两个城市呢？好像是可行的，但是如果存在度数一样多并且都为最多或者第二多的结点，需要用一个数组把这些结点都保存起来，最后再遍历这两个数组，选择网络秩最大的组合
不想写了，拿官方题解

class Solution {
public:
    int maximalNetworkRank(int n, vector<vector<int>>& roads) {
        vector<vector<bool>> connect(n, vector<bool>(n, false));
        vector<int> degree(n);
        for (auto road : roads) {
            int x = road[0], y = road[1];
            connect[x][y] = true;
            connect[y][x] = true;
            degree[x]++;
            degree[y]++;
        }

        int first = -1, second = -2;
        vector<int> firstArr, secondArr;
        for (int i = 0; i < n; ++i) {
            if (degree[i] > first) {
                second = first;
                secondArr = firstArr;
                first = degree[i];
                firstArr.clear();
                firstArr.emplace_back(i);
            } else if (degree[i] == first) {
                firstArr.emplace_back(i);
            } else if (degree[i] > second){
                secondArr.clear();
                second = degree[i];
                secondArr.emplace_back(i);
            } else if (degree[i] == second) {
                secondArr.emplace_back(i);
            }
        }
        if (firstArr.size() == 1) {
            int u = firstArr[0];
            for (int v : secondArr) {
                if (!connect[u][v]) {
                    return first + second;
                }
            }
            return first + second - 1;
        } else {
            int m = roads.size();
            if (firstArr.size() * (firstArr.size() - 1) / 2 > m) {
                return first * 2;
            }
            for (int u: firstArr) {
                for (int v: firstArr) {
                    if (u != v && !connect[u][v]) {
                        return first * 2;
                    }
                }
            }
            return first * 2 - 1;
        }
    }
};

作者：LeetCode-Solution
链接：https://leetcode.cn/problems/maximal-network-rank/solution/zui-da-wang-luo-zhi-by-leetcode-solution-x4gx/
来源：力扣（LeetCode）

这样时间复杂度为$O(n+m)$，空间复杂度为$O(n^2)$ 理论上是有提升，但是运行结果没有体现出来。

运行结果最好的代码如下：

class Solution {
public:
    int maximalNetworkRank(int n, vector<vector<int>>& roads)
    {
        int ans = -1;

        vector<vector<int>> adjMat(n, vector<int>(n, 0));
        vector<int> degree(n, 0);
        for (auto& road : roads)
        {
            adjMat[road[0]][road[1]] = 1;
            adjMat[road[1]][road[0]] = 1;
            degree[road[0]]++;
            degree[road[1]]++;
        }

        for (int i = 0; i < n - 1; i++)
        {
            for (int j = i + 1; j < n; j++)
            {
                ans = max(ans, degree[i] + degree[j] - adjMat[i][j]);
            }
        }

        return ans;
    }
};

也没看出来哪里有优化…

总结

自己做第二个解法时没有存储度数相同的结点，导致WA，考虑还是欠周全