Leetcode 1579. 保证图可完全遍历

最新推荐文章于 2022-10-07 20:59:43 发布

原创最新推荐文章于 2022-10-07 20:59:43 发布 · 402 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 同时被 2 个专栏收录

19 篇文章

订阅专栏

并查集

3 篇文章

订阅专栏

本文介绍了一种使用并查集与路径压缩算法解决图遍历问题的方法，通过处理不同类型边，确保图可被两个角色完全遍历，同时最大化可删除边的数量。

解法：并查集+路径压缩

设置并查集 father[] ，father_2

对type = 3进行并查集操作，将边一条一条压入并查集中，然后对于在一个father中的边，不加入并查集，并统计数量为ans，即type=3可以删除的边。

father_2 保存一下father的结果，一会给type=2用

根据type = 1获得 father[] ，父亲儿子的信息（即并查集的信息），继续对type=1的边做并查集操作，如果两条边在一个并查集，则不加入，并统计数量为ans1，

同理对于father_2 ，就行type=2 的并查集操作，结果计数为ans3

当然，在判断完type=1 的并查集和type=2的并查集时候，需要判断其中的并查集是否包含了所有的点。如果不包含，则直接返回-1

如果没有-1，则返回结果 ans + ans1 + ans2

题意：

1579. 保证图可完全遍历

难度困难15收藏分享切换为英文关注反馈

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

提示：

1 <= n <= 10^5
1 <= edges.length <= min(10^5, 3 * n * (n-1) / 2)
edges[i].length == 3
1 <= edges[i][0] <= 3
1 <= edges[i][1] < edges[i][2] <= n
所有元组 (typei, ui, vi) 互不相同

代码：

class Solution:
    def maxNumEdgesToRemove(self, n: int, edges: List[List[int]]) -> int:
        father,ans,ans1,ans2 = [i for i in range(n+1)] , 0,0,0
        #print(father,"  father1")
        def find(a):
            if(a!=father[a]):
                father[a]= find(father[a])
            return father[a]

        def merge(a,b):
            temp1 = find(a)
            temp2 = find(b)
            if(temp1== temp2): pass
            father[temp2] = temp1

#  type = 3
        for edge in edges:
            if(edge[0]==3):
                father_a = find(edge[1])
                father_b = find(edge[2])
                if(father_a == father_b):
                    ans+=1
                else:
                    merge(edge[1],edge[2])
        father_2 = father.copy()
# type = 2
        for edge in edges:
            if(edge[0]==1):
                father_a = find(edge[1])
                father_b = find(edge[2])
                if(father_a == father_b):
                    ans1+=1
                else:
                    merge(edge[1],edge[2])
        
        for i in range(1,n+1):
            if(find(1) == find(i)):pass
            else: return -1
        father = father_2

        for edge in edges:
            if(edge[0]==2):
                father_a = find(edge[1])
                father_b = find(edge[2])
                if(father_a == father_b):
                    ans2+=1
                else:
                    merge(edge[1],edge[2])
        
        for i in range(1,n+1):
            if(find(1) == find(i)):pass
            else: return -1        

        return ans+ans1+ans2