链接：LeetCode
[Leetcode]2373. 矩阵中的局部最大值
给你一个大小为 n x n 的整数矩阵 grid 。
生成一个大小为 (n - 2) x (n - 2) 的整数矩阵 maxLocal ，并满足：
- maxLocal[i][j] 等于 grid 中以 i + 1 行和 j + 1 列为中心的 3 x 3 矩阵中的 最大值 。
换句话说，我们希望找出 grid 中每个 3 x 3 矩阵中的最大值。
返回生成的矩阵。
循环模拟即可。如果把 \(3\times 3\) 改成一个比较大的 \(h\times w\)， 构建二维单调队列求解即可。
class Solution {
public int arithmeticTriplets(int[] nums, int diff) {
int res = 0;
HashSet<Integer> set = new HashSet<>();
for(var num:nums) set.add(num);
for(var num:nums) {
if(set.contains(num+diff) && set.contains(num+2*diff)) {
res ++;
}
}
return res;
}
}
[Leetcode]2374. 边积分最高的节点
给你一个有向图，图中有 n 个节点，节点编号从 0 到 n - 1 ，其中每个节点都 恰有一条 出边。
图由一个下标从 0 开始、长度为 n 的整数数组 edges 表示，其中 edges[i] 表示存在一条从节点 i 到节点 edges[i] 的 有向 边。
节点 i 的 边积分 定义为：所有存在一条指向节点 i 的边的节点的 编号 总和。
返回 边积分 最高的节点。如果多个节点的 边积分 相同，返回编号 最小 的那个。
遍历，注意需要long类型。
class Solution {
public int edgeScore(int[] edges) {
int n = edges.length, res = 0;
long[] score = new long[n];
for(int i=0;i<n;++i) {
score[edges[i]] += i;
}
for(int i=0;i<n;++i) {
if(score[i] > score[res]) {
res = i;
}
}
return res;
}
}
[Leetcode]2375. 根据模式串构造最小数字
给你下标从 0 开始、长度为 n 的字符串 pattern ，它包含两种字符，'I' 表示 上升 ，'D' 表示 下降 。
你需要构造一个下标从 0 开始长度为 n + 1 的字符串，且它要满足以下条件：
- num 包含数字 '1' 到 '9' ，其中每个数字 至多 使用一次。
- 如果 pattern[i] == 'I' ，那么 num[i] < num[i + 1] 。
- 如果 pattern[i] == 'D' ，那么 num[i] > num[i + 1] 。
请你返回满足上述条件字典序 最小 的字符串 num。
贪心。先将数组按自然序列排列好，默认升序.接下来只需要处理降序情况，扫到一系列'D'，就把D系列中的数字逆排序。这里关键的是，之所以可以通过贪心策略来排序，是因为我们分组处理后，后面组的数据不影响前面的结果。如，'IIIDDID'，这里'IIIDD'是一组，已经可得'123654'后面无论是什么都不影响前面的最佳顺序。
class Solution {
public String smallestNumber(String pattern) {
int n = pattern.length();
String[] res = new String[n+1];
for(int i=0;i<n+1;i++) {
res[i] = "" + (char)('1'+i);
}
int i=0;
while(i<n) {
if(pattern.charAt(i) == 'I') {
i++;
} else {
int start_ind = i;
while(i<n && pattern.charAt(i) == 'D') {
i++;
}
reverseArray(res, start_ind, i);
}
}
return String.join("", res);
}
private void reverseArray(String[] list, int start, int end) {
while(start<=end) {
String tmp = list[end];
list[end] = list[start];
list[start] = tmp;
start ++;
end --;
}
}
}
[Leetcode] 2376. 统计特殊整数
如果一个正整数每一个数位都是 互不相同 的，我们称它是 特殊整数 。
给你一个 正 整数 n ，请你返回区间 [1, n] 之间特殊整数的数目。
数位DP。
将 \(n\) 转换成字符串 \(s\)，定义 \(f(i,\textit{mask}, \textit{isLimit},\textit{isNum})\) 表示构造从左往右第 \(i\) 位及其之后数位的合法方案数，其余参数的含义为：
- \(\textit{mask}\) 表示前面选过的数字集合，换句话说，第 \(i\) 位要选的数字不能在 \(\textit{mask}\) 中。
- \(\textit{isLimit}\) 表示当前是否受到了\(n\) 的约束。若为真，则第 \(i\) 位填入的数字至多为 \(s[i]\)，否则可以是 \(9\)。如果在受到约束的情况下填了 \(s[i]\)，那么后续填入的数字仍会受到 \(n\) 的约束。
- \(\textit{isNum}\) 表示 \(i\) 前面的数位是否填了数字。若为假，则当前位可以跳过（不填数字），或者要填入的数字至少为 \(1\)；若为真，则要填入的数字可以从 \(0\) 开始。
后面两个参数可适用于其它数位 DP 题目。
枚举要填入的数字，具体实现逻辑见代码。
下面代码中 只需要记忆化 \((i,\textit{mask})\) 这个状态，因为：
- 对于一个固定的 \((i,\textit{mask})\)，这个状态受到 \(\textit{isLimit}\) 或 \(\textit{isNum}\) 的约束在整个递归过程中至多会出现一次，没必要记忆化。
- 另外，如果只记忆化 \((i,\textit{mask})\)，\(\textit{dp}\) 数组的含义就变成在不受到约束时的合法方案数，所以要在 !isLimit && isNum 成立时才去记忆化。
class Solution {
int length;
int[][] dp;
String s;
public int countSpecialNumbers(int n) {
s = ""+n;
length = s.length();
dp = new int[length][1 << 10];
for (var i = 0; i < length; i++) Arrays.fill(dp[i], -1);
return dfs(0, 0, true, false);
}
public int dfs(int i, int mask, boolean isLimit, boolean isNum) {
if(i == length) return isNum ? 1 : 0;
if(!isLimit && isNum && dp[i][mask] >= 0) return dp[i][mask];
dp[i][mask] = 0;
if(!isNum) dp[i][mask] += dfs(i+1, mask, false, false);
int up = isLimit ? (int)(s.charAt(i)-'0') : 9;
int below = isNum ? 0 : 1;
for(int val = below; val<up+1; val++) {
if((mask & (1 << val)) == 0) dp[i][mask] += dfs(i+1, mask | (1<<val), isLimit && (val == up) ? true : false, true);
}
return dp[i][mask];
}
}
参考：LeetCode