住一层窗外一棵大树小区里的孩子总上树又吵还总窥视屋里怎么办？

Posted 2023-03-18

家住一层，小孩爬树向屋里看，还吵闹：
可以针对这种情况想想办法，比如说大树，它的树枝低小孩才上仍，你跟物业说一下，让他们把树修理一下，高了小孩都爬不上去了，这是一点。
如果物业不管或没有物业，那你自己就可以。你自己也可以修理一下树。
还有就是把树根处码上砖头上创上坑浇上水，或者是打一个围栏，孩子就到不了树跟前去就无法上树了，所以这个问题是很容易解决，所以你就看根据情况去处理。
还有把树身涂上石灰水，有的给树防虫就刷石灰水，这样做对树没有伤害，还保互树呢。
在这棵大树周围的土，天天翻一遍洒上水，也可以种些小树。都是办法，只要你想做。
希望能帮到你。 参考技术A 孩子爱吵闹，对新鲜事物好奇是本性。你所做的只能是拉上窗帘儿。和社区反应反应。和孩子家长反映反映。毕竟上述是不对的。也容易受伤。在也就没有什么好办法的。 参考技术B 小区里也有大树的话，孩子们肯定喜欢去那里玩耍，因为有凉快又有趣，但是小区的树是不可能砍伐的，所以你要想他们不打扰到你，么你只有拉上窗帘关紧窗户，这样才能够不打扰到你的生活，不可能不让孩子们在那里玩吧？ 参考技术C 能做的就是拉上窗帘不让孩子们看而已，一层有好处也有缺点，总不至于再买房换房吧，这就看你经济条件了，小区里的大树轻易不会为了你而砍掉的吧，随遇而安吧，看到孩子们的天真烂漫你也会跟着开心的不是吗？ 参考技术D 你可以把玻璃做成厚一点的看不到屋里的玻璃。还可以拉上窗帘，我觉得还是在玻璃上做文章。我们家的玻璃就是内外都看不到，不过不影响透光效果也很不错。住在一层最大的不方便就是夏天有苍蝇蚊子比较厉害。不过没想到还有这种

获取每个节点的最大树深度

【中文标题】获取每个节点的最大树深度

【英文标题】：Get maximum tree depth for each node

【发布时间】：2022-01-13 13:57:34

【问题描述】：

假设我们有一棵树，每个节点可以有多个孩子，而孩子可以有更多的孩子等等。

以这棵树为例：

- Node 1
    - Node 1.1
    - Node 1.2
        - Node 1.2.1
            - Node 1.2.1.1
            - Node 1.2.1.2
        - Node 1.2.2
    - Node 1.3
        - Node 1.3.1

节点 1 的深度 = 0（根）

节点 1.1、1.2、1.3 的深度 = 1 等等

对于每个节点，我想计算它可以达到的最大深度。 例如，最大节点 1。深度为 3（树的深度与节点 1.2.1.1 一样深）。而节点 1.3 最大深度 = 1（子树达到节点 1.3.1 的深度）

现在我可以做的是创建一个函数，它接受一个子树并计算到最深的节点，然后返回深度值。但这需要为每个节点调用该函数，这对我来说似乎非常低效。

我想一次性创建树并计算最大深度。

我保持代码非常简单，因为我的函数包含许多其他操作（例如在我从头开始构建树时生成新的子节点，但为简单起见，我省略了这些部分）。 但基本上，我是这样遍历树的：

def create_behavior_tree(depth, max_depth, behavior_tree)
  for child in behavior_tree.children:
    if depth > max_depth:
      max_depth = depth
    if len(child) > 0: # Expanding node
      max_depth = create_behavior_tree(depth + 1, max_depth, child)
      child.max_depth = max_depth  # problem: stores the values in "reverse"
    else: # Single node without children
      child.max_depth = depth


create_behavior_tree(1, 0, Tree)

但是，当我这样做时，我无法达到外部节点的最新 max_depth 值，只能在最里面的节点内达到（因为这是递归）。 所以这将计算：节点 1 最大深度 = 0，节点 1.2 最大深度 = 1，节点 1.2.1 最大深度 = 2 等等。实际上是相反的。

那么，也许我需要在这里使用全局变量？

EDIT - 我的函数的更详细版本

