LeetCode 第250场周赛（分情况dp，离线查询，01字典树）
第250场周赛
将近700名，还是两道的水平，第三道想了一个多小时没想出来…难受，还是菜
5161. 可以输入的最大单词数
题目描述
键盘出现了一些故障，有些字母键无法正常工作。而键盘上所有其他键都能够正常工作。
给你一个由若干单词组成的字符串 text ，单词间由单个空格组成（不含前导和尾随空格）；另有一个字符串 brokenLetters ，由所有已损坏的不同字母键组成，返回你可以使用此键盘完全输入的 text 中单词的数目。
示例 1：
输入：text = “hello world”, brokenLetters = “ad”
输出：1
解释：无法输入 “world” ，因为字母键 ‘d’ 已损坏。
示例 2：
输入：text = “leet code”, brokenLetters = “lt”
输出：1
解释：无法输入 “leet” ，因为字母键 ‘l’ 和 ‘t’ 已损坏。
示例 3：
输入：text = “leet code”, brokenLetters = “e”
输出：0
解释：无法输入任何单词，因为字母键 ‘e’ 已损坏。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-words-you-can-type
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
先用一个哈希表存储坏了的字母，然后查看每个单词中是否有这个字母
class Solution {
public int canBeTypedWords(String text, String brokenLetters) {
String[] ss = text.split(" ");
int l = ss.length;
int res = 0;
boolean[] used = new boolean[26];
for(int i = 0; i < brokenLetters.length(); i++){
used[brokenLetters.charAt(i) - 'a'] = true;
}
for(int i = 0; i < l; i++){
String s = ss[i];
boolean flag = true;
for(int j = 0; j < s.length(); j++){
if(used[s.charAt(j) - 'a']){
flag = false;
break;
}
}
if(flag)
res++;
}
return res;
}
}
5814. 新增的最少台阶数
题目描述
给你一个 严格递增 的整数数组 rungs ，用于表示梯子上每一台阶的 高度 。当前你正站在高度为 0 的地板上，并打算爬到最后一个台阶。
另给你一个整数 dist 。每次移动中，你可以到达下一个距离你当前位置（地板或台阶）不超过 dist 高度的台阶。当然，你也可以在任何正 整数 高度处插入尚不存在的新台阶。
返回爬到最后一阶时必须添加到梯子上的 最少 台阶数。
示例 1：
输入：rungs = [1,3,5,10], dist = 2
输出：2
解释：
现在无法到达最后一阶。
在高度为 7 和 8 的位置增设新的台阶，以爬上梯子。
梯子在高度为 [1,3,5,7,8,10] 的位置上有台阶。
示例 2：
输入：rungs = [3,6,8,10], dist = 3
输出：0
解释：
这个梯子无需增设新台阶也可以爬上去。
示例 3：
输入：rungs = [3,4,6,7], dist = 2
输出：1
解释：
现在无法从地板到达梯子的第一阶。
在高度为 1 的位置增设新的台阶，以爬上梯子。
梯子在高度为 [1,3,4,6,7] 的位置上有台阶。
示例 4：
输入：rungs = [5], dist = 10
输出：0
解释：这个梯子无需增设新台阶也可以爬上去。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-minimum-number-of-rungs
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
看到以后，第一反应，如果两个台阶高度相差大于dist就需要加台阶，然后就看加多少个台阶，恰好等于不要加，也可以用diff - 1来当被除数代替分情况讨论
为什么
class Solution {
public int addRungs(int[] rungs, int dist) {
int res = 0;
int pre = 0;
int l = rungs.length;
for(int i = 0; i < l; i++){
int temp = rungs[i];
int diff = temp - pre;
int t = diff / dist;
if(t * dist == diff)
res += t - 1;
else
res += t;
pre = temp;
}
return res;
}
}
5815. 扣分后的最大得分（dp）
给你一个 m x n 的整数矩阵 points （下标从 0 开始）。一开始你的得分为 0 ，你想最大化从矩阵中得到的分数。
你的得分方式为：每一行 中选取一个格子，选中坐标为 (r, c) 的格子会给你的总得分 增加 points[r][c] 。
然而，相邻行之间被选中的格子如果隔得太远，你会失去一些得分。对于相邻行 r 和 r + 1 （其中 0 <= r < m - 1），选中坐标为 (r, c1) 和 (r + 1, c2) 的格子，你的总得分 减少 abs(c1 - c2) 。
请你返回你能得到的 最大 得分。
abs(x) 定义为：
如果 x >= 0 ，那么值为 x 。
如果 x < 0 ，那么值为 -x 。
示例 1：
输入：points = [[1,2,3],[1,5,1],[3,1,1]]
输出：9
解释：
蓝色格子是最优方案选中的格子，坐标分别为 (0, 2)，(1, 1) 和 (2, 0) 。
你的总得分增加 3 + 5 + 3 = 11 。
但是你的总得分需要扣除 abs(2 - 1) + abs(1 - 0) = 2 。
你的最终得分为 11 - 2 = 9 。
示例 2：
输入：points = [[1,5],[2,3],[4,2]]
输出：11
解释：
蓝色格子是最优方案选中的格子，坐标分别为 (0, 1)，(1, 1) 和 (2, 0) 。
你的总得分增加 5 + 3 + 4 = 12 。
但是你的总得分需要扣除 abs(1 - 1) + abs(1 - 0) = 1 。
你的最终得分为 12 - 1 = 11 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-number-of-points-with-cost
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
写了个暴力解法，然后不出意外超时了，就卡在最后一个用例上。做题的时候刚开始还头脑清晰，后面越想脑子越乱
一直在想一个问题，就是知道了上一行每一个位置对应的最大值，那么下一行的最大值该怎么求
然后很自然的想到是否能利用到前面的值，因为很显然看时间复杂度，最多只能有两层循环。
然后冥冥中感觉是这样做，但是就是想不明白，比赛完看第五名大佬的写法（因为是java的），发现从左到右一次，从右到左一次，还是没看明白。。
看了一下赞多的解答，醍醐灌顶
暴力解法对应的转移方程如下（max是遍历上一行所有值的max）
dp[i][j] = point[i][j] + max(dp[i - 1][k] + |j - k|)
然后将绝对值符号去掉的话，可以得到：
dp[i][j] = if k < j, point[i][j] + max(dp[i - 1][k] + j - k) else if k >= j, point[i][j] + max(dp[i - 1][k] + k - j)
然后将 j 提出来
dp[i][j] = if k < j, point[i][j] + j + max(dp[i - 1][k] - k) else if k >= j, point[i][j] - j + max(dp[i - 1][k] + k)
这样写了以后，对于当前位置 j ，需要知道它左边部分的最大值，那就从左到右遍历，此时 k 是小于 j 的，记录一个当前的最大值，存储在一个数组中，然后就能在O(n)的求出每个位置前半部分的值
然后再从右向左遍历，记录后半部分的值
最后，dp[i][j] 的值根据式子，就可以求出来了
暴力解
class Solution {
public long maxPoints(int[][] points) {
int m = points.length;
int n = points[0].length;
long[] row = new long[n];
for(int i = 0; i < n; i++){
row[i] = points[0][i];
}
//优化
for(int i = 1; i < m; i++){
long[] te = Arrays.copyOf(row, n);
for(int j = 0; j < n; j++){
for(int k = 0; k < n; k++){
row[j] = Math.max(row[j], te[k] + points[i][j] - Math.abs(k - j));
}
}
}
long res = 0;
for(int i = 0; i < n; i++){
res = Math.max(res, row[i]);
}
return res;
}
}
根据我的理解写一下代码：
写出来一个这样的代码，关键点还是在left和right数组的计算。
这里是什么意思呢，比如left数组，求的是 max(dp[i - 1][k] + j - k)，当前位置的最大值就是之前之前的最大值减1和当前位置值相比较，为什么要减1呢，因为每向右移动一位，那么leftmax必然会少1
同理right数组也是这样求出来的
求出这两个数组以后，当前位置左边的最大值和右边的最大值就知道了，然后再取个最大就是当前位置的值dp[i][j]
class Solution {
public long maxPoints(int[][] points) {
int m = points.length;
int n = points[0].length;
long[][] dp = new long[m][n];
//初始化
for(int i = 0; i < n; i++){
dp[0][i] = points[0][i];
}
//状态转移
for(int i = 1; i < m; i++){
//从左到右，k < j，求 max(dp[i - 1][k] + j - k)
long leftmax = Long.MIN_VALUE + 1;
long[] left = new long[n];
for(int j = 0; j < n; j++){
//每次向右移动，都要leftmax都要减1，然后和当前正下方的值相比较
leftmax = Math.max(leftmax - 1, dp[i - 1][j]);
left[j] = leftmax;
}
//从右向左，求 max(dp[i - 1][k] + k - j)
long rightmax = Long.MIN_VALUE + 1;
long[] right = new long[n];
for(int j = n - 1; j >= 0; j--){
//每次向左移动，都要rightmax都要减1，然后和当前正下方的值相比较
rightmax = Math.max(rightmax - 1, dp[i - 1][j]);
right[j] = rightmax;
}
for(int j = 0; j < n; j++){
dp[i][j] = Math.max(left[j], right[j]) + points[i][j];
}
}
long res = 0;
for(int i = 0; i < n; i++){
res = Math.max(res, dp[m - 1][i]);
}
return res;
//直接转换成流的形式
// return Arrays.stream(dp).max().getAsLong();
}
}
最后想想这道题到底有什么样的启发，这种动态规划第一次见。首先，根据绝对值，把情况分成两种。当看到k= < j 和 k >= j 时，就可以比较容易的想到从两边分别遍历，求出两边的最大值，然后再对两个最大值求最大
能得到的启发就是遇到这种分情况的问题，要拆分来考虑，分成子问题以后，往往能够得到简化
最后，因为最近看了stream的知识， 学习一下stream的用法
421. 数组中两个数的最大异或值（字典树）
由于最后一题的需要，这里先看一下这道题
题目描述
给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
进阶：你可以在 O(n) 的时间解决这个问题吗？
示例 1：
输入：nums = [3,10,5,25,2,8]
输出：28
解释：最大运算结果是 5 XOR 25 = 28.
示例 2：
输入：nums = [0]
输出：0
示例 3：
输入：nums = [2,4]
输出：6
示例 4：
输入：nums = [8,10,2]
输出：10
示例 5：
输入：nums = [14,70,53,83,49,91,36,80,92,51,66,70]
输出：127
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-xor-of-two-numbers-in-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
有一天的每日一题，用字典树做
求异或值，可以将一个数表示成31个二进制位的形式，然后根据数组中的所有数，每一位是0或者1，构建一个字典树。
然后怎么求两个数的最大异或值呢，已知一个数为t，就是从根节点开始往下进行选择，如果存在和t当前位相反的节点，那么就走这个节点，不存在就走同样的节点。最后走到树的叶子部分，得到的值就是异或能得到的最大值
在具体实现过程中，没有必要先构建树，可以边遍历边构建字典树，然后记录当前的最大值
自己再写一遍，加深印象：
class Solution {
Trie trie = new Trie();
public int findMaximumXOR(int[] nums) {
int l = nums.length;
int res = 0;
for(int i = 1; i < l; i++){
//把前一个节点加到字典树中
add(nums[i - 1]);
int t = check(nums[i]);
res = Math.max(res, t);
}
return res;
}
public void add(int num){
Trie temp = trie;
for(int i = 30; i >= 0; i--){
int t = ((num >> i) & 1);
if(t == 0){
if(temp.left == null){
temp.left = new Trie();
}
temp = temp.left;
}else{
if(temp.right == null){
temp.right = new Trie();
}
temp = temp.right;
}
}
}
public int check(int num){
Trie temp = trie;
int ret = 0;
for(int i = 30; i >= 0; i--){
int t = ((num >> i) & 1);
if(t == 0){
if(temp.right == null){
temp = temp.left;
ret = (ret << 1) + 0;
}else{
temp = temp.right;
ret = (ret << 1) + 1;
}
}else{
if(temp.left == null){
temp = temp.right;
ret = (ret << 1) + 0;
}else{
temp = temp.left;
ret = (ret << 1) + 1;
}
}
}
return ret;
}
}
class Trie{
Trie left;
Trie right;
}
5816. 查询最大基因差（字典树+离线查询）
题目描述
给你一棵 n 个节点的有根树，节点编号从 0 到 n - 1 。每个节点的编号表示这个节点的 独一无二的基因值 （也就是说节点 x 的基因值为 x）。两个基因值的 基因差 是两者的 异或和 。给你整数数组 parents ，其中 parents[i] 是节点 i 的父节点。如果节点 x 是树的 根 ，那么 parents[x] == -1 。
给你查询数组 queries ，其中 queries[i] = [nodei, vali] 。对于查询 i ，请你找到 vali 和 pi 的 最大基因差 ，其中 pi 是节点 nodei 到根之间的任意节点（包含 nodei 和根节点）。更正式的，你想要最大化 vali XOR pi 。
请你返回数组 ans ，其中 ans[i] 是第 i 个查询的答案。
示例 1：
输入：parents = [-1,0,1,1], queries = [[0,2],[3,2],[2,5]]
输出：[2,3,7]
解释：查询数组处理如下：
- [0,2]：最大基因差的对应节点为 0 ，基因差为 2 XOR 0 = 2 。
- [3,2]：最大基因差的对应节点为 1 ，基因差为 2 XOR 1 = 3 。
- [2,5]：最大基因差的对应节点为 2 ，基因差为 5 XOR 2 = 7 。
示例 2：
输入：parents = [3,7,-1,2,0,7,0,2], queries = [[4,6],[1,15],[0,5]]
输出：[6,14,7]
解释：查询数组处理如下：
- [4,6]：最大基因差的对应节点为 0 ，基因差为 6 XOR 0 = 6 。
- [1,15]：最大基因差的对应节点为 1 ，基因差为 15 XOR 1 = 14 。
- [0,5]：最大基因差的对应节点为 2 ，基因差为 5 XOR 2 = 7 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-genetic-difference-query
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
看了下题，然后很自然想到暴力解法，对于要查找的节点，一直向上找，直到根节点，然后求每个节点的异或值的最大者。很显然会超时，不过还是写一下：
class Solution {
public int[] maxGeneticDifference(int[] parents, int[][] queries) {
//暴力
int n = queries.length;
int[] res = new int[n];
//对于每个查询
for(int i = 0; i < n; i++){
int node = queries[i][0];
int val = queries[i][1];
int max = 0;
do{
max = Math.max(max, node ^ val);
node = parents[node];
}while(node != -1);
res[i] = max;
}
return res;
}
}
然后想优化，求两个数最大的异或值，之前每日一题专项训练异或那几天出过
复习过后，再来想这个问题
首先构建字典树，首先将根节点node 的值 i 放在字典树中，然后看有没有点 i 的询问，并处理
然后dfs建树，如果处理完了node的所有子树以后，再将 i 从字典树中删除
为啥要这样做呢，这样做可以保证，当处理到当前节点node时，字典树中只有从根节点root到当前节点node的所有值
根据这个思路，来写一下代码
注意这里的节点删除操作，是在Trie中加了一个成员变量count，定义这个节点出现的次数，如果出现次数为0的话，就相当于删除了这个节点
然后对两个给定的数组，都需要用哈希表预处理，方便查询，否则超时
class Solution {
class Trie{
Trie left;
Trie right;
//考虑到删除操作，就是将这个节点的使用次数-1
int count;
}
Trie trie = new Trie();
int[] parents;
int[][] queries;
int[] res;
Map<Integer, List<Integer>> map = new HashMap<>();
Map<Integer, List<Integer>> node = new HashMap<>();
public int[] maxGeneticDifference(int[] parents, int[][] queries) {
this.parents = parents;
this.queries = queries;
int l = parents.length;
int n = queries.length;
for(int i = 0; i < l; i++){
int val = parents[i];
List<Integer> list = node.getOrDefault(val, new ArrayList<>());
list.add(i);
node.put(val, list);
}
//System.out.println(node.get(0));
for(int i = 0; i < queries.length; i++){
int key = queries[i][0];
int val = queries[i][1];
List<Integer> list = map.getOrDefault(key, new ArrayList<>());
list.add(i);
map.put(key, list);
}
res = new int[n];
//对于每个查询
dfs(-1);
return res;
}
public void dfs(int val){
//先找到当前根节点的子节点
List<Integer> child = node.getOrDefault(val, new ArrayList<>());
//对于每一个子节点
for(int t : child){
//加到字典树中
add(t);
//如果有当前节点的查询
List<Integer> list = map.getOrDefault(t, new ArrayList<>());
for(int j = 0; j < list.size(); j++){
int index = list.get(j);
res[index] = check(queries[index][1]);
}
//然后递归，把子节点加入字典树中
dfs(t);
delete(t);
}
}
public void add(int t){
Trie temp = trie;
temp.count++;
//因为最大2*10^5
for(int i = 17; i >= 0; i--){
int cur = ((t >> i) & 1);
if(cur == 0){
if(temp.left == null)
temp.left = new Trie();
temp = temp.left;
temp.count++;
}else{
if(temp.right == null)
temp.right = new Trie();
temp = temp.right;
temp.count++;
}
}
}
public void delete(int t){
Trie temp = trie;
temp.count--;
//因为最大2*10^5
for(int i = 17; i >= 0; i--){
int cur = ((t >> i) & 1);
if(cur == 0){
temp = temp.left;
temp.count--;
}else{
temp = temp.right;
temp.count--;
}
}
}
public int check(int val){
Trie temp = trie;
int ret = 0;
for(int i = 17; i >= 0; i--){
int cur = ((val >> i) & 1);
if(cur == 0){
if(temp.right == null || temp.right.count == 0){
temp = temp.left;
ret = (ret << 1) + 0;
}else{
temp = temp.right;
ret = (ret << 1) + 1;
}
}else{
if(temp.left == null || temp.left.count == 0){
temp = temp.right;
ret = (ret << 1) + 0;
}else{
temp = temp.left;
ret = (ret << 1) + 1;
}
}
}
return ret;
}
}
这个代码基本上算是一次写成吧，还挺开心的，明显感觉编码能力增强了许多
另外，这个题的还有另一种方法，可持久化字典树+在线查询
什么意思呢，我的理解是这样的，在线查询就是需要能够同时查询多个结果，那么就需要建立持久化的字典树，所以就需要建立出根节点到每一个节点范围内的对应的字典树，然后利用这些字典树进行在线查询。
那么怎么建立这个树呢，除了暴力法，还可以想到的方法就是，每次如果只增加一个数或者减少一个数的时候，并不需要重新建立整个字典树，而是只需要修改字典树中K个节点，就可以得到新状态对应的字典树。先看个思想，具体有题再看吧，今天已经学到很多了