历届试题 合根植物——并查集思想

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

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
输入格式
　　第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
　　接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
　　接下来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

这题一开始我以为是跟岛屿问题差不多,就是查看连通的有多少个,而且对于格子中的每一个编号,他们最多就只有4个与之连通(上下左右),最少就是单独一个,那么我就可以设置一个二维数组link[count][4],其中count是编号总数,例题中就有20个编号，4代表上下左右与之相连的编号(如果没有与之相连的话就是初始值为0)
就如例题中编号为10的格子,通过图可以看出10与之相连的有9,14,11.那么对应的二维数组就是link[10][0]=9,link[10][1]=14,link[10][2]=11,link[10][3]=0

在这里我是使用了广度优先搜索,每次取出)需要一个编号来加入到队列中,并以该编号作为根节点进行bfs，就比如将编号1加入到队列中,编号1下面的字结点可以通过二维数组link获取,每次将获取的子节点再加入到队列中,直到队列为空,说明该部分的所有连通的植物都搜索了一遍了,此时合根植物数加一表示找到一条可连通的。(ps:bfs求出来的数量是至少有2个以上连根的数量,单独一个植物的我单独处理了)

具体见代码

import java.util.*;
public class Main {
    static int row;//行
    static int column;//列
    static boolean[] isVisited ;
    static int[][] link;
    static TreeSet<Integer> set;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        row = scan.nextInt();//行
        column = scan.nextInt();//列
        int k = scan.nextInt();
        //表示第i个小格子有几个连根(最多4个即上下左右)
        link = new int[row*column+1][4];
        //当前位置是否已访问
        isVisited = new boolean[row*column+1];
        //存放具有两个以上的两个的坐标
        set = new TreeSet<Integer>();
        int a,b;
        for (int i=0;i<k;i++){
            a = scan.nextInt();
            b = scan.nextInt();
            //每次将两连通的a,b加入到set中
            //不包含在set中的编号就代表植物没有跟其他植物有连根
            set.add(a);
            set.add(b);
            init_link(b,a);
            init_link(a,b);
        }
        //先求出单独的植物的数量
        int only_one = column*row-set.size();
        LinkedList<Integer> list = new LinkedList<Integer>();
        int count =0;
        while (set.size()>0){
            //已该点作为根节点弹出并加入到队列中
            list.add(set.pollFirst());
            //进行广度优先遍历
            while (list.size()>0){
                int index = list.poll();
                //并将该点设置为已访问
                isVisited[index]=true;
                set.remove(index);
                add_list(list,index);
            }
            list.clear();
            count++;
        }
        System.out.println(count + only_one);

    }

    /**
     * 获取编号为start的格子与之相连的格子编号,加入到队列中
     * @param list
     * @param start
     */
    private static void add_list(LinkedList<Integer> list, int start) {
        for (int i=0;i<4;i++){
            if (link[start][i]!=0&&!isVisited[link[start][i]]){
                //该编号的格子有与编号start相连并且该编号的位置未访问
                list.add(link[start][i]);
            }
        }
    }

    /**
     * 设置对应格子上下左右的编号(如果有相连的话)
     * @param a 当前格子编号
     * @param b 与之相连的子格子编号
     */
    private static void init_link(int a, int b) {
        for (int i=0;i<4;i++){
            if (link[a][i]==0){
                link[a][i]=b;
                break;
            }
        }
    }
}

测试结果却只通过了最后两个(⊙o⊙)…

对于用dfs来进行求解,我感觉是思路应该也是对的啊,但测试数据就是不能全通过ε=(´ο｀*)))，如果哪位大佬指定我代码哪里有问题,希望可以指出来

那么言归正传,其实这题用并查集是最好解决的,对应并查集,其实思路都是差不多的,换汤不换药。

如果是第一次接触并查集,建议先看一下相关的解释,这是我认为对于并查集讲得最通俗易懂的解释:并查集通俗讲解

直接上代码

import java.util.*;
public class PREV54_01 {
    static int[] pre;
    static int[] root;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();//m行
        int n = scan.nextInt();//n列
        int k = scan.nextInt();
        pre = new int[m*n+1];
        root = new int[m*n+1];
        //初始化,即最开始根节点都是自己本身
        init_pre();
        for (int i=0;i<k;i++){
            int a = scan.nextInt();
            int b = scan.nextInt();
            //将编号a和编号b所在的连通分支连接起来
            join(a,b);
        }
        //set集合存储各连通分支的根节点
        TreeSet<Integer> set = new TreeSet<Integer>();
        for (int i=1;i<=m*n;i++){
            //一一遍历每个格子,将每个格子的根节点加入到set集合中
            set.add(find(i));
        }
        System.out.println(set.size());

    }

    private static void join(int a, int b) {
        int a_root = find(a);//找到编号为a的根节点
        int b_root = find(b);//找到编号为b的根节点
        if (a_root!=b_root){
            pre[a_root]=b_root;
        }
    }

    //查找编号为a的根节点
    private static int find(int x) {
        int p = x;
        while (x!=pre[x]){
            //寻找根节点
            x = pre[x];
        }
        int temp;
        //路径压缩即把原来的x（现在的p，因为x被修改了）节点到根节
        //点的间的所有点的前节点改为现在的根节点，从而降低树的高度。
        while (p!=x){
            temp = pre[p];
            pre[p] = x;
            p = temp;
        }
        return x;
    }


    private static void init_pre() {
        for (int i=1;i<pre.length;i++){
            pre[i]=i;
        }
    }
}