def create_behavior_tree(depth, behavior_tree, children, max_tree_depth, node_count):
    if depth <= max_tree_depth:
        for child in children:
            # add behavior node
            if type(child) == Behaviour:
                behavior_tree.add_children([child])
                node_count += 1  # counting total nodes in tree
            # add composite node
            if type(child) == Composite:
                # replace by behavior node (reached max tree depth)
                if depth == max_tree_depth:
                    node = create_behaviour_node()
                    behavior_tree.add_children([node])
                    node_count += 1
                else:
                    behavior_tree.add_children([child])
                    node_count += 1
                    # further expand behavior tree 
                    children = create_random_children(size=3)
                    _, node_count = create_behavior_tree(depth + 1, node, children, max_tree_depth, node_count)
    return behavior_tree, node_count

random_children = create_random_children(size=3)  # Create 3 random children
root = py_trees.composites.Selector("Selector")

create_behavior_tree(1, root, random_children, 5, 0)

【问题讨论】：

没有全局变量！编写一个以节点为参数并返回最大值的递归函数。该节点下的深度。如果没有子节点，它应该返回 0，否则在子节点上递归调用函数的结果的 1 + max。

@MarkLavin 这是我最初的想法。但是，当我创建树（通过递归）时，它已经遍历了每个节点。难道不能在那个过程中一次获得这些最大值吗？

@ggorlen 我编辑了我的帖子。它基于 0（因此如果一个节点没有子节点，则最大深度应为 0）

【参考方案1】：

利用递归的自相似性，这与任何其他一次 O(n) 深度/树高算法相同，除了在备份调用堆栈时为每个节点设置最大深度属性：

def set_all_depths(tree):
    if not tree:
        return 0

    tree.max_depth = (
        max(map(set_all_depths, tree.children)) 
        if tree.children else 0
    )
    return tree.max_depth + 1

def print_tree(tree, depth=0):
    if tree:
        print("    " * depth + 
              f"tree.val [max_depth: tree.max_depth]")

        for child in tree.children:
            print_tree(child, depth + 1)


class TreeNode:
    def __init__(self, val, children=None, max_depth=None):
        self.val = val
        self.children = children or []
        self.max_depth = max_depth


if __name__ == "__main__":
    tree = TreeNode(
        "1",
        [
            TreeNode("1.1"),
            TreeNode(
                "1.2",
                [
                    TreeNode(
                        "1.2.1",
                        [
                            TreeNode("1.2.1.1"),
                            TreeNode("1.2.1.2"),
                        ],
                    ),
                    TreeNode("1.2.2"),
                ],
            ),
            TreeNode(
                "1.3",
                [
                    TreeNode("1.3.1"),
                ],
            ),
        ],
    )
    set_all_depths(tree)
    print_tree(tree)

输出：

1 [max_depth: 3]
    1.1 [max_depth: 0]
    1.2 [max_depth: 2]
        1.2.1 [max_depth: 1]
            1.2.1.1 [max_depth: 0]
            1.2.1.2 [max_depth: 0]
        1.2.2 [max_depth: 0]
    1.3 [max_depth: 1]
        1.3.1 [max_depth: 0]

---

基于后续的cmets，如果想一次性做树并分配最大深度，一种方法是从children中挑出最大深度，分配给备份途中的每个节点调用堆栈。

这是一个与库无关的概念证明，因为我没有新示例中的类：

import random
from random import randint


def make_random_tree(max_depth=4):
    if max_depth <= 0:
        return TreeNode(Id.make(), max_depth=0)

    node = TreeNode(Id.make())
    node.children = [
        make_random_tree(max_depth - 1) for _ in range(randint(0, 4))
    ]
    node.max_depth = 1 + (
        max([x.max_depth for x in node.children])
        if node.children else 0
    )
    return node

def print_tree(tree, depth=0):
    if tree:
        print("    " * depth + 
              f"tree.val [max_depth: tree.max_depth]")

        for child in tree.children:
            print_tree(child, depth + 1)


class TreeNode:
    def __init__(self, val, children=None, max_depth=None):
        self.val = val
        self.children = children or []
        self.max_depth = max_depth


class Id:
    identifier = 0

    def make():
        Id.identifier += 1
        return Id.identifier


if __name__ == "__main__":
    random.seed(1)
    tree = make_random_tree()
    print_tree(tree)

输出：

1 [max_depth: 4]
    2 [max_depth: 3]
        3 [max_depth: 1]
        4 [max_depth: 2]
            5 [max_depth: 1]
            6 [max_depth: 1]
                7 [max_depth: 0]
                8 [max_depth: 0]
                9 [max_depth: 0]
        10 [max_depth: 2]
            11 [max_depth: 1]
                12 [max_depth: 0]
                13 [max_depth: 0]
                14 [max_depth: 0]
            15 [max_depth: 1]
                16 [max_depth: 0]
                17 [max_depth: 0]
                18 [max_depth: 0]
            19 [max_depth: 1]
                20 [max_depth: 0]
        21 [max_depth: 1]

