4.22
124. 二叉树中的最大路径和 - 力扣（LeetCode）
本题有两个关键概念：
- 链：从下面的某个节点（不一定是叶子）到当前节点的路径。把这条链的节点值之和，作为 dfs 的返回值。如果节点值之和是负数，则返回 0。
- 直径：等价于由两条（或者一条）链拼成的路径。我们枚举每个 node，假设直径在这里「拐弯」，也就是计算由左右两条从下面的某个节点（不一定是叶子）到 node 的链的节点值之和，去更新答案的最大值。
⚠注意：dfs 返回的是链的节点值之和，不是直径的节点值之和。
链：max(max(l_val, r_val) + node->val, 0);
直径： ans = max(ans, l_val + r_val + node->val);
左右子树都被选中时，路径不能继续向上分叉
问：如果所有节点值都是负数，代码会算出什么结果？
答：在所有节点值都为负数的情况下，代码中的
ans = max(ans, l_val + r_val + node.val)等价于ans = max(ans, node.val)，我们求的是最大节点值（绝对值最小的负数）。这是符合题目要求的，因为在所有节点值都为负数的情况下，路径只有一个节点是最优的（毕竟节点越多，元素和越小）。类比 53. 最大子数组和，当数组元素都是负数的时候，答案就是 max(nums)。
class Solution {
public:
int maxPathSum(TreeNode* root) {
int ans = INT_MIN;
auto dfs = [&](this auto&& dfs, TreeNode* node) -> int {
if (node == nullptr) {
return 0; // 没有节点，和为 0
}
int l_val = dfs(node->left); // 左子树最大链和
int r_val = dfs(node->right); // 右子树最大链和
ans = max(ans, l_val + r_val + node->val); // 两条链拼成路径
return max(max(l_val, r_val) + node->val, 0); // 当前子树最大链和（注意这里和 0 取最大值了）
};
dfs(root);
return ans;
}
};
代码说明：
在给定的代码中，
return max(max(l_val, r_val) + node->val, 0);这一行的目的是计算当前子树对父节点的最大贡献值。以下是对该行的详细解释：关键点解析：
node->val的含义：
node->val是当前节点的值，而非子节点的值。在递归过程中，每个节点独立处理自己的值，结合左右子树的贡献值进行决策。- 递归逻辑：
l_val和r_val分别表示左子树和右子树的最大贡献值（即从左右子节点出发向下延伸的路径和的最大值）。- 当前节点可以选择左或右子树中贡献更大的一侧，加上自身值，形成一条链式路径（例如，
max(l_val, r_val) + node->val）。- 若该链式路径的和为负数，则返回
0，表示当前子树对父节点没有贡献（因为父节点可以选择不经过该子树）。- 全局最大路径和
ans的更新：
在计算当前节点的贡献值之前，代码通过ans = max(ans, l_val + r_val + node->val);更新全局最大值。这一步考虑的是以当前节点为“根”的完整路径（左链 + 当前节点 + 右链），即使这条路径无法向上延伸（例如，左右子树都被选中时，路径不能继续向上分叉）。举例说明：
示例1：简单负值节点
- 树结构：单个节点
node，node->val = -3。- 递归过程：
- 左右子树均为空，
l_val = 0，r_val = 0。ans更新为0 + 0 + (-3) = -3。- 返回值：
max(max(0, 0) + (-3), 0) = max(-3, 0) = 0。- 结果：全局最大值
ans = -3，正确。示例2：复杂树结构
-10 / \ 9 20 / \ 15 7
- 节点15：
- 左右子树为空，贡献值均为
0。- 返回值：
max(0 + 15, 0) = 15。- 节点7：
- 左右子树为空，贡献值均为
0。- 返回值：
max(0 + 7, 0) = 7。- 节点20：
l_val = 15，r_val = 7。ans更新为15 + 7 + 20 = 42（全局最大值）。- 返回值：
max(15, 7) + 20 = 35。（如果都取了就不能往上走）- 节点-10：
- 左子树贡献
9，右子树贡献35。ans计算9 + 35 + (-10) = 34（小于42，不更新）。- 返回值：
max(35, 9) + (-10) = 25（与0比较后仍为25）。总结：
node->val是当前节点的值，递归过程中每个节点独立计算自己的贡献值。- 返回值的意义：当前子树能向上提供的最大链式和（若为负则返回0，表示不选择该子树）。
- 全局最大值的更新：通过遍历所有可能的路径（包括以当前节点为根的完整路径）确保不漏掉最优解。
复杂度分析
- 时间复杂度：O(n)，其中 n 为二叉树的节点个数。
- 空间复杂度：O(n)。最坏情况下，二叉树退化成一条链，递归需要 O(n) 的栈空间。
相关题目
543. 二叉树的直径
定义和上题一样
⚠注意：dfs 返回的是链的长度，不是直径的长度。
⚠注意：dfs 返回的是当前子树的最大链长（也可以理解为子树的高度），不包含当前节点和其父节点的这条边。因此 int l_len = dfs(node->left) + 1
class Solution {
public:
int diameterOfBinaryTree(TreeNode* root) {
int ans = 0;
auto dfs = [&](this auto&& dfs, TreeNode* node) -> int {
if (node == nullptr) {
return -1;// 下面 +1 后，对于叶子节点就刚好是 0
}
int l_len = dfs(node->left) + 1; // 左子树最大链长+1
int r_len = dfs(node->right) + 1; // 右子树最大链长+1
ans = max(ans, l_len + r_len); // 两条链拼成路径
return max(l_len, r_len); // 当前子树最大链长
};
dfs(root);
return ans;
}
};
2246. 相邻字符不同的最长路径
前置题目： 543. 二叉树的直径
如果没有相邻节点的限制，那么本题求的就是树的直径上的点的个数，见 1245. 树的直径。
考虑用树形 DP 求直径。枚举子树 x 的所有子树 y，维护从 x 出发的最长路径 maxLen，那么可以更新答案为从 y 出发的最长路径加上 maxLen，再加上 1（边 x−y），即合并从 x 出发的两条路径。递归结束时返回 maxLen。
对于本题的限制，我们可以在从子树 y 转移过来时，仅考虑从满足 s[y]!=s[x] 的子树 y 转移过来，所以对上述做法加个
if判断就行了。由于本题求的是点的个数，所以答案为最长路径的长度加一。
class Solution {
public:
int longestPath(vector<int>& parent, string s) {
int n = parent.size();
vector<vector<int>> g(n); // 构建树的邻接表表示
for (int i = 1; i < n; i++) {
g[parent[i]].push_back(i); // 将子节点加入父节点的邻接表
}
int ans = 0; // 存储最长路径的边数
// DFS定义：返回以x为起点的最长单链边数（只能选择一个子节点）
auto dfs = [&](this auto&& dfs, int x) -> int {
int max_len = 0; // 记录当前节点的子节点中最长的单链边数
for (int y : g[x]) { // 遍历所有子节点
int len = dfs(y) + 1; // 子节点y的最长单链边数 + 当前边(x->y)
if (s[y] != s[x]) { // 字符不同才能连接
// 更新全局最大值：当前最长链 + 新链的组合
ans = max(ans, max_len + len);
// 维护当前节点的最长单链边数
max_len = max(max_len, len);
}
}
return max_len; // 返回以x为起点的最长单链边数
};
dfs(0); // 从根节点开始遍历
return ans + 1; // 边数转节点数（路径长度=边数+1）
}
};
关键点解释：
- 邻接表构建
通过parent数组构建树结构，g[x]存储节点x的所有子节点。例如，若parent[i] = x，则i是x的子节点。- DFS递归逻辑
len = dfs(y) + 1
表示从子节点y出发的最长路径边数（dfs(y)）加上当前边x→y，构成以x为起点的路径。- 字符不同才能连接
若x与子节点y的字符不同，则可以组合路径，否则跳过。- 维护全局最大值
ans
将当前子节点的路径长度len与之前的最长子路径max_len相加，形成以x为中间节点的完整路径。- 返回最长单链边数
每个节点返回给父节点的值是其子节点中的最长单链边数，保证路径是线性无分叉的。- 最终结果处理
由于ans记录的是最长路径的边数，返回时需+1转换为节点数。
示例说明：
示例1：
输入
parent = [-1,0,0,1,1],s = "abacd"
树结构如下：0(a) / \ 1(b) 2(a) / \ 3(c) 4(d)DFS过程
- 节点3（叶节点）：无子节点，返回0。
len = 0 + 1 = 1，字符c != b，更新ans = 0 + 1 = 1，max_len = 1。- 节点4（叶节点）：同理，
len = 1，字符d != b，更新ans = 1 + 1 = 2。- 节点1：返回
max_len = 1，传递给父节点。- 节点0：处理子节点1时，
len = 1 + 1 = 2，字符b != a，更新ans = 0 + 2 = 2；处理子节点2时，字符相同不更新。最终返回ans + 1 = 3。最长路径
路径为3 → 1 → 4，节点数为3，对应ans + 1 = 3。
示例2：
输入
parent = [-1,0,1,2,3],s = "abcde"
树结构为链式：0(a) → 1(b) → 2(c) → 3(d) → 4(e)DFS过程
- 节点4：返回0，
len = 1，更新ans = 1。- 节点3：
len = 1 + 1 = 2，更新ans = 2。- 节点2：
len = 2 + 1 = 3，更新ans = 3。- 节点1：
len = 3 + 1 = 4，更新ans = 4。- 节点0：
len = 4 + 1 = 5，更新ans = 5。最长路径
整条链0 → 1 → 2 → 3 → 4，节点数5，对应ans + 1 = 5。
687. 最长同值路径
思路
在 543. 二叉树的直径 的基础上修改：
- 如果当前节点和左子树的值不同，左子树的链长可以视作 0，否则就是左子树的链长。
- 如果当前节点和右子树的值不同，右子树的链长可以视作 0，否则就是右子树的链长；
常见错误
先判断节点值是否相同，不同则不往下递归的写法是错误的。
想一想，如果正确答案在更下面的子树当中呢？
必须保证每个节点都访问到。所以正确的写法是先递归，再判断。
class Solution {
public:
int longestUnivaluePath(TreeNode* root) {
int ans = 0;
auto dfs = [&](this auto&& dfs, TreeNode* node) -> int {
if (node == nullptr) {
return -1; // 下面 +1 后，对于叶子节点就刚好是 0
}
int l_len = dfs(node->left) + 1; // 左子树最大链长+1
int r_len = dfs(node->right) + 1; // 右子树最大链长+1
if (node->left && node->left->val != node->val) l_len = 0; // 链长视作 0
if (node->right && node->right->val != node->val) r_len = 0; // 链长视作 0
ans = max(ans, l_len + r_len); // 两条链拼成路径
return max(l_len, r_len); // 当前子树最大链长
};
dfs(root);
return ans;
}
};
HARD:1617. 统计子树中城市之间最大距离（未做）
HARD:2539. 最大价值和与最小价值和的差值（未做）
151. 反转字符串中的单词 - 力扣（LeetCode）
解题思路如下：
- 移除多余空格
- 将整个字符串反转
- 将每个单词反转
举个例子，源字符串为："the sky is blue "
- 移除多余空格 : "the sky is blue"
- 字符串反转："eulb si yks eht"
- 单词反转："blue is sky the"
使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。
这部分和27.移除元素的逻辑是一样一样的，本题是移除空格，而 27.移除元素 就是移除元素。
所以代码可以写的很精简，大家可以看 如下 代码
removeExtraSpaces函数的实现：// 版本二 void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。 int slow = 0; //整体思想参考https://programmercarl.com/0027.移除元素.html for (int i = 0; i < s.size(); ++i) { // if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。 if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。 while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。 s[slow++] = s[i++]; } } } s.resize(slow); //slow的大小即为去除多余空格后的大小。 }如果以上代码看不懂，建议先把 27.移除元素这道题目做了。
此时我们已经实现了
removeExtraSpaces函数来移除冗余空格。还做实现反转字符串的功能，支持反转字符串子区间，这个实现我们分别在344.反转字符串和541.反转字符串II里已经讲过了。
代码如下：
// 反转字符串s中左闭右闭的区间[start, end] void reverse(string& s, int start, int end) { for (int i = start, j = end; i < j; i++, j--) { swap(s[i], s[j]); } }
class Solution {
public:
void reverse(string& s, int start, int end){ //翻转，区间写法：左闭又闭 []
for (int i = start, j = end; i < j; i++, j--) {
swap(s[i], s[j]);
}
}
void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
int slow = 0; //整体思想参考https://programmercarl.com/0027.移除元素.html
for (int i = 0; i < s.size(); ++i) { //
if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
s[slow++] = s[i++];
}
}
}
s.resize(slow); //slow的大小即为去除多余空格后的大小。
}
string reverseWords(string s) {
removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
reverse(s, 0, s.size() - 1);
int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
for (int i = 0; i <= s.size(); ++i) {
if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
start = i + 1; //更新下一个单词的开始下标start
}
}
return s;
}
};
56. 合并区间 - 力扣（LeetCode）
以示例 1 为例，我们有 [1,3],[2,6],[8,10],[15,18] 这四个区间。
为方便合并，把区间按照左端点从小到大排序（示例 1 已经按照左端点排序了）。排序的理由会在下面的合并过程中说明。
排序后，我们就知道了第一个合并区间的左端点，即
intervals\[0\]\[0\]\=1。第一个合并区间的右端点是多少？目前只知道
其 ≥intervals\[0\]\[1\]\=3，但具体是多少现在还不确定，得向右遍历。具体算法如下：
- 把 intervals[0] 加入答案。注意，答案的最后一个区间表示当前正在合并的区间。
- 遍历到 intervals[1]=[2,6]，由于左端点 2 不超过当前合并区间的右端点 3，可以合并。由于右端点 6>3，那么更新当前合并区间的右端点为 6。注意，由于我们已经按照左端点排序，所以 intervals[1] 的左端点 2 必然大于等于合并区间的左端点，所以无需更新当前合并区间的左端点。
- 遍历到 intervals[2]=[8,10]，由于左端点 8 大于当前合并区间的右端点 6，无法合并（两个区间不相交）。再次利用区间按照左端点排序的性质，更后面的区间的左端点也大于 6，无法与当前合并区间相交，所以当前合并区间 [1,6] 就固定下来了，把新的合并区间 [8,10] 加入答案。
- 遍历到 intervals[3]=[15,18]，由于左端点 15 大于当前合并区间的右端点 10，无法合并（两个区间不相交），我们找到了一个新的合并区间 [15,18] 加入答案。
上述算法同时说明，按照左端点排序后，合并的区间一定是 intervals 中的连续子数组。
class Solution {
public:
vector<vector<int>> merge(vector<vector<int>>& intervals) {
ranges::sort(intervals); // 按照左端点从小到大排序
vector<vector<int>> ans;
for (auto& p : intervals) {
if (!ans.empty() && p[0] <= ans.back()[1]) { // 可以合并
ans.back()[1] = max(ans.back()[1], p[1]); // 更新右端点最大值
} else { // 不相交，无法合并
ans.emplace_back(p); // 新的合并区间
}
}
return ans;
}
};
复杂度分析
- 时间复杂度：O(nlogn)，其中 n 是 intervals 的长度。瓶颈在排序上。
- 空间复杂度：O(1)。排序的栈开销和返回值不计入。
浙公网安备 33010602011771号