LeetCode 5650 执行交换操作后的最小汉明距离(并查集)

5650. 执行交换操作后的最小汉明距离

给你两个整数数组 source 和 target ，长度都是 n 。还有一个数组 allowedSwaps ，其中每个 allowedSwaps[i] = [ai, bi] 表示你可以交换数组 source 中下标为 ai 和 bi（下标从 0 开始）的两个元素。注意，你可以按 任意 顺序 多次 交换一对特定下标指向的元素。

相同长度的两个数组 source 和 target 间的 汉明距离 是元素不同的下标数量。形式上，其值等于满足 source[i] != target[i] （下标从 0 开始）的下标 i（0 <= i <= n-1）的数量。

在对数组 source 执行 任意 数量的交换操作后，返回 source 和 target 间的 最小汉明距离 。

示例 1：

输入：source = [1,2,3,4], target = [2,1,4,5], allowedSwaps = [[0,1],[2,3]]
输出：1
解释：source 可以按下述方式转换：
- 交换下标 0 和 1 指向的元素：source = [2,1,3,4]
- 交换下标 2 和 3 指向的元素：source = [2,1,4,3]
source 和 target 间的汉明距离是 1 ，二者有 1 处元素不同，在下标 3 。
示例 2：

输入：source = [1,2,3,4], target = [1,3,2,4], allowedSwaps = []
输出：2
解释：不能对 source 执行交换操作。
source 和 target 间的汉明距离是 2 ，二者有 2 处元素不同，在下标 1 和下标 2 。
示例 3：

输入：source = [5,1,2,4,3], target = [1,5,4,2,3], allowedSwaps = [[0,4],[4,2],[1,3],[1,4]]
输出：0
 

提示：

n == source.length == target.length
1 <= n <= 105 1 <= source[i],target[i] <= 105
0 <= allowedSwaps.length <= 105
allowedSwaps[i].length == 2
0 <= ai, bi <= n - 1 ai != bi

解题思路：

1. 对于所有的交换关系，使用并查集合并，如果交换的下标i,j,属于同一集合，该集合下任意两个都可以进行交换
2. 统计source中所有的元素在某个集合中出现的次数
3. 判断target中的元素是否出现在某个集合中，如果出现，则表明可以交换得到，则该元素对汉明码的距离无贡献，如果没出现，则表明不能交换得到，该元素对汉明码的距离有贡献。

class ufd//并查集
{
public:
    vector<int> f;
    ufd(int n)
    {//初始化
        f.resize(n);
        for(int i=0;i<n;i++)
            f[i] = i;
    }

    void merge(int a,int b)
    {//合并到同一个集合
        int fa = getFather(a);
        int fb = getFather(b);
        f[fa] = fb;
    }

    int getFather(int x)
    {//获取该集合的代表，当f[x]==x标明找到集合的代表
        return f[x]==x?x:getFather(f[x]);
    }
};



class Solution {
public:
    int minimumHammingDistance(vector<int>& source, vector<int>& target, vector<vector<int>>& allowedSwaps) {
        int size = source.size();
        ufd ufd_m(size);
        for(auto &a:allowedSwaps)
        {
            ufd_m.merge(a[0],a[1]);
        }
        unordered_map<int,unordered_map<int,int> > umap;
        for(int i=0;i<size;i++)
        {
            int fa = ufd_m.getFather(i);
            umap[fa][source[i]]++;
        }
        int same = 0;
        for(int i=0;i<size;i++)
        {
            int fa = ufd_m.getFather(i);
            if(umap[fa][target[i]] > 0)
            {//能通过交换得到
                same++;
                umap[fa][target[i]]--;
            }
        }

        return size - same;
    }
};