也就是说，在第二遍中分配深度仍然是 O(n)，因此除非您有真正的大型或性能关键代码，否则一次性完成所有操作可能是过早的优化。

【讨论】：

这实际上是我想要的。但是，我很难在我的函数中实现这一点（查看我的最新编辑）。我的树是随机生成的。所以我没有在函数中传递已经创建的树。它需要一个根节点，然后向其添加 3 个随机子节点。然后可以再次扩展其中一些孩子，直到达到最大树深度

无论你是否在现场创建节点都是一样的算法。 max_depth 不能自顶向下计算；您必须将该信息作为单独的返回值、某个子节点上的属性、按节点索引的查找表传递回调用堆栈……这可能是最简单的方法，只需检查一个子节点并查看什么max_depth 它具有并加 1 以计算当前节点的最大深度。如果在基本情况下没有子节点/当前节点，则深度为 0（取决于您是从 0 还是从 1 计算深度）。

另外，除非树很大，否则它只是另一个将其作为单独步骤计算的过程；仍然是 O(n)。否则可能是过早的优化。

我上面的两条评论可能具有误导性：您想从所有孩子那里获取最大深度。我更新了答案，通过概念证明更详细地涵盖了这个案例。

【参考方案2】：

您可以使用广度优先搜索来获取所有节点的深度以及从根到每个节点的路径，然后迭代所有节点的结果，产生最大深度：

from collections import deque
tree = '1': '1': None, '2': '1': '1': None, '2': None, '2': None, '3': '1': None
def bfs(t):
   d = deque([(a, [a], 0, b) for a, b in t.items()])
   while d:
      yield (n:=d.popleft())[:-1]
      if n[-1] is not None:
         d.extend([(a, n[1]+[a], n[2]+1, b) for a, b in n[-1].items()])

nodes = list(bfs(tree))
r = '.'.join(b):max(y for _, x, y in nodes if a in x) - c for a, b, c in nodes

输出：

'1': 3, '1.1': 2, '1.2': 2, '1.3': 1, '1.2.1': 1, '1.2.2': 1, '1.3.1': 1, '1.2.1.1': 0, '1.2.1.2': 0

【参考方案3】：

如果有人还想添加有关节点当前深度以及节点包含多少节点（计数节点）的信息，我扩展了 @ggorlen 的答案

def create_depth_map(self, tree, depth, node_count):
    results = list(zip(*map(lambda x: self.create_depth_map(*x), [[child, depth + 1, node_count] for child in tree.children])))
    tree.max_depth = (max(results[0]) if tree.children else 0)
    tree.current_depth = depth
    node_count += (sum(results[1]) if tree.children else 0)
    tree.node_count = node_count
    return tree.max_depth + 1, node_count

所以它看起来像：

Selector [current_depth: 0] [max_depth: 5] [node_count: 17]
    Action [current_depth: 1] [max_depth: 0] [node_count: 1]
    Inverter [current_depth: 1] [max_depth: 3] [node_count: 7]
        Sequence [current_depth: 2] [max_depth: 2] [node_count: 6]
            Action [current_depth: 3] [max_depth: 0] [node_count: 1]
            Sequence [current_depth: 3] [max_depth: 1] [node_count: 4]
                Action [current_depth: 4] [max_depth: 0] [node_count: 1]
                Condition [current_depth: 4] [max_depth: 0] [node_count: 1]       
                Condition [current_depth: 4] [max_depth: 0] [node_count: 1]       
    Inverter [current_depth: 1] [max_depth: 4] [node_count: 8]
        Sequence [current_depth: 2] [max_depth: 3] [node_count: 7]
            Sequence [current_depth: 3] [max_depth: 2] [node_count: 5]
                Parallel [current_depth: 4] [max_depth: 1] [node_count: 3]        
                    Action [current_depth: 5] [max_depth: 0] [node_count: 1]      
                    Condition [current_depth: 5] [max_depth: 0] [node_count: 1]   
                Action [current_depth: 4] [max_depth: 0] [node_count: 1]
            Action [current_depth: 3] [max_depth: 0] [node_count: 1]

非常感谢 ggorlen，这让我更进一步！