题目描述
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)
O(n2),空间复杂度也是
O
(
n
2
)
O(n^2)
O(n2)。但是结果感觉还行啊,甚至没有优化的兴趣了
还是再看看。
如果直接查找连接数量最多的两个城市呢?好像是可行的,但是如果存在度数一样多并且都为最多或者第二多的结点,需要用一个数组把这些结点都保存起来,最后再遍历这两个数组,选择网络秩最大的组合
不想写了,拿官方题解
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+m) O(n+m),空间复杂度为 O ( n 2 ) O(n^2) O(n2) 理论上是有提升,但是运行结果没有体现出来。
运行结果最好的代码如下:
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,考虑还是欠周全