class Solution {
public:int max_sum = INT_MIN;  // 初始化为最小值，确保能够处理所有可能的路径和int maxPathSum(TreeNode* root) {dfs(root);return max_sum;}int dfs(TreeNode* root) {if (root == nullptr) return 0;  // 如果是空节点，返回0// 递归计算左子树和右子树的最大路径和，负值则不贡献路径和int left = max(0, dfs(root->left));  // 只考虑正路径int right = max(0, dfs(root->right));  // 只考虑正路径// 计算当前节点的最大路径和，包括根节点与左、右子树的路径max_sum = max(max_sum, root->val + left + right);// 返回当前节点的最大贡献值return root->val + max(left, right);  // 返回当前节点的最大路径和（要么包括左子树，要么右子树）}
};

路径上的节点最多有两个相邻节点。

好的，接下来我会详细解析你之前提到的 二叉树最大路径和 代码的思路。

问题说明

最大路径和问题的目标是：在一个二叉树中找到一条路径，使得路径上的节点值的和最大。这条路径可以通过任意节点，不需要从根节点开始，并且路径可以穿越树的多个分支。

• max_sum 作为一个全局变量，用来存储二叉树中计算出来的最大路径和。初始化为 0，代表我们初始时尚未计算任何路径的和。

2. maxPathSum 函数

int maxPathSum(TreeNode* root) {

    dfs(root);  // 从根节点开始，递归计算最大路径和

    return max_sum;  // 返回最大路径和

}

• maxPathSum 是主要的接口函数，它接收二叉树的根节点 root 作为输入，调用 dfs 函数计算路径和。

• 调用 dfs(root) 会触发对整个树的深度优先搜索。

• 最后返回 max_sum，这个变量会保存二叉树中遍历得到的最大路径和。

3. 深度优先搜索 dfs 函数

int dfs(TreeNode* root) {

    if (root == nullptr) return 0;  // 递归边界：如果节点为空，路径和为0

• dfs 是一个递归函数，负责从当前节点计算出其左右子树的路径和，并更新 max_sum。

• 如果当前节点是 nullptr（即为空节点），直接返回 0，因为空节点对路径和没有任何贡献。

int left = max(0, dfs(root->left));  // 计算左子树的最大路径和，若为负数则不贡献，返回0

int right = max(0, dfs(root->right));  // 计算右子树的最大路径和，若为负数则不贡献，返回0

• 计算当前节点的左子树和右子树的最大路径和。

• 对于每个子树，我们希望只考虑正路径和（即如果某个子树的路径和是负数，那么我们就不考虑这条路径）。因此，使用 max(0, dfs(...)) 来确保如果子树的路径和为负数，则返回 0，表示我们不选取该子树。

• dfs(root->left) 和 dfs(root->right) 分别递归地计算左子树和右子树的最大路径和。

max_sum = max(max_sum, root->val + left + right);  // 以当前节点为根的路径和

• 现在我们计算的是通过当前节点 root 的路径和，这个路径包括：

• 当前节点的值 root->val

• 左子树的最大路径和 left

• 右子树的最大路径和 right

• max_sum 会更新为当前路径和和之前的最大路径和中的较大值。

return root->val + max(left, right);  // 返回当前节点的最大路径和

• 由于路径不能跨越多个分支，因此我们只能选择单边（左子树或右子树）继续延伸路径。返回当前节点的最大路径和时，我们只选择左子树和右子树中的较大者：

• root->val + max(left, right) 表示包括当前节点和其较大子树路径和的最大路径和。

4. 递归的执行流程

• 从根节点开始递归。

• 对于每个节点：

• 计算左右子树的最大路径和（递归调用 dfs）。

• 更新全局变量 max_sum。

• 返回当前节点的最大路径贡献（选择左子树或右子树的较大路径）。

• 最终 max_sum 就包含了整棵树的最大路径和。

代码执行流程（示例）

假设有以下二叉树：

       1

      / \

     2   3

    / \

   4   5

1. 调用 maxPathSum(root)，根节点是 1：

• 进入 dfs(1)。

2. dfs(1)：

• 左子树是 2，右子树是 3，开始计算左右子树的路径和。

3. 计算 dfs(2)（左子树）：

• 左子树是 4，右子树是 5，继续递归。

4. 计算 dfs(4)：

• 节点 4 没有子树，返回 4。

5. 计算 dfs(5)：

• 节点 5 没有子树，返回 5。

6. 计算 dfs(2)：

• left = 4，right = 5，节点 2 的路径和是 2 + 4 + 5 = 11。

• 更新 max_sum = 11。

• 返回 2 + max(4, 5) = 7。

7. 计算 dfs(3)（右子树）：

• 节点 3 没有子树，返回 3。

8. 计算 dfs(1)（根节点）：

• left = 7，right = 3，节点 1 的路径和是 1 + 7 + 3 = 11，max_sum 不变。

• 返回 1 + max(7, 3) = 8。

9. 最终结果：

• max_sum = 11，即树中的最大路径和是 4 -> 2 -> 5 或 4 -> 2 -> 1 -> 3。

总结

1. 深度优先搜索：通过递归遍历树中的每个节点，计算以每个节点为根的最大路径和。

2. 路径和的更新：对于每个节点，计算包括其左右子树的路径和，并更新全局最大路径和 max_sum。

3. 递归的返回值：每个节点返回的路径和代表它向上回溯的贡献，它是当前节点值与左、右子树最大路径和中的较大者之和。

这种方法的时间复杂度是 O(n)，其中 n 是二叉树的节点数，因为每个节点只会被访问一次。