leetcode 558. 四叉树交集

二进制矩阵中的所有元素不是 0 就是 1 。

给你两个四叉树，quadTree1 和 quadTree2。其中 quadTree1 表示一个 n * n 二进制矩阵，而 quadTree2 表示另一个 n * n 二进制矩阵。

请你返回一个表示 n * n 二进制矩阵的四叉树，它是 quadTree1 和 quadTree2 所表示的两个二进制矩阵进行 按位逻辑或运算 的结果。

注意，当 isLeaf 为 False 时，你可以把 True 或者 False 赋值给节点，两种值都会被判题机制 接受 。

四叉树数据结构中，每个内部节点只有四个子节点。此外，每个节点都有两个属性：

val：储存叶子结点所代表的区域的值。1 对应 True，0 对应 False；
isLeaf: 当这个节点是一个叶子结点时为 True，如果它有 4 个子节点则为 False 。
class Node {
public boolean val;
    public boolean isLeaf;
    public Node topLeft;
    public Node topRight;
    public Node bottomLeft;
    public Node bottomRight;
}
我们可以按以下步骤为二维区域构建四叉树：

如果当前网格的值相同（即，全为 0 或者全为 1），将 isLeaf 设为 True ，将 val 设为网格相应的值，并将四个子节点都设为 Null 然后停止。
如果当前网格的值不同，将 isLeaf 设为 False， 将 val 设为任意值，然后如下图所示，将当前网格划分为四个子网格。
使用适当的子网格递归每个子节点。

如果你想了解更多关于四叉树的内容，可以参考 wiki 。

四叉树格式：

输出为使用层序遍历后四叉树的序列化形式，其中 null 表示路径终止符，其下面不存在节点。

它与二叉树的序列化非常相似。唯一的区别是节点以列表形式表示 [isLeaf, val] 。

如果 isLeaf 或者 val 的值为 True ，则表示它在列表 [isLeaf, val] 中的值为 1 ；如果 isLeaf 或者 val 的值为 False ，则表示值为 0 。

 

示例 1：

 

输入：quadTree1 = [[0,1],[1,1],[1,1],[1,0],[1,0]]
, quadTree2 = [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
输出：[[0,0],[1,1],[1,1],[1,1],[1,0]]
解释：quadTree1 和 quadTree2 如上所示。由四叉树所表示的二进制矩阵也已经给出。
如果我们对这两个矩阵进行按位逻辑或运算，则可以得到下面的二进制矩阵，由一个作为结果的四叉树表示。
注意，我们展示的二进制矩阵仅仅是为了更好地说明题意，你无需构造二进制矩阵来获得结果四叉树。

示例 2：

输入：quadTree1 = [[1,0]]
, quadTree2 = [[1,0]]
输出：[[1,0]]
解释：两个数所表示的矩阵大小都为 1*1，值全为 0
结果矩阵大小为 1*1，值全为 0 。
示例 3：

输入：quadTree1 = [[0,0],[1,0],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,0],[1,1],[1,1],[1,0],[1,1]]
输出：[[1,1]]
示例 4：

输入：quadTree1 = [[0,0],[1,1],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]
输出：[[0,0],[1,1],[0,1],[1,1],[1,1],null,null,null,null,[1,1],[1,0],[1,0],[1,1]]
示例 5：

输入：quadTree1 = [[0,1],[1,0],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
, quadTree2 = [[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1]]
输出：[[0,0],[0,1],[0,1],[1,1],[1,0],[1,0],[1,0],[1,1],[1,1],[1,0],[1,0],[1,1],[1,1]]
 

提示：

quadTree1 和 quadTree2 都是符合题目要求的四叉树，每个都代表一个 n * n 的矩阵。
n == 2^x ，其中 0 <= x <= 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/logical-or-of-two-binary-grids-represented-as-quad-trees
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1：采用前序遍历二叉树的思想。

2：每遍历一次，就创建一个节点。

3：需要注意的地方就是有些节点的合并。

若a节点是叶子节点，并且值为1,不管b中是否还有子节点，都不用再遍历了，其值都肯定为1,新创建的节点的值和a节点的值相同即可。

若a节点是叶子节点，并且值为0,则新创建的节点和b节点相同。

若都不为子节点，则继续递归，再判断4个字节的返回值，若是返回值相同，则可以直接合并为[1,1]

代码有点乱。。。

/*
// 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) {
        return find(quadTree1, quadTree2, false);
    }

    private Node find(Node a, Node b, boolean value) {

        if (a == null && b == null) {
            return null;
        }

        Node no = new Node();
        if (a == null) {

            if (b.isLeaf && b.val) {
                no.isLeaf = true;
                no.val = true;
                return no;
            }
            if (b.isLeaf) {
                no.isLeaf = true;
                no.val = b.val || value;
            } else {
                no.isLeaf = false;
                no.topLeft = find(a, b.topLeft, value);
                no.topRight = find(a, b.topRight, value);
                no.bottomLeft = find(a, b.bottomLeft, value);
                no.bottomRight = find(a, b.bottomRight, value);
            }
            return no;
        }

        if (b == null) {
            if (a.isLeaf) {
                no.isLeaf = true;
                no.val = a.val || value;
            } else {
                no.isLeaf = false;
                no.topLeft = find(a.topLeft, b, value);
                no.topRight = find(a.topRight, b, value);
                no.bottomLeft = find(a.bottomLeft, b, value);
                no.bottomRight = find(a.bottomRight, b, value);
            }
            return no;
        }


        if ((a.isLeaf && a.val) || (b.isLeaf && b.val)) {
            no.isLeaf = true;
            no.val = true;
            return no;
        }
        value = a.isLeaf ? a.val : b.val;
        no.isLeaf = a.isLeaf && b.isLeaf;
        Node n1  = find(a.topLeft, b.topLeft, value);
        Node n2 = find(a.topRight, b.topRight, value);
        Node n3  = find(a.bottomLeft, b.bottomLeft, value);
        Node n4  = find(a.bottomRight, b.bottomRight, value);


        if (n1 != null && n2 != null && n3 != null && n4 != null) {
            if (n1.isLeaf && n2.isLeaf && n3.isLeaf && n4.isLeaf) {

                if (n1.val == n2.val && n2.val == n3.val && n3.val == n4.val) {
                    no.val = true;
                    no.isLeaf = true;
                    return no;
                }
            }
        }

        no.topLeft = n1;
        no.topRight = n2;
        no.bottomLeft = n3;
        no.bottomRight = n4;

        return no;
    }
}