【2022.12.14】备战春招Day9——每日一题 + 416. 分割等和子集 + 617. 合并二叉树
[每日一题] 1697. 检查边长度限制的路径是否存在
题目描述
给你一个 n 个点组成的无向图边集 edgeList ，其中 edgeList[i] = [ui, vi, disi] 表示点 ui 和点 vi 之间有一条长度为 disi 的边。请注意，两个点之间可能有 超过一条边 。
给你一个查询数组queries ，其中 queries[j] = [pj, qj, limitj] ，你的任务是对于每个查询 queries[j] ，判断是否存在从 pj 到 qj 的路径，且这条路径上的每一条边都 严格小于 limitj 。
请你返回一个 布尔数组 answer ，其中 answer.length == queries.length ，当 queries[j] 的查询结果为 true 时， answer 第 j 个值为 true ，否则为 false 。
输入：n = 3, edgeList = [[0,1,2],[1,2,4],[2,0,8],[1,0,16]], queries = [[0,1,2],[0,2,5]]
输出：[false,true]
解释：上图为给定的输入数据。注意到 0 和 1 之间有两条重边，分别为 2 和 16 。
对于第一个查询，0 和 1 之间没有小于 2 的边，所以我们返回 false 。
对于第二个查询，有一条路径（0 -> 1 -> 2）两条边都小于 5 ，所以这个查询我们返回 true 。
题目解析
【离线查询】：「离线」的意思是，对于一道题目会给出若干询问，而这些询问是全部提前给出的，也就是说，你不必按照询问的顺序依次对它们进行处理，而是可以按照某种顺序（例如全序、偏序（拓扑序）、树的 DFS 序等）**或者把所有询问看成一个整体（**例如整体二分、莫队算法等）进行处理。
与「离线」相对应的是「在线」思维，即所有的询问是依次给出的，在返回第 kk 个询问的答案之前，不会获得第 k+1k+1 个询问。
首先将 edgeList 按边长度从小到大进行排序，然后将queries 按 limit 从小到大进行排序，使用 k指向上一次查询中不满足limit 要求的长度最小的边，显然初始时 k=0。
【并查集】：添加链接描述
【查】：给定一个查询时，我们可以遍历edgeList中的所有边，依次将长度小于 imit 的边加入到并查集中，然后使用并查集查询 p 和 q是否属于同一个集合。如果 p 和 q属于同一个集合，则说明存在从 p到 q的路径，且这条路径上的每一条边的长度都严格小于 limit，查询返回true，否则查询返回 false。
【并】：如果 queries 的limit 是非递减的，显然上一次查询的并查集里的边都是满足当前查询的limit 要求的，我们只需要将剩余的长度小于limit 的边加入并查集中即可。
我们依次遍历 queries：如果 k 指向的边的长度小于对应查询的limit，则将该边加入并查集中，然后将 k 加 1，直到 k 指向的边不满足要求；最后根据并查集查询对应的 p 和 q是否属于同一集合来保存查询的结果。
class Solution {
public boolean[] distanceLimitedPathsExist(int n, int[][] edgeList, int[][] queries) {
//将edgeList按照边长从小到大的顺序排序
Arrays.sort(edgeList, (o1, o2) -> (o1[2] - o2[2]));
//将queries按照limit从小到大的顺序排序
Integer[] index = new Integer[queries.length];
for (int i = 0; i < queries.length; i++) {
index[i] = i;
}
Arrays.sort(index, (a, b) -> queries[a][2] - queries[b][2]);
// 构造并查集：节点
int[] uf = new int[n];
for(int i = 0; i < n; i++){
uf[i] = i;
}
boolean[] re = new boolean[queries.length];
int k = 0;//标识目前指向哪个边
for(int i : index){
while(k < edgeList.length && edgeList[k][2] < queries[i][2]){
//合并
merge(uf, edgeList[k][0], edgeList[k][1]);
k++;
}
//查
re[i] = find(uf, queries[i][0]) == find(uf, queries[i][1]);
}
return re;
}
public int find(int[] uf, int x){
if(uf[x] == x) return x;
return uf[x] = find(uf, uf[x]);
}
public void merge(int[] uf, int x, int y){
x = find(uf, x);
y = find(uf, y);
uf[y] = x;
}
}
【leetcode hot 100】
题目描述
给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符
题目解析
【动态规划】：该题是动态规划的经典题目。
-
dp数据的含义
dp[i][j]表示使得word1[0 - i] 和 word2[0 - j]相同，所做操作的最少次数。 -
初始化
dp[0][j] = j，表示当word1为空，word2不为空时，需要进行j次添加操作。
dp[i][0] = i，表示当word2为空，word1不为空时，需要进行i次添加操作。 -
状态转移方程
dp[i][j] = dp[i - 1][j - 1]， 当word1[i] = word2[j]时
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1])) + 1
class Solution {
public int minDistance(String word1, String word2) {
if(word1.length() == 0) return word2.length();
if(word2.length() == 0) return word1.length();
char[] array1 = word1.toCharArray();
char[] array2 = word2.toCharArray();
int[][] dp = new int[word1.length() + 1][word2.length() + 1];
//初始化
for(int i = 1; i <= word1.length(); i++){
dp[i][0] = i;
}
for(int i = 1; i <= word2.length(); i++){
dp[0][i] = i;
}
for(int i = 1; i <= word1.length(); i++){
for(int j = 1; j <= word2.length(); j++){
if(array1[i - 1] == array2[j - 1]){
dp[i][j] = dp[i - 1][j - 1];
}else{
dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j], dp[i][j - 1])) + 1;
}
}
}
return dp[word1.length()][word2.length()];
}
}
【代码随想录】617. 合并二叉树
题目描述
给你两棵二叉树： root1 和 root2 。
想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。
返回合并后的二叉树。
题目解析
【递归】：使用树的先序遍历，将对应位置的节点相加。
class Solution {
public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
//递归
if(root1 == null) return root2;
if(root2 == null) return root1;
TreeNode new_head = new TreeNode(root1.val + root2.val);
new_head.left = mergeTrees(root1.left, root2.left);
new_head.right = mergeTrees(root1.right, root2.right);
return new_head;
}
}