LintCode刷题——集合合并（并查集）

题目描述

有一个集合组成的list，如果有两个集合有相同的元素，将他们合并。返回最后还剩下几个集合。

• 集合数 n <= 1000。
• 每个集合的元素个数 m <= 100。
• 元素一定是非负整数，且不大于 100000。

样例

样例1:

输入：list = [[1,2,3],[3,9,7],[4,5,10]]
输出：2 .
样例：剩下[1,2,3,9,7]和[4,5,10]这2个集合。

样例 2:

输入：list = [[1],[1,2,3],[4],[8,7,4,5]]
输出 ：2
解释：剩下[1,2,3]和[4,5,7,8] 2个集合。

分析

一开始想直接暴力，后面发现会超时，就往并查集方向想，想将所有的数都设置一个所属的数组下标（相当于祖先节点），然后搜索一遍，如果相同的数的对应的数组下标不同，那么就合并这两个数所在的两个数组，当时没有想到给这个二维数组构造一个一维数组list然后对它按数进行从小到大排序，所以才导致了后面的结果出错。那么为啥要排序呢？因为经过排序之后，相同的数会靠在一起，这样就利于合并两个数组了，用一个while循环，只要遇到两个相同的数，而且这两个数对应的数组下标inde不相等，那么就将后面数所在数组的所有数合并，直到没有相同的数不在同一个数组之后就跳出while循环。最后统计一下list数组中有多少个不同的数下标（这里可以将list中的所有数依次遍历并添加到set集合中，因为set集合可以去重）即可。

 

暴力代码

import java.util.*;

public class Solution {

    public int setUnion(int[][] sets) {
        if (sets == null || sets.length == 0) {
            return 0;
        }

        int n = sets.length;

        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (sets[i] == null || sets[j] == null) {
                    continue;
                }
                if (find(sets[i], sets[j])) {
                    sets[i] = union(sets[i], sets[j]);
                    sets[j] = null;
                    // 回溯
                    i = -1;
                    break;
                }
            }
        }
        
        int count = 0;
        for (int i = 0; i < sets.length; i++) {
            if (sets[i] != null) {
            count++;
            }
        }
        
        return count;
    }

    // 合并
    public int[] union(int[] a, int[] b) {
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < a.length; i++) {
            set.add(a[i]);
        }
        for (int i = 0; i < b.length; i++) {
            set.add(b[i]);
        }

        int[] union = new int[set.size()];
        Iterator<Integer> iterator = set.iterator();
        int index = 0;
        while (iterator.hasNext()) {
            union[index++] = iterator.next();
        }

        return union;
    }

    // 查询
    public boolean find(int[] a, int[] b) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < b.length; j++) {
                if (a[i] == b[j]) {
                    return true;
                }
            }
        }

        return false;
    }
}

运行结果

AC代码

import java.util.*;

public class Solution {
   
   /**
    * 键值对类
    */ 
    class MyMap {
        int val;
        int index;

        public MyMap(int val, int index) {
            this.val = val;
            this.index = index;
        }
    }

    /**
     * @param sets:
     *            Initial set list
     * @return: The final number of sets
     */
    public int setUnion(int[][] sets) {
        // Write your code here
        if (sets == null || sets.length == 0) {
            return 0;
        }

        int n = sets.length;

        // 注意：一定要排序，才能用这种方法
        // 定义一个MyMap类，val表示当前数，index表示当前数所在的数组的下标
        List<MyMap> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < sets[i].length; j++) {
            list.add(new MyMap(sets[i][j], i));
            }
        }
        
        // 排序
        Collections.sort(list, new Comparator<MyMap>() {

            @Override
            public int compare(MyMap o1, MyMap o2) {
                if (o1.val > o2.val) {
                    return 1;
                } else if (o1.val < o2.val){
                    return -1;
                } else {            
                    return 0;
                }
            }
            
        });
        
        // 保存两个相同数的后一个数在list集合中的下标
        int endIndex;
        // 一直循环判断，直到没有相同的数为止，跳出循环
        while ((endIndex = check(list)) != -1) {
            int src = list.get(endIndex).index;
            int target = list.get(endIndex - 1).index;
            union(list, src, target);
        }

        Set<Integer> set = new HashSet<>();
        for (int i = 0; i < list.size(); i++) {
            set.add(list.get(i).index);
        }

        return set.size();
    }

    // 返回要修改的那个数在list集合中的下标
    public int check(List<MyMap> list) {
        for (int i = 1; i < list.size(); i++) {
            // 跟前面一个数比
            // 如果当前数跟前面一个数相等，但是所在集合不是同一个，那么就要合并，并返回当前数所在的数组下标
            if (list.get(i).val == list.get(i - 1).val && list.get(i).index != list.get(i - 1).index) {
            return i;
            }
        }

        // 如果没有相等的数不在同一个数组中的话，那么就返回-1，即表示不需要合并
        return -1;
    }

    public void union(List<MyMap> list, int src, int target) {
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).index == src) {
            list.get(i).index = target;
            }
        }
    }
}

LintCode链接：https://www.lintcode.com/problem/1396/