leetcode-205场周赛

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 。

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

解题思路

1. 先判断Alice和Blob能否分别连通，如果不能则直接返回-1.
2. 其次计算在Alice和Blob两个最小生成树当中能够公用的最大的边的数量。这里需要明白一个性质，一个n个节点的图，其边的数量>=n-1时候，选择任意n-1个节点都可以得到生成树，那么此时我们使用第三种类型的边来构造并查集计算出来count个最大公共边，都可以囊括在Alice和Blob的各自的n-1个定点当中。

实现代码

class Solution 
{
    const static int MAXN = 1e5 + 10;
    int F[MAXN];

public :
    int maxNumEdgesToRemove(int n, vector<vector<int>>& edges) 
    {
        // 初始化并差集合数组
        initF(n);

        // 判断 alice 和 Bob 能否连通
        for(const auto & edge : edges)
        {
            if(edge[0] == 1 || edge[0] == 3)
            {
                int fu = uFind(edge[1]);
                int fv = uFind(edge[2]);
                if(fu != fv)
                    F[fu] = fv;
            }
        }
        if(!isConnected(n)) return -1;
        
        // cout << "Alice can" << endl;

        initF(n);

        for(const auto & edge : edges)
        {
            if(edge[0] == 2 || edge[0] == 3)
            {
                int fu = uFind(edge[1]);
                int fv = uFind(edge[2]);
                if(fu != fv)
                    F[fu] = fv;
            }
        }
        if(!isConnected(n)) return -1;
        initF(n);
        
        // cout << "Bob can" << endl;

        // 遍历添加三类型的边
        int count = 0;
        for(const auto & edge : edges)
        {
            if(edge[0] == 3)
            {
                int fu = uFind(edge[1]);
                int fv = uFind(edge[2]);
                if(fu != fv)
                {
                    F[fu] = fv;
                    count += 1;
                }
            }
        }

        // 计算最终的结果
        return edges.size() - 2 * (n - 1) + count; 
    }

private : 

    void initF(int n)
    {
        // 初始化并差集合数组
        for(int i = 1; i <= n; i++)
            F[i] = i;
    }

    int uFind(int x)
    {
        return x == F[x] ? x : F[x] = uFind(F[x]);
    }

    // 判断当前并茶几当中是否连通
    bool isConnected(int n) 
    {
        int ConnectionConunt = 0;
        for(int i = 1; i <= n; i++)
        {
            int father = uFind(i);
            if(father == i)
                ConnectionConunt++;
        }
        // cout << ConnectionConunt << endl;
        return ConnectionConunt == 1;
    } 
};