🌟欢迎来到 我的博客 ------ 探索技术的无限可能！
30.二叉树中的链表
题目链接：1367. 二叉树中的链表
给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表。
如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。
一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。
示例 1：
输入：head = 4,2,8, root =
1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3
输出：true
解释：树中蓝色的节点构成了与链表对应的子路径。
示例 2：
输入：head = 1,4,2,6, root =
1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3
输出：true
示例 3：
输入：head = 1,4,2,6,8, root =
1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3
输出：false
解释：二叉树中不存在一一对应链表的路径。
提示：
二叉树和链表中的每个节点的值都满足 1 <= node.val <= 100 。
链表包含的节点数目在 1 到 100 之间。
二叉树包含的节点数目在 1 到 2500 之间。
题解：
方法：暴力匹配
java
class Solution {
private ListNode head;
public boolean isSubPath(ListNode head, TreeNode root) {
this.head = head;
return dfs(head, root);
}
private boolean dfs(ListNode s, TreeNode t) {
if (s == null) { // 整个链表匹配完毕
return true;
}
// 否则需要继续匹配
if (t == null) { // 无法继续匹配
return false;
}
// 节点值相同则继续匹配，否则从 head 开始重新匹配
return s.val == t.val && (dfs(s.next, t.left) || dfs(s.next, t.right)) ||
s == head && (dfs(head, t.left) || dfs(head, t.right));
}
} 31.切蛋糕的最小总开销 II
题目链接：3219. 切蛋糕的最小总开销 II
有一个 m x n 大小的矩形蛋糕，需要切成 1 x 1 的小块。
给你整数 m ，n 和两个数组：
horizontalCut 的大小为 m - 1 ，其中 horizontalCuti 表示沿着水平线 i 切蛋糕的开销。
verticalCut 的大小为 n - 1 ，其中 verticalCutj 表示沿着垂直线 j 切蛋糕的开销。
一次操作中，你可以选择任意不是 1 x 1 大小的矩形蛋糕并执行以下操作之一：
沿着水平线 i 切开蛋糕，开销为 horizontalCuti 。
沿着垂直线 j 切开蛋糕，开销为 verticalCutj 。
每次操作后，这块蛋糕都被切成两个独立的小蛋糕。
每次操作的开销都为最开始对应切割线的开销，并且不会改变。
请你返回将蛋糕全部切成 1 x 1 的蛋糕块的 最小 总开销。
示例 1：
输入：m = 3, n = 2, horizontalCut = 1,3, verticalCut = 5
输出：13
解释：
沿着垂直线 0 切开蛋糕，开销为 5 。
沿着水平线 0 切开 3 x 1 的蛋糕块，开销为 1 。
沿着水平线 0 切开 3 x 1 的蛋糕块，开销为 1 。
沿着水平线 1 切开 2 x 1 的蛋糕块，开销为 3 。
沿着水平线 1 切开 2 x 1 的蛋糕块，开销为 3 。
总开销为 5 + 1 + 1 + 3 + 3 = 13 。
示例 2：
输入：m = 2, n = 2, horizontalCut = 7, verticalCut = 4
输出：15
解释：
沿着水平线 0 切开蛋糕，开销为 7 。
沿着垂直线 0 切开 1 x 2 的蛋糕块，开销为 4 。
沿着垂直线 0 切开 1 x 2 的蛋糕块，开销为 4 。
总开销为 7 + 4 + 4 = 15 。
提示：
1 <= m, n <= 105
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCuti, verticalCuti <= 103
题解：
方法：最小生成树
java
class Solution {
public long minimumCost(int m, int n, int[] horizontalCut, int[] verticalCut) {
Arrays.sort(horizontalCut); // 下面倒序遍历
Arrays.sort(verticalCut);
long ans = 0;
int i = 0;
int j = 0;
while (i < m - 1 || j < n - 1) {
if (j == n - 1 || i < m - 1 && horizontalCut[i] < verticalCut[j]) {
ans += horizontalCut[i++] * (n - j); // 上下连边
} else {
ans += verticalCut[j++] * (m - i); // 左右连边
}
}
return ans;
}
} 未完待续
...