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

/*
 * Problem: Given two integer arrays source and target of length n, and an array allowedSwaps where each allowedSwaps[i] = [ai, bi] indicates that you can swap the elements at indices ai and bi in the source array any number of times and in any order.
 * The Hamming distance between two arrays of the same length is the number of positions where the elements are different.
 * Return the minimum Hamming distance after performing any number of allowed swaps on the source array.
 */

import java.util.*;
import java.util.stream.*;

public class Solution {
    public int minimumHammingDistance(int[] source, int[] target, int[][] allowedSwaps) {
        int n = source.length;
        UnionFind uf = new UnionFind(n);
        Arrays.stream(allowedSwaps).forEach(swap -> uf.union(swap[0], swap[1]));
        Map<Integer, Map<Integer, Long>> componentMap = new HashMap<>();
        IntStream.range(0, n).forEach(i -> {
            int root = uf.find(i);
            componentMap.computeIfAbsent(root, k -> new HashMap<>()).merge(source[i], 1L, Long::sum);
        });
        return (int) IntStream.range(0, n).filter(i -> {
            int root = uf.find(i);
            Map<Integer, Long> component = componentMap.get(root);
            if (component.getOrDefault(target[i], 0L) > 0) {
                component.put(target[i], component.get(target[i]) - 1);
                return false;
            }
            return true;
        }).count();
    }

    class UnionFind {
        private int[] parent, rank;

        public UnionFind(int size) {
            parent = new int[size];
            rank = new int[size];
            IntStream.range(0, size).forEach(i -> {
                parent[i] = i;
                rank[i] = 1;
            });
        }

        public int find(int x) {
            if (parent[x] != x) {
                parent[x] = find(parent[x]);
            }
            return parent[x];
        }

        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if (rootX != rootY) {
                if (rank[rootX] > rank[rootY]) {
                    parent[rootY] = rootX;
                } else if (rank[rootX] < rank[rootY]) {
                    parent[rootX] = rootY;
                } else {
                    parent[rootY] = rootX;
                    rank[rootX]++;
                }
            }
        }
    }
}