Leetcode每日一题：1579. 保证图可完全遍历

问题描述

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 。因此，图无法完全遍历。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-max-number-of-edges-to-keep-graph-fully-traversable
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析及代码实现

思路：
首先是公共边，Alice和Bob都能走，然后分别加入各自并查集
然后各自走，如果已存在集合就可以删掉了
最后判断一下两条是否都已连通，如果不是那么返回-1，如果是那么返回删除数

class DSU:
    def __init__(self,n):
        self.father = [i for i in range(n+1)]
        self.num = n

    def find(self, x):
        if x != self.father[x]:
            self.father[x] = self.find(self.father[x])
        return self.father[x]
    

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)
        if root_x != root_y:
            self.father[root_x] = root_y
            self.num -= 1 

class Solution:
    def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:
        alice = DSU(n)
        bob = DSU(n)
        res = 0
        for tpyes, u, v in edges:
            if tpyes == 3:
                if alice.find(u) != alice.find(v):
                    alice.union(u, v)
                    bob.union(u, v)
                else:
                    res += 1
        for tpyes, u, v in edges:
            if tpyes == 1:
                if alice.find(u) != alice.find(v):
                    alice.union(u, v)
                else:
                    res += 1
            if tpyes == 2:
                if bob.find(u) != bob.find(v):
                    bob.union(u, v)
                else:
                    res += 1
        if alice.num * bob.num > 1:
            return -1
        else:
            return res