题目:
A quadtree is a tree data in which each internal node has exactly four children:
topLeft
,topRight
,bottomLeft
andbottomRight
. 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 aN * 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
andval
.isLeaf
is true if and only if the node is a leaf node. Theval
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:
BothA
andB
represent grids of sizeN * N
.
N
is guaranteed to be a power of2
.
If you want to know more about the quad tree, you can refer to its wiki.
The logic OR operation is defined as this: “A or B” is true ifA is true
, or ifB is true
, or ifboth A and B are true
.
解释:
python代码:
"""
# Definition for a QuadTree node.
class Node(object):
def __init__(self, val, isLeaf, topLeft, topRight, bottomLeft, bottomRight):
self.val = val
self.isLeaf = isLeaf
self.topLeft = topLeft
self.topRight = topRight
self.bottomLeft = bottomLeft
self.bottomRight = bottomRight
"""
class Solution(object):
#这个函数用于合并之后的结点是不是叶子结点
def isLeaf(self,node):
topLeft=node.topLeft
topRight=node.topRight
bottomLeft=node.bottomLeft
bottomRight=node.bottomRight
if topLeft==None and topRight==None and bottomLeft==None and bottomRight==None:
return True
if topLeft.isLeaf and topRight.isLeaf and bottomLeft.isLeaf and bottomRight.isLeaf and (topLeft.val==topRight.val==bottomLeft.val==bottomRight.val):
return True
return False
def intersect(self, quadTree1, quadTree2):
"""
:type quadTree1: Node
:type quadTree2: Node
:rtype: Node
"""
if quadTree1==None and quadTree2==None:
return None
if quadTree1==None or quadTree2==None:
return quadTree1 if quadTree2==None else quadTree2
if quadTree1.isLeaf:
return quadTree1 if quadTree1.val else quadTree2
if quadTree2.isLeaf:
return quadTree2 if quadTree2.val else quadTree1
#如果都不是叶子结点
quadTree1.topLeft=self.intersect(quadTree1.topLeft,quadTree2.topLeft)
quadTree1.topRight=self.intersect(quadTree1.topRight,quadTree2.topRight)
quadTree1.bottomLeft=self.intersect(quadTree1.bottomLeft,quadTree2.bottomLeft)
quadTree1.bottomRight=self.intersect(quadTree1.bottomRight,quadTree2.bottomRight)
if self.isLeaf(quadTree1):
quadTree1.isLeaf=True
quadTree1.val=quadTree1.topLeft.val
return quadTree1
c++代码:
/*
// Definition for a QuadTree node.
class Node {
public:
bool val;
bool isLeaf;
Node* topLeft;
Node* topRight;
Node* bottomLeft;
Node* bottomRight;
Node() {}
Node(bool _val, bool _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) {
if(!quadTree1 &&!quadTree2)
return NULL;
else if(!quadTree1 or !quadTree2)
return quadTree1?quadTree1:quadTree2;
if(quadTree1->isLeaf)
return quadTree1->val?quadTree1:quadTree2;
if(quadTree2->isLeaf)
return quadTree2->val?quadTree2:quadTree1;
//两个结点都不是叶子结点
else
{
quadTree1->topLeft=intersect(quadTree1->topLeft,quadTree2->topLeft);
quadTree1->topRight=intersect(quadTree1->topRight,quadTree2->topRight);
quadTree1->bottomLeft=intersect(quadTree1->bottomLeft,quadTree2->bottomLeft);
quadTree1->bottomRight=intersect(quadTree1->bottomRight,quadTree2->bottomRight);
}
//如果quadTree1合并以后变成了叶子结点。
if (isLeaf(quadTree1))
{
quadTree1->isLeaf=true;
quadTree1->val=quadTree1->topLeft->val;
}
return quadTree1;
}
bool isLeaf(Node* node)
{
Node* topLeft=node->topLeft;
Node* topRight=node->topRight;
Node* bottomLeft=node->bottomLeft;
Node* bottomRight=node->bottomRight;
if(!topLeft && !topRight && !bottomLeft && !bottomRight)
return true;
if(topLeft->isLeaf && topRight->isLeaf && bottomLeft->isLeaf && bottomRight->isLeaf &&(topLeft->val==topRight->val)&&(topRight->val==bottomRight->val)&&(bottomRight->val==bottomLeft->val))
return true;
return false;
}
};
总结:
就是递归问题,但是合并的时候需要考虑的特殊情况比较多,这一点需要注意一下。