蓝桥杯--生命之树（Java）

package com.itdonghuang.Test;

import java.util.*;

public class JavaTest1 {
    static long maxsum = 0;

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        
        int n = scan.nextInt();
        
        int[] val = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            val[i] = scan.nextInt();
        }

        List<Integer>[] opp = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            opp[i] = new ArrayList<>();
        }
        for (int i = 0; i < n - 1; i++) {
            int u = scan.nextInt();
            int v = scan.nextInt();
            opp[u].add(v);
            opp[v].add(u);
        }

        dfs(1, -1, opp, val);
        System.out.println(maxsum);

        scan.close();
    }

    public static long dfs(int u, int parent, List<Integer>[] opp, int[] val) {
        long sum = val[u];

        for (int v : opp[u]) {
            if (v == parent) continue;
            
            long childSum = dfs(v, u, opp, val);
            if (childSum > 0) {
                sum += childSum;
            }
        }

        if (sum > maxsum) {
            maxsum = sum;
        }
        return sum;
    }
}

代码分析：

一、初始化，赋值

定义n、val、opp分别接受键盘输入的节点数、每个结点的评分、u<-->v的边

opp是一个数组array，每个元素是List<Integer>，构成无向图

java 复制代码

Scanner scan = new Scanner(System.in);
        
int n = scan.nextInt();
        
int[] val = new int[n + 1];
for (int i = 1; i <= n; i++) {
    val[i] = scan.nextInt();
}

List<Integer>[] opp = new ArrayList[n + 1];
for (int i = 1; i <= n; i++) {
    opp[i] = new ArrayList<>();
}
for (int i = 0; i < n - 1; i++) {
    int u = scan.nextInt();
    int v = scan.nextInt();
    opp[u].add(v);
    opp[v].add(u);
}

二、dfs方法讲解

逐行详解

第 1 行：`long sum = val[u];`

含义：当前子树至少包含节点 u 自己。
**用 long，**防止整数溢出（权值可能很大）。
关键思想 ：我们计算的是 "必须包含当前节点 u 的最大连通子图和"。

注意：这个子图必须包含 u，但可以选择性地包含它的某些子树。

第 2--3 行：遍历邻居 + 跳过父节点

java 复制代码

for (int v : opp[u]) {
    if (v == parent) continue;

opp[u] 是节点 u 的所有邻居（来自邻接表）。
因为树是无向图，u 的邻居包括它的父节点 和子节点。
但我们是从根往下 DFS 的，所以要避免走回父节点，否则会无限递归或重复访问。

举例：

如果从 1 → 2 → 3，那么在 dfs(2, 1) 中，opp[2] 包含 1 和 3，

必须跳过 1（因为它是父节点），只处理 3。

第 4 行：`long childSum = dfs(v, u, opp, val);`

递归调用 ：进入子节点 v，并告诉它："你的父节点是 u"。
返回值含义 ：
childSum = 以 v 为根的子树中，包含 v 的最大连通子图的和。

再次强调：这个值必须包含 v ，但可能只包含 v 自己（如果子树都是负的）。

第 5 行：`if (childSum > 0) sum += childSum;`

这是整个算法最核心的贪心思想！

为什么只加正数？

如果某个子树的最大和是负数（比如 -5），把它加到当前节点只会让总和变小。
所以我们只"吸收"那些能带来正收益的子树。
这相当于：不选那些负贡献的子树分支。

类比数组版"最大子数组和"（Kadane 算法）：

如果前缀和 < 0，就丢掉，重新开始。

这里同理：如果子树和 < 0，就"断开"，不选它。

举个例子：

val[u] = 3
子树 A 贡献 +4 → 加上 → 总和变成 7
子树 B 贡献 -2 → 不加 → 总和还是 7
最终 sum = 3 + 4 = 7

第 6 行：`if (sum > maxsum) maxsum = sum;`

更新全局答案！
sum 是"包含当前节点 u 的最大连通子图和"。
而全局最优解一定是以某个节点为"最高点"的连通子图（因为树是连通无环的）。
所以我们在每个节点都尝试一次，取最大值。

这就是为什么不需要额外判断"路径是否跨子树"------因为任何连通子图都有一个"顶部节点"，我们会在那里计算它。

第 7 行：`return sum;`

返回值用途 ：告诉父节点，"如果你把我（以 u 为根的这部分）接上去，最多能给你增加 sum 的收益"。
父节点会根据这个值决定是否"吸收"你。

这是一个典型的 自底向上（bottom-up）的信息传递过程。

java 复制代码

public static long dfs(int u, int parent, List<Integer>[] opp, int[] val) {
    long sum = val[u]; // 当前子树至少包含自己

    for (int v : opp[u]) {
        if (v == parent) continue; // 避免回溯到父节点（防止死循环）

        long childSum = dfs(v, u, opp, val); // 递归计算以 v 为根的子树的最大"贡献值"

        if (childSum > 0) {
            sum += childSum; // 只有当子树贡献为正时，才合并进来
        }
    }

    if (sum > maxsum) {
        maxsum = sum; // 更新全局最大子树和
    }

    return sum; // 返回以 u 为根的子树能向上提供的最大和（用于父节点决策）
}

结语：

今天是我刷算法的第N天，每天刷算法题，写写项目，补充知识点。完善知识体系，加油加油！希望可以帮助到你！

"你走的每一步，都算数；你坚持的每一刻，都在靠近光。" 💪✨