558. Quad Tree Intersection(python+cpp)

本文探讨了如何通过递归算法实现两个四叉树的逻辑或运算,详细解析了四叉树的节点合并过程,包括特殊情况处理,适用于两维布尔网格的数据结构优化。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:

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 aN * Nboolean 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:
Both A and B represent grids of size N * N.
N is guaranteed to be a power of 2.
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 if A is true, or if B is true, or if both 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;
    }
};

总结:
就是递归问题,但是合并的时候需要考虑的特殊情况比较多,这一点需要注意一下。

资源下载链接为: https://pan.quark.cn/s/22ca96b7bd39 在 IT 领域,文档格式转换是常见需求,尤其在处理多种文件类型时。本文将聚焦于利用 Java 技术栈,尤其是 Apache POI 和 iTextPDF 库,实现 doc、xls(涵盖 Excel 2003 及 Excel 2007+)以及 txt、图片等格式文件向 PDF 的转换,并实现在线浏览功能。 先从 Apache POI 说起,它是一个强大的 Java 库,专注于处理 Microsoft Office 格式文件,比如 doc 和 xls。Apache POI 提供了 HSSF 和 XSSF 两个 API,其中 HSSF 用于读写老版本的 BIFF8 格式(Excel 97-2003),XSSF 则针对新的 XML 格式(Excel 2007+)。这两个 API 均具备读取和写入工作表、单元格、公式、样式等功能。读取 Excel 文件时,可通过创建 HSSFWorkbook 或 XSSFWorkbook 对象来打开相应格式的文件,进而遍历工作簿中的每个 Sheet,获取行和列数据。写入 Excel 文件时,创建新的 Workbook 对象,添加 Sheet、Row 和 Cell,即可构建新 Excel 文件。 再看 iTextPDF,它是一个用于生成和修改 PDF 文档的 Java 库,拥有丰富的 API。创建 PDF 文档时,借助 Document 对象,可定义页面尺寸、边距等属性来定制 PDF 外观。添加内容方面,可使用 Paragraph、List、Table 等元素将文本、列表和表格加入 PDF,图片可通过 Image 类加载插入。iTextPDF 支持多种字体和样式,可设置文本颜色、大小、样式等。此外,iTextPDF 的 TextRenderer 类能将 HTML、
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值