2017年蓝桥杯国赛Java组——合根植物 只得了一半分 99%是时间超时 后面会优化（并查集）

题目：

问题描述
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
样例说明
　　其合根情况参考下图

 

 

分析：

一开始我看到这是考察并查集的题目，就直接往这方面想，因为这题也是解决合并与查询的问题，所以用并查集是肯定的，但是要用哪种数据结构来表示所有集合呢，这里我构造了二叉排序树用来存储每个集合的所有元素，然后针对每次输入的两个数之间的关系，将这两个数所在的集合合并，不过要先判断这两个数是否在一个集合中，如果在就不用操作，反之则进行上面所说的操作，每次合并完之后，就要将另一个树中的所有元素对应在dp数组中的值修改为合并的那棵树对应在dp数组中的值。即dp[b] = dp[a]，等接收完所有可能合根的情况之后，就计算一下arr数组中还剩下哪些不为null的集合，将统计之后的结果输出即可。这个算法经蓝桥官网的OJ测试之后，最后得了60来分，我分析原因，应该是我的二叉树在查询与合并的操作上效率会有点低。

 

上代码：

package com.lzp.lanqiaocontests;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Author LZP
 * @Date 2021/3/19 11:59
 * @Version 1.0
 * 题目描述
 *
 * w 星球的一个种植园，被分成 m×n 个小格子（东西方向 m 行，南北方向 n 列）。每个格子里种了一株合根植物。
 *
 * 这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
 *
 * 如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？
 * 输入描述
 *
 * 第一行，两个整数 m,n，用空格分开，表示格子的行数、列数（1≤m,n≤10000）。
 *
 * 接下来一行，一个整数 k (0≤k≤10^5 )，表示下面还有 k 行数据。
 *
 * 接下来 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
 *
 * 样例说明
 *
 * 其合根情况参考下图：
 *
 * 运行限制
 *
 *     最大运行时间：2s
 *     最大运行内存: 256M
 *
 *  该题使用并查集解，每当输入一对可以合根的植物，就将这两个植物所在的集合合并，直到
 *  所有合根的情况都已经输入完成，就确定了这片田地中最终剩下多少根植物，也就是求最
 *  终剩下的有几个集合，这里的集合我们用树来表示
 */
public class MergePlant {
    /**
     * dp[i] = val 表示数i此时处在索引为val的位置
     */
    private static int[] dp = new int[1000000 + 10];
    private static Node[] arr = new Node[1000000 + 10];
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int m = input.nextInt();
        int n = input.nextInt();
        for (int i = 1; i <= m * n; i++) {
            // 一开始，将每个植物都作为一个集合，把自己装入
            Node root = new Node(i, null, null);
            arr[i] = root;
            dp[i] = i;
        }

        int k = input.nextInt();
        // 接收所有合根的情况
        for (int i = 0; i < k; i++) {
            int a = input.nextInt();
            int b = input.nextInt();
            // 将b中的所有数用List集合存储起来，后面会用的到
            List<Integer> list = new ArrayList<>();
            if (!find(a, b)) {

                // 判断两者能否合根，因为题目说了：这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
                // 言外之意就是，斜的对角线是不可以的

                // a、b不在同一棵树中
                Node rootA = arr[dp[a]];
                Node rootB = arr[dp[b]];
                if (rootA != null && rootB != null) {
                    union(rootA, rootB, list);
                    // 修改dp[b]中的所有值为dp[a]
                    for (int j = 0; j < list.size(); j++) {
                        dp[list.get(j)] = dp[a];
                        // 置为null
                        arr[list.get(j)] = null;
                    }
                }
            }
        }

        int count = 0;
        for (int i = 1; i <= m * n; i++) {
            // 如果不为arr[i] != null ，则表示i这棵植物还在，没有被其他植物合根，
            if (arr[i] != null) {
                count++;
            }
        }
        System.out.println(count);
    }

    /**
     * 查询两个数是否在同一棵树中
     * @param a
     * @param b
     * @return
     */
    public static boolean find(int a, int b) {
        return dp[a] == dp[b];
    }

    /**
     * 将b树中的所有元素都添加到a树中
     * @param a
     * @param b
     * @return
     */
    public static Node union(Node a, Node b, List<Integer> list) {
        BinarySortTreeUtil.getValues(b, list);
        for (int i = 0; i < list.size(); i++) {
            BinarySortTreeUtil.add(a, list.get(i));
        }
        return a;
    }
}


/**
 * 二叉排序树
 */
class BinarySortTreeUtil {

    public static void add(Node root, int data) {
        if (!find(root, data)) {
            addNode(root, data);
        }
    }

    /**
     * 中序遍历
     * @param root
     * @param list
     */
    public static void getValues(Node root, List<Integer> list) {
        if (root == null) {
            return;
        }
        if (root.left != null) {
            getValues(root.left, list);
        }
        list.add(root.data);
        if (root.right != null) {
            getValues(root.right, list);
        }
    }

    /**
     * 添加元素
     * 如果要添加的元素跟二叉树中的某一个元素相等则不添加
     * @param root
     * @param data
     */
    private static void addNode(Node root, int data) {
        if (data < root.data) {
            if (root.left == null) {
                // 如果左孩子为空，则直接赋值给左孩子
                root.left = new Node(data, null, null);
            } else {
                // 左孩子
                addNode(root.left, data);
            }
        } else if (data > root.data){
            if (root.right == null) {
                // 如果右孩子为空，则直接赋值给右孩子
                root.right = new Node(data, null, null);
            } else {
                // 右孩子
                addNode(root.right, data);
            }
        }
    }

    /**
     * 二分查找
     * @param data
     * @return
     */
    public static boolean find(Node root, int data) {
        if (root == null) {
            return false;
        }
        if (data == root.data) {
            return true;
        } else if (data < root.data) {
            return find(root.left, data);
        } else {
            return find(root.right, data);
        }
    }
}


/**
 * 二叉树节点
 */
class Node {
    public int data;
    public Node left;
    public Node right;

    public Node(int data, Node left, Node right) {
        this.data = data;
        this.left = left;
        this.right = right;
    }
}