找亲戚——并查集

再次谈起什么是并查集？

在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（Union-find Algorithm）定义了两个用于此数据结构的操作：

Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。
由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（Union-find Data Structure）或合并-查找集合（Merge-find Set）。
为了更加精确的定义这些方法，需要定义如何表示集合。一种常用的策略是为每个集合选定一个固定的元素，称为代表，以表示整个集合。接着，Find(x)Find(x) 返回 xx 所属集合的代表，而 Union 使用两个集合的代表作为参数。

并查集概念

在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。

 

并查集经典案例——找亲戚

问题描述：                                              
    给出总人数n和k对关系，然后给出p次关系询问                           
                                                      
输入说明：                                                 
    第一行输入两个正整数，分别代表总人数和关系数                           
    下面k行代表k对关系                                       
    再下面一行输入一个正整数p，                                   
    下面p行代表p次关系询问                                     
                                                      
输出说明：                                                 
    输出p行，每一行代表1次询问的回答，若有亲戚关系，则输出yes，反之输出no           
                                                      
输入示例1：                                                
9 7                                              
     2 4                                              
     5 7                                              
     1 3                                              
     8 9                                              
     1 2                                              
     5 6                                              
     2 3                                              
     3                                                
     1 9                                              
     5 6                                              
     4 8                                              
                                                      
输出示例1：                                                
    no                                               
    yes                                              
    no      

       

案例代码

public class Main {
    
    /**
     * 查询
     */
    public static int find(int x, int[] parent) {
    if (parent[x] == x) {
        // 直接返回
        return parent[x];
    }
    // 递归找祖先
    // 将当前节点的父亲设置为祖先，可以为之后的查询减少递归层数，提高算法的执行效率
    // 关键代码
    parent[x] = find(parent[x], parent);
    return parent[x];
    }
    
    /**
     * 合并
     */
    public static void union(int a, int b, int[] parent) {
    // 各自找祖先
    int parent_a = find(a, parent);
    int parent_b = find(b, parent);
    // 将a祖先的祖先设置为b的祖先
    parent[parent_a] = parent_b; 
    }
    
    /**
     * 初始化
     */
    public static void init(int[] parent) {
    for (int i = 0; i < parent.length; i++) {
        parent[i] = i;
    }
    }
    
    public static void main(String[] args) {    
    // 设定人数，设定亲戚关系数
    Scanner input = new Scanner(System.in);
    int n = input.nextInt();
    // 一开始，初始化自己就为自己的祖先，因为这里我设置人的编号从1~n，所以数组长度要开n+1
    int[] parent = new int[n + 1];
    init(parent);
    int k = input.nextInt();
    for (int i = 0; i < k; i++) {
        // 合并
        int a = input.nextInt();
        int b = input.nextInt();
        union(a, b, parent);
    }
    
    // 接收询问次数
    int p = input.nextInt();
    List<String> list = new ArrayList<>();
    for (int i = 0; i < p; i++) {
        int a = input.nextInt();
        int b = input.nextInt();
        // 分别找各自祖先
        int parent_a = find(a, parent);
        int parent_b = find(b, parent);
        if (parent_a == parent_b) {
        list.add("yes");
        } else {
        list.add("no");
        }
    }
    
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i));
    }
    }
}

运行结果