文章目录
- [6462. 最小化字符串长度](https://leetcode.cn/problems/minimize-string-length/)
- 阅读理解
- [6424. 半有序排列](https://leetcode.cn/problems/semi-ordered-permutation/)
- 模拟
- [6472. 查询后矩阵的和](https://leetcode.cn/problems/sum-of-matrix-after-queries/)
- 倒序遍历（正难则反）
- [6396. 统计整数数目](https://leetcode.cn/problems/count-of-integers/)
- 数位DP
6462. 最小化字符串长度
难度中等3
给你一个下标从 0 开始的字符串 s ，重复执行下述操作 任意 次：
- 在字符串中选出一个下标
i，并使c为字符串下标i处的字符。并在i左侧（如果有）和 右侧（如果有）各 删除 一个距离i最近 的字符c。
请你通过执行上述操作任意次，使 s 的长度 最小化 。
返回一个表示 最小化 字符串的长度的整数。
示例 1：
输入：s = "aaabc"
输出：3
解释：在这个示例中，s 等于 "aaabc" 。我们可以选择位于下标 1 处的字符 'a' 开始。接着删除下标 1 左侧最近的那个 'a'（位于下标 0）以及下标 1 右侧最近的那个 'a'（位于下标 2）。执行操作后，字符串变为 "abc" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。
示例 2：
输入：s = "cbbd"
输出：3
解释：我们可以选择位于下标 1 处的字符 'b' 开始。下标 1 左侧不存在字符 'b' ，但右侧存在一个字符 'b'（位于下标 2），所以会删除位于下标 2 的字符 'b' 。执行操作后，字符串变为 "cbd" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 3 。
示例 3：
输入：s = "dddaaa"
输出：2
解释：我们可以选择位于下标 1 处的字符 'd' 开始。接着删除下标 1 左侧最近的那个 'd'（位于下标 0）以及下标 1 右侧最近的那个 'd'（位于下标 2）。执行操作后，字符串变为 "daaa" 。继续对新字符串执行操作，可以选择位于下标 2 的字符 'a' 。接着删除下标 2 左侧最近的那个 'a'（位于下标 1）以及下标 2 右侧最近的那个 'a'（位于下标 3）。执行操作后，字符串变为 "da" 。继续对字符串执行任何操作都不会改变其长度。因此，最小化字符串的长度是 2 。
提示：
1 <= s.length <= 100s仅由小写英文字母组成
阅读理解
统计字符串中出现的不同字符数
class Solution:
def minimizedStringLength(self, s: str) -> int:
c = Counter(s)
return len(c)
6424. 半有序排列
难度简单 0
给你一个下标从 0 开始、长度为 n 的整数排列 nums 。
如果排列的第一个数字等于 1 且最后一个数字等于 n ，则称其为 半有序排列 。你可以执行多次下述操作，直到将 nums 变成一个 半有序排列 ：
- 选择
nums中相邻的两个元素，然后交换它们。
返回使 nums 变成 半有序排列 所需的最小操作次数。
排列 是一个长度为 n 的整数序列，其中包含从 1 到 n 的每个数字恰好一次。
示例 1：
输入：nums = [2,1,4,3]
输出：2
解释：可以依次执行下述操作得到半有序排列：
1 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。
2 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。
可以证明，要让 nums 成为半有序排列，不存在执行操作少于 2 次的方案。
示例 2：
输入：nums = [2,4,1,3]
输出：3
解释：
可以依次执行下述操作得到半有序排列：
1 - 交换下标 1 和下标 2 对应元素。排列变为 [2,1,4,3] 。
2 - 交换下标 0 和下标 1 对应元素。排列变为 [1,2,4,3] 。
3 - 交换下标 2 和下标 3 对应元素。排列变为 [1,2,3,4] 。
可以证明，要让 nums 成为半有序排列，不存在执行操作少于 3 次的方案。
示例 3：
输入：nums = [1,3,4,2,5]
输出：0
解释：这个排列已经是一个半有序排列，无需执行任何操作。
提示：
2 <= nums.length == n <= 501 <= nums[i] <= 50nums是一个 排列
模拟
简单题，可以直接模拟，或者不需要进行元素的交换，找出最大值和最小值的位置，判断一下是否会交错，交错的话最后答案减一，不交错答案即 最小值到左端点 + 最大值到右端点 的长度
class Solution:
def semiOrderedPermutation(self, nums: List[int]) -> int:
ans = 0
mn, idx = inf, -1
for i, v in enumerate(nums):
if mn > v:
mn = v
idx = i
ans += idx
mx, idxm = -inf, -1
for i, v in enumerate(nums):
if mx < v:
mx = v
idxm = i
if idxm < idx:
ans += len(nums) - 1 - idxm - 1
else:
ans += len(nums) - 1 - idxm
return ans
6472. 查询后矩阵的和
难度中等10
给你一个整数 n 和一个下标从 0 开始的 二维数组 queries ，其中 queries[i] = [typei, indexi, vali] 。
一开始，给你一个下标从 0 开始的 n x n 矩阵，所有元素均为 0 。每一个查询，你需要执行以下操作之一：
- 如果
typei == 0，将第indexi行的元素全部修改为vali，覆盖任何之前的值。 - 如果
typei == 1，将第indexi列的元素全部修改为vali，覆盖任何之前的值。
请你执行完所有查询以后，返回矩阵中所有整数的和。
示例 1：
输入：n = 3, queries = [[0,0,1],[1,2,2],[0,2,3],[1,0,4]]
输出：23
解释：上图展示了每个查询以后矩阵的值。所有操作执行完以后，矩阵元素之和为 23 。
示例 2：
输入：n = 3, queries = [[0,0,4],[0,1,2],[1,0,1],[0,2,3],[1,2,1]]
输出：17
解释：上图展示了每一个查询操作之后的矩阵。所有操作执行完以后，矩阵元素之和为 17 。
提示：
1 <= n <= 1041 <= queries.length <= 5 * 104queries[i].length == 30 <= typei <= 10 <= indexi < n0 <= vali <= 105
倒序遍历（正难则反）
class Solution {
public long matrixSumQueries(int n, int[][] queries) {
// 正序不好做，考虑倒序
// 倒序遍历，记录下这次修改能影响下的 行数 和 列数， 每次修改后影响数 - 1
long ans = 0l;
// 记录一下当前行列有没有被修改过
int[] arrrow = new int[n];
int[] arrcol = new int[n];
// 这一次操作能影响的 行/列 数
int row = n, col = n;
for(int i = queries.length-1; i >= 0; i--){
int type = queries[i][0], index = queries[i][1], val = queries[i][2];
if(type == 0){ // 修改整行
if(arrrow[index] == 1)
continue; // 这一行已经被后面的操作修改过了
ans += (long)(val * row); // 答案 += val * 还能影响的行数
col -= 1; // 影响列数 - 1
arrrow[index] = 1;
}else{
if(arrcol[index] == 1)
continue;
ans += (long)(val * col);
row -= 1;
arrcol[index] = 1;
}
}
return ans;
}
}
6396. 统计整数数目
难度困难4
给你两个数字字符串 num1 和 num2 ，以及两个整数 max_sum 和 min_sum 。如果一个整数 x 满足以下条件，我们称它是一个好整数：
num1 <= x <= num2min_sum <= digit_sum(x) <= max_sum.
请你返回好整数的数目。答案可能很大，请返回答案对 109 + 7 取余后的结果。
注意，digit_sum(x) 表示 x 各位数字之和。
示例 1：
输入：num1 = "1", num2 = "12", min_num = 1, max_num = 8
输出：11
解释：总共有 11 个整数的数位和在 1 到 8 之间，分别是 1,2,3,4,5,6,7,8,10,11 和 12 。所以我们返回 11 。
示例 2：
输入：num1 = "1", num2 = "5", min_num = 1, max_num = 5
输出：5
解释：数位和在 1 到 5 之间的 5 个整数分别为 1,2,3,4 和 5 。所以我们返回 5 。
提示：
1 <= num1 <= num2 <= 10221 <= min_sum <= max_sum <= 400
数位DP
class Solution {
private static final int MOD = (int)1e9 + 7;
int min_sum, max_sum;
int[][] cache;
public int count(String num1, String num2, int min_sum, int max_sum) {
this.min_sum = min_sum;
this.max_sum = max_sum;
int m = num2.toCharArray().length;
cache = new int[m][max_sum + 1];
for(int i = 0; i < m; i++){
Arrays.fill(cache[i], -1);
}
char[] s2 = num2.toCharArray();
int a = dfs(0, 0, true, s2);
for(int i = 0; i < m; i++){
Arrays.fill(cache[i], -1);
}
char[] s1 = num1.toCharArray();
s1[s1.length - 1]--;
int b = dfs(0, 0, true, s1);
return (a - b + MOD) % MOD;
}
public int dfs(int i, int sum, boolean isLimit, char[] s){
if(i == s.length){
return sum >= min_sum ? 1 : 0;
}
if(!isLimit && cache[i][sum] >= 0) return cache[i][sum];
int res = 0;
int up = isLimit ? s[i] - '0' : 9;
for(int d = 0; d <= up; d++){
if((sum + d) <= max_sum)
res = (res + dfs(i+1, sum+d, isLimit & (d == up), s)) % MOD;
}
if(!isLimit) cache[i][sum] = res % MOD;
return res % MOD;
}
}
