如题~
Alice 和 Bob 共有一个无向图,其中包含 n 个节点和 3 种类型的边:
类型 1:只能由 Alice 遍历。
类型 2:只能由 Bob 遍历。
类型 3:Alice 和 Bob 都可以遍历。
给你一个数组 edges ,其中 edges[i] = [typei, ui, vi] 表示节点 ui 和 vi 之间存在类型为 typei 的双向边。请你在保证图仍能够被 Alice和 Bob 完全遍历的前提下,找出可以删除的最大边数。如果从任何节点开始,Alice 和 Bob 都可以到达所有其他节点,则认为图是可以完全遍历的。
返回可以删除的最大边数,如果 Alice 和 Bob 无法完全遍历图,则返回 -1 。
示例 1:
输入:n = 4, edges = [[3,1,2],[3,2,3],[1,1,3],[1,2,4],[1,1,2],[2,3,4]]
输出:2
解释:如果删除 [1,1,2] 和 [1,1,3] 这两条边,Alice 和 Bob 仍然可以完全遍历这个图。再删除任何其他的边都无法保证图可以完全遍历。所以可以删除的最大边数是 2 。
示例 2:
输入:n = 4, edges = [[3,1,2],[3,2,3],[1,1,4],[2,1,4]]
输出:0
解释:注意,删除任何一条边都会使 Alice 和 Bob 无法完全遍历这个图。
示例 3:
输入:n = 4, edges = [[3,2,3],[1,1,2],[2,3,4]]
输出:-1
解释:在当前图中,Alice 无法从其他节点到达节点 4 。类似地,Bob 也不能达到节点 1 。因此,图无法完全遍历。
我已经啥也不想说了。。
上代码:
int find_root(int *parent, int x)//寻找根节点
{
int x_root, a;//a是随手弄得,不重要
x_root = x;
while (x != parent[x]) {
x = parent[x];
}
while (parent[x_root] != x) {
a = parent[x_root];
parent[x_root] = x;
x_root = a;
}
return x;
}
int node_num = 0;//他有多少根。先设为0
void union_vertries(int *parent, int x, int y)//x和y就是龙套
{
int root1 = find_root(parent, x);
int root2 = find_root(parent, y);
if (root1 != root2) {
int min = root1 < root2 ? root1 : root2;
int max = root1 < root2 ? root2 : root1;
parent[max] = min;
node_num--;//合并之后,根数-1
}
}
int maxNumEdgesToRemove(int n, int** edges, int edgesSize, int* edgesColSize){
int *parent1 = (int*)malloc(sizeof(int) * (n + 1));
int *parent2 = (int*)malloc(sizeof(int) * (n + 1));
int *parent3 = (int*)malloc(sizeof(int) * (n + 1));//给他们分配空间
int bridge1 = 0;
int bridge2 = 0;
int bridge3 = 0;//每个边分析每个边自己的。这样容易一些
int end = 0;
// 初始化节点,每个节点的父节点都是自己
for (int i = 1; i <= n; i++) {
parent1[i] = i;
parent2[i] = i;
parent3[i] = i;
}
// 利用并查集,得到类型2场景所有节点的父节点,父节点为值最小的点
node_num = n;
for (int i = 0; i < edgesSize; i++) {
if (edges[i][0] == 2 || edges[i][0] == 3) {
bridge2++;
union_vertries(parent2, edges[i][1], edges[i][2]);
}
}
for (int i = 2; i <= n; i++) {
if (parent2[i] == i) {
return -1;
}
}
// 利用并查集,得到类型1场景所有节点的父节点,父节点为值最小的点
node_num = n;
for (int i = 0; i < edgesSize; i++) {
if (edges[i][0] == 1 || edges[i][0] == 3) {
bridge1++;
union_vertries(parent1, edges[i][1], edges[i][2]);
}
}
for (int i = 2; i <= n; i++) {
if (parent1[i] == i) {
return -1;
}
}
// 利用并查集,得到类型3场景所有节点的父节点,父节点为值最小的点
node_num = n;//有多少条分链
for (int i = 0; i < edgesSize; i++) {
if (edges[i][0] == 3) {
bridge3++;
union_vertries(parent3, edges[i][1], edges[i][2]);
}
}
// 独属于场景1的边
bridge1 -= bridge3;
// 独属于场景2的边
bridge2 -= bridge3;
// 多余的场景3的边;
end = bridge3 - (n - node_num);
end += bridge1 - (node_num - 1) + bridge2 - (node_num - 1);
return end;
}