牛客题解 | 二叉树中的最大路径和

原创已于 2025-03-11 10:17:03 修改 · 393 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #力扣 #面试 #算法力扣

于 2025-03-11 10:15:00 首次发布

牛客笔试必刷101题单题解专栏收录该内容

72 篇文章

订阅专栏

题目## 题目

题目链接

解题思路

核心思想：
- 对于每个节点，需要考虑经过该节点的最大路径和
- 路径可以是：左子树->节点->右子树，或者左子树->节点，或者右子树->节点
- 需要自底向上计算，使用DFS
关键点：
- 每个节点需要返回：从该节点出发的最大路径和（只能选择一个子树）
- 同时需要更新全局最大路径和（可以包含两个子树）
- 注意处理负数情况

代码

#include <bits/stdc++.h>
using namespace std;

const int N = 100010;
vector<int> children[N];
int values[N];
int ans;

int dfs(int u) {
    if(children[u].empty()) {  // 叶子节点
        ans = max(ans, values[u-1]);
        return values[u-1];
    }
    
    // 获取左右子节点的最大路径和
    int max_child = INT_MIN;
    int sum_child = values[u-1];  // 当前节点值
    
    for(int child : children[u]) {
        int child_sum = dfs(child);
        // 更新从当前节点出发的最大路径
        max_child = max(max_child, child_sum);
        // 尝试将子路径加入总路径（如果为正）
        if(child_sum > 0) {
            sum_child += child_sum;
        }
    }
    
    // 更新全局最大路径和
    ans = max(ans, sum_child);
    
    // 返回从当前节点出发的最大路径和（只能选择一个子树）
    return max(values[u-1], values[u-1] + max_child);
}

int main() {
    int n;
    cin >> n;
    
    // 读入节点值
    for(int i = 0; i < n; i++) {
        cin >> values[i];
    }
    
    // 读入父节点关系并构建子节点表
    for(int i = 0; i < n; i++) {
        int p;
        cin >> p;
        if(p > 0) {  // 非根节点
            children[p].push_back(i+1);
        }
    }
    
    ans = INT_MIN;
    dfs(1);  // 从根节点开始DFS
    
    cout << ans << endl;
    
    return 0;
}

import java.util.*;

public class Main {
    static int N = 100010;
    static ArrayList<Integer>[] children;
    static int[] values;
    static int ans;
    
    static int dfs(int u) {
        if(children[u].isEmpty()) {  // 叶子节点
            ans = Math.max(ans, values[u-1]);
            return values[u-1];
        }
        
        // 获取左右子节点的最大路径和
        int maxChild = Integer.MIN_VALUE;
        int sumChild = values[u-1];  // 当前节点值
        
        for(int child : children[u]) {
            int childSum = dfs(child);
            // 更新从当前节点出发的最大路径
            maxChild = Math.max(maxChild, childSum);
            // 尝试将子路径加入总路径（如果为正）
            if(childSum > 0) {
                sumChild += childSum;
            }
        }
        
        // 更新全局最大路径和
        ans = Math.max(ans, sumChild);
        
        // 返回从当前节点出发的最大路径和（只能选择一个子树）
        return Math.max(values[u-1], values[u-1] + maxChild);
    }
    
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        
        // 初始化
        values = new int[n];
        children = new ArrayList[N];
        for(int i = 0; i < N; i++) {
            children[i] = new ArrayList<>();
        }
        
        // 读入节点值
        for(int i = 0; i < n; i++) {
            values[i] = sc.nextInt();
        }
        
        // 读入父节点关系并构建子节点表
        for(int i = 0; i < n; i++) {
            int p = sc.nextInt();
            if(p > 0) {  // 非根节点
                children[p].add(i+1);
            }
        }
        
        ans = Integer.MIN_VALUE;
        dfs(1);  // 从根节点开始DFS
        
        System.out.println(ans);
        
        sc.close();
    }
}

import sys
sys.setrecursionlimit(100010)  # 扩大递归栈深度

