558. Quad Tree Intersection

A quadtree is a tree data in which each internal node has exactly four children: topLeft, topRight, bottomLeft and bottomRight. Quad trees are often used to partition a two-dimensional space by recursively subdividing it into four quadrants or regions.

We want to store True/False information in our quad tree. The quad tree is used to represent a N * N boolean grid. For each node, it will be subdivided into four children nodes until the values in the region it represents are all the same. Each node has another two boolean attributes : isLeaf and val. isLeaf is true if and only if the node is a leaf node. The val attribute for a leaf node contains the value of the region it represents.

For example, below are two quad trees A and B:

A:
+-------+-------+   T: true
|       |       |   F: false
|   T   |   T   |
|       |       |
+-------+-------+
|       |       |
|   F   |   F   |
|       |       |
+-------+-------+
topLeft: T
topRight: T
bottomLeft: F
bottomRight: F

B:               
+-------+---+---+
|       | F | F |
|   T   +---+---+
|       | T | T |
+-------+---+---+
|       |       |
|   T   |   F   |
|       |       |
+-------+-------+
topLeft: T
topRight:
     topLeft: F
     topRight: F
     bottomLeft: T
     bottomRight: T
bottomLeft: T
bottomRight: F

 

Your task is to implement a function that will take two quadtrees and return a quadtree that represents the logical OR (or union) of the two trees.

A:                 B:                 C (A or B):
+-------+-------+  +-------+---+---+  +-------+-------+
|       |       |  |       | F | F |  |       |       |
|   T   |   T   |  |   T   +---+---+  |   T   |   T   |
|       |       |  |       | T | T |  |       |       |
+-------+-------+  +-------+---+---+  +-------+-------+
|       |       |  |       |       |  |       |       |
|   F   |   F   |  |   T   |   F   |  |   T   |   F   |
|       |       |  |       |       |  |       |       |
+-------+-------+  +-------+-------+  +-------+-------+

Note:

1. Both A and B represent grids of size N * N.
2. N is guaranteed to be a power of 2.
3. If you want to know more about the quad tree, you can refer to its wiki.
4. The logic OR operation is defined as this: "A or B" is true if A is true, or if B is true, or if both A and B are true.

https://leetcode-cn.com/problems/quad-tree-intersection/description/

 

这个是英文的，网站没翻译，大概意思是对应的方位求或。

 

下面这个方法虽然写得不简洁。。但是还好，通过了测试。

 

/*
// Definition for a QuadTree node.
class Node {
    public boolean val;
    public boolean isLeaf;
    public Node topLeft;
    public Node topRight;
    public Node bottomLeft;
    public Node bottomRight;

    public Node() {}

    public Node(boolean _val,boolean _isLeaf,Node _topLeft,Node _topRight,Node _bottomLeft,Node _bottomRight) {
        val = _val;
        isLeaf = _isLeaf;
        topLeft = _topLeft;
        topRight = _topRight;
        bottomLeft = _bottomLeft;
        bottomRight = _bottomRight;
    }
};
*/
class Solution {
    public Node intersect(Node quadTree1, Node quadTree2) {
        change(quadTree1, quadTree2);
        return quadTree1;
    }

    public Node change(Node quadTree1, Node quadTree2) {
        boolean tree1 = quadTree1.isLeaf;
        boolean tree2 = quadTree2.isLeaf;
        if (tree1 && tree2) {
            //如果两个都是叶子,取或
            quadTree1.val = quadTree1.val || quadTree2.val;
        } else if (tree2 && quadTree2.val) {
            //1不是叶子，2是叶子时。如果2是true，则结果应该是true，如果2是false，则结果依据1，不处理
            quadTree1.isLeaf = true;
            quadTree1.val = true;
            quadTree1.bottomLeft = null;
            quadTree1.bottomRight = null;
            quadTree1.topLeft = null;
            quadTree1.topRight = null;
        } else if (tree1 && !quadTree1.val) {
            //1是叶子，2不是叶子时。如果1是true，不处理，如果1是false，则结果依据2,
            quadTree1.isLeaf = false;
            quadTree1.bottomLeft = quadTree2.bottomLeft;
            quadTree1.bottomRight = quadTree2.bottomRight;
            quadTree1.topLeft = quadTree2.topLeft;
            quadTree1.topRight = quadTree2.topRight;
        } else if (!tree1 && !tree2) {
            //都不是叶子，分别取对应的子节点处理
            Node bottomLeft = change(quadTree1.bottomLeft, quadTree2.bottomLeft);
            Node bottomRight = change(quadTree1.bottomRight, quadTree2.bottomRight);
            Node topLeft = change(quadTree1.topLeft, quadTree2.topLeft);
            Node topRight = change(quadTree1.topRight, quadTree2.topRight);
            //如果处理后的子节点都是叶子则考虑合并
            if (bottomLeft.isLeaf && bottomRight.isLeaf && topLeft.isLeaf && topRight.isLeaf) {
                boolean temp = bottomLeft.val;
                //数值相等，合并
                if (bottomRight.val == temp && topLeft.val == temp && topRight.val == temp) {
                    quadTree1.val = temp;
                    quadTree1.isLeaf = true;
                    quadTree1.bottomLeft = null;
                    quadTree1.bottomRight = null;
                    quadTree1.topLeft = null;
                    quadTree1.topRight = null;
                }
            }
        }
        return quadTree1;
    }
}