【问题标题】:Finding the largest sum of disjoint leaf-to-leaf paths in a binary tree在二叉树中找到不相交的叶到叶路径的最大总和
【发布时间】:2022-11-04 08:52:54
【问题描述】:

我需要关于我正在寻找从叶子到叶子的不相交路径(它们不能沿着相同的路径/边缘返回)的任务的建议,以便它们的总和创造最大可能的值,即路径不能相交并且必须是尽可能的好属于总。请注意,路径中断的点(根)不包括在总和中,即。图片。

我根本不知道如何解决这个问题。我附上了试图决定是选择一片叶子的路径还是选择较小的子树的代码,但它不能正常工作。

如果有人有任何学习材料,我将非常感激。先感谢您 所有程序 https://onecompiler.com/c/3ymb7xvzn

int depth(struct node *root, int *res)
{
    if(root == NULL) return 0;
    
    int l = depth(root->left, res);
    int r = depth(root->right, res);
    
    int max_single_best_Way = max(l+root->data, r+root->data);

    int max_root = l+r;
    
    int maximum = max(max_single_best_Way, max_root);
    *res = max(*res, maximum);

    return maximum;

}

我无法创建一个算法来解决这个问题。我想要一些可以在解决方案中使用的建议和学习材料。

【问题讨论】:

    标签: algorithm recursion tree binary-tree binary-search-tree


    【解决方案1】:

    让我们调用函数f,这是我们的整体任务,输入参数是树的根。让我们调用函数g,它是给定节点(包括该节点)的最大连续下降路径,它还为每个未选择的节点添加f 的结果。

    从树的根开始,在f 的运行中,对于每个节点,我们可以将其分配(1)作为路径中的父节点,或者(2)不属于任何路径。在 (1) 的情况下,我们想要g(left_child) + g(right_child)。在 (2) 的情况下,我们想要f(left_child) + f(right_child)

    带有第二个示例的 Python 代码,其中根不是任何路径的一部分:

    def g(tree):
      if tree == None:
        return 0
      return tree["val"] + max(
        g(tree["l"]) + f(tree["r"]),
        g(tree["r"]) + f(tree["l"])
      )
    
    def f(tree):
      if tree == None:
        return 0
      return max(
        g(tree["l"]) + g(tree["r"]),
        f(tree["l"]) + f(tree["r"])
      )
      
    tree = {
      "val": 0,
      
      "l": {
        "val": 2,
        
        "l": {
          "val": 2,
          "l": None,
          "r": None
        },
        
        "r": {
          "val": 3,
          "l": None,
          "r": None
        }
      },
      
      "r": {
        "val": 1,
        
        "l": {
          "val": 2,
          "l": None,
          "r": None
        },
        
        "r": {
          "val": 3,
          "l": None,
          "r": None
        }
      }
    }
    
    print(f(tree)) # 10
    

    你的第三个例子:

    tree = {
      "val": 0,
      
      "l": {
        "val": 6,
        
        "l": {
          "val": 5,
          "l": None,
          "r": None
        },
        
        "r": {
          "val": 3,
          "l": None,
          "r": None
        }
      },
      
      "r": {
        "val": 5,
        
        "l": {
          "val": 7,
          
          "l": {
            "val": 3,
            "l": None,
            "r": None
          },
        
          "r": {
            "val": 6,
            "l": None,
            "r": None
          }
        },
        
        "r": {
          "val": 7,
          
          "l": {
            "val": 6,
            "l": None,
            "r": None
          },
        
          "r": {
            "val": 7,
            "l": None,
            "r": None
          }
        }
      }
    }
    
    print(f(tree)) # 42
    

    【讨论】:

    • 嗨,感谢代码,它解决了我的情况并且可以理解,但是我很难创建类似的代码,你有一些技巧,学习资料如何学习为其他类似任务编写这样的树遍历?
    • 我不知道学习材料。通过阅读带有“算法”标签的问题并尝试理解解决方案并解决自己的问题,我学到了很多东西。
    • 嗨,我还在考虑简化这个任务,难道没有更简单的解决方案吗?今天我和大学的一位老师讨论了这个问题,也许它可以用我在帖子中概述的类似方式来解决,即如果你计算不相交路径的值和每个子树的总和。但我真的不知道该怎么做
    • @Martin1541 我不确定我是否遵循这个想法。您是否可以添加到问题描述中,用文字描述将要计算的数据以及程序将根据您的想法针对特定的非平凡示例做出的决定?
    • 看最后一张照片。关键是您计算当您越过顶部时的值和使用不相交子树时的路径,并且在递归中您决定哪个是更好的选择
    猜你喜欢
    • 2016-08-03
    • 2014-02-05
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2018-11-26
    • 2016-08-29
    相关资源
    最近更新 更多