def dfs(u, values, children, ans):
    """
    返回从节点u出发的最大路径和
    同时更新全局最大路径和ans[0]
    """
    if not children[u]:  # 叶子节点
        ans[0] = max(ans[0], values[u-1])
        return values[u-1]
    
    # 获取左右子节点的最大路径和
    max_child = float('-inf')
    sum_child = values[u-1]  # 当前节点值
    
    for child in children[u]:
        child_sum = dfs(child, values, children, ans)
        # 更新从当前节点出发的最大路径
        max_child = max(max_child, child_sum)
        # 尝试将子路径加入总路径（如果为正）
        if child_sum > 0:
            sum_child += child_sum
    
    # 更新全局最大路径和
    ans[0] = max(ans[0], sum_child)
    
    # 返回从当前节点出发的最大路径和（只能选择一个子树）
    return max(values[u-1], values[u-1] + max_child)

def main():
    # 输入
    n = int(input())
    values = list(map(int, input().split()))
    parents = list(map(int, input().split()))
    
    # 构建子节点表
    children = [[] for _ in range(n+1)]
    root = 1
    for i in range(n):
        if parents[i] > 0:  # 非根节点
            children[parents[i]].append(i+1)
    
    # 计算最大路径和
    ans = [float('-inf')]  # 使用列表存储全局最大值
    dfs(root, values, children, ans)
    
    print(ans[0])

if __name__ == "__main__":
    main()

算法及复杂度

算法：DFS（后序遍历）
时间复杂度： $\mathcal{O}(n)$ ，每个节点只访问一次
空间复杂度： $\mathcal{O}(1)$ ，不考虑递归栈空间

题目链接

题目的主要信息：

给定一个元素升序的、无重复数字的整型数组 nums 和一个目标值 target
找到目标值的下标
如果找不到返回-1

举一反三：

学习完本题的思路你可以解决如下题目：

BM18.二维数组中的查找

BM19.寻找峰值

BM21.旋转数组

方法：二分法（推荐使用）

知识点：分治

分治即“分而治之”，“分”指的是将一个大而复杂的问题划分成多个性质相同但是规模更小的子问题，子问题继续按照这样划分，直到问题可以被轻易解决；“治”指的是将子问题单独进行处理。经过分治后的子问题，需要将解进行合并才能得到原问题的解，因此整个分治过程经常用递归来实现。

思路：

本来我们可以遍历数组直接查找，每次检查当前元素是不是要找的值。

for(int i = 0; i < nums.length; i++)
    if(nums[i] == target)
        return i;

但是这样这个有序的数组我们就没有完全利用起来。我们想想，若是目标值比较小，肯定在前半区间，若是目标值比较大，肯定在后半区间，怎么评价大小？我们可以用中点值作为一个标杆，将整个数组分为两个区间，目标值与中点值比较就能知道它会在哪个区间，这就是分治的思维。

具体做法：

step 1：从数组首尾开始，每次取中点值。
step 2：如果中间值等于目标即找到了，可返回下标，如果中点值大于目标，说明中点以后的都大于目标，因此目标在中点左半区间，如果中点值小于目标，则相反。
step 3：根据比较进入对应的区间，直到区间左右端相遇，意味着没有找到。

图示：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Java实现代码：

import java.util.*;
public class Solution {
    public int search (int[] nums, int target) {
        int l = 0;
        int r = nums.length - 1;
        //从数组首尾开始，直到二者相遇
        while(l <= r){ 
            //每次检查中点的值
            int m = (l + r) / 2; 
            if(nums[m] == target)
                return m;
            //进入左的区间
            if(nums[m] > target) 
                r = m - 1;
            //进入右区间
            else 
                l = m + 1;
        }
        //未找到
        return -1; 
    }
}

C++实现代码：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size() - 1;
        //从数组首尾开始，直到二者相遇
        while(l <= r){ 
            //每次检查中点的值
            int m = (l + r) / 2; 
            if(nums[m] == target)
                return m;
            //进入左的区间
            if(nums[m] > target) 
                r = m - 1;
            //进入右区间
            else 
                l = m + 1;
        }
        //未找到
        return -1; 
    }
};

Python代码实现

class Solution:
    def search(self , nums: List[int], target: int) -> int:
        l = 0
        r = len(nums) - 1
        # 从数组首尾开始，直到二者相遇
        while l <= r :
            # 每次检查中点的值 
            m = int((l+r)/2) 
            if nums[m] == target:
                return m
            # 进入左的区间
            if nums[m] > target: 
                r = m - 1
            # 进入右区间
            else: 
                l = m + 1
        # 未找到
        return -1