蓝桥杯合根植物并查集 java实现

问题描述

w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
　　这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式
　　第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1 　　接下来一行，一个整数k，表示下面还有k行数据(0 　　接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。
　　比如：5 * 4 的小格子，编号：
　　1 2 3 4
　　5 6 7 8
　　9 10 11 12
　　13 14 15 16
　　17 18 19 20

样例输入
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

样例输出
5

代码实现

import java.util.Scanner;
public class Main {
     
    public static void main(String[] args) {
     
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int column = sc.nextInt();
        sc.nextLine();
        int len = sc.nextInt();
        int[][] matrix = new int[len][2];
        sc.nextLine();
        for(int i=0;i<len;i++){
     
            matrix[i][0] = sc.nextInt();
            matrix[i][1] = sc.nextInt();
        }
        Solution sl = new Solution();
        System.out.println(sl.f(row,column,matrix));
    }
}

class Solution{
     

    public int f(int row,int column,int[][] matrix){
     
        UnionUF uf = new UnionUF(row*column);
        for(int i=0;i<matrix.length;i++){
     
            int m = matrix[i][0] - 1;
            int n = matrix[i][1] - 1;
            //如果m n不在一个集合中 则连接m n
            if(!uf.isConnected(m,n)){
     
                uf.union(m,n);
            }
        }
        return uf.getCount();
    }

}


class UnionUF{
     
    /**
     * 对象索引数组 0~N-1表示N个对象
     * id[i]表示第i个节点的父节点索引为id[i]
     * id[i] == i 表示第i个节点的父节点为子集
     */
    private int[] id;
    private int[] size;
    private int count;

    public UnionUF(int N){
     
        id = new int[N];
        size = new int[N];
        for(int i=0;i<N;i++){
     
            id[i] = i;
            size[i] = 1;
            count++;
        }
    }

    public int getCount(){
     
        return count;
    }

    public void union(int x,int y){
     
        int RootX = find(x);
        int RootY = find(y);
        //小树指向大树
        if(size[RootX] >= size[RootY]){
     
            id[RootY] = RootX;
            size[RootX] += size[RootY];
        }else{
     
            id[RootX] = RootY;
            size[RootY] += size[RootX];
        }
        //两个合根植物变为一根
        count--;
    }

    //将树的高度压缩为2
    public int find(int node){
     
        while(node != id[node]){
     
            //让父节点永远指向父节点的父节点
            id[node] = id[id[node]];
            node = id[node];
        }
        return node;
    }

    public boolean isConnected(int p,int q){
     
        return find(p) == find(q);
    }

}