链接：LeetCode
[Leetcode]2264. 字符串中最大的 3 位相同数字
给你一个字符串 num ，表示一个大整数。如果一个整数满足下述所有条件，则认为该整数是一个 优质整数 ：
- 该整数是 num 的一个长度为 3 的 子字符串 。
- 该整数由唯一一个数字重复 3 次组成。
以字符串形式返回 最大的优质整数 。如果不存在满足要求的整数，则返回一个空字符串 "" 。
注意：
- 子字符串 是字符串中的一个连续字符序列。
- num 或优质整数中可能存在 前导零 。
遍历即可。
class Solution {
public String largestGoodInteger(String num) {
char cur = 'N';
char pre = 'N';
int n = 0;
for(char ch:num.toCharArray()) {
if(cur != 'N' && ch < cur){
n = 0;
pre = 'N';
continue;
}
else {
if(ch == pre) n ++;
else n = 1;
if(n == 3) cur = ch;
pre = ch;
}
}
if(cur == 'N') return "";
return ""+cur+cur+cur;
}
}
[Leetcode]2265. 统计值等于子树平均值的节点数
给你一棵二叉树的根节点 root ，找出并返回满足要求的节点数，要求节点的值等于其 子树 中值的 平均值 。
注意：
- n 个元素的平均值可以由 n 个元素 求和 然后再除以 n ，并 向下舍入 到最近的整数。
- root 的 子树 由 root 和它的所有后代组成。
dfs 保存总和、节点数量, 自底向上递归。
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
int res = 0;
public int averageOfSubtree(TreeNode root) {
dfs(root);
return res;
}
public int[] dfs(TreeNode root) {
if(root.left == null && root.right == null) {
res++;
return new int[]{ root.val, 1};
}
int[] leftRes = new int[2];
int[] rightRes = new int[2];
if(root.left!=null) leftRes = dfs(root.left);
if(root.right!=null) rightRes = dfs(root.right);
int curSum = root.val + leftRes[0] + rightRes[0];
int curCount = 1 + leftRes[1] + rightRes[1];
if(curSum / curCount == root.val) res ++;
return new int[]{curSum, curCount};
}
}
[Leetcode]2266. 统计打字方案数
Alice 在给 Bob 用手机打字。
为了 打出 一个字母，Alice 需要 按 对应字母 i 次，i 是该字母在这个按键上所处的位置。
- 比方说，为了按出字母 's' ，Alice 需要按 '7' 四次。类似的， Alice 需要按 '5' 两次得到字母 'k' 。
- 注意，数字 '0' 和 '1' 不映射到任何字母，所以 Alice 不 使用它们。
但是，由于传输的错误，Bob 没有收到 Alice 打字的字母信息，反而收到了 按键的字符串信息 。
- 比方说，Alice 发出的信息为 "bob" ，Bob 将收到字符串 "2266622" 。
给你一个字符串 pressedKeys ，表示 Bob 收到的字符串，请你返回 Alice 总共可能发出多少种文字信息 。由于答案可能很大，将它对 \(10^9 + 7\) 取余 后返回。
动态规划。把相同字符分为一组，每组内只有一种字符，考虑如下 DP：
对于字符不为 \(\texttt{7}\) 或 \(\texttt{9}\) 的情况，定义 \(f[i]\) 表示长为 \(i\) 的只有一种字符的字符串对应的文字信息种类数，我们可以将末尾的 1 个、2 个或 3 个字符单独视作一个字母，那么有转移方程
\(f[i] = f[i-1]+f[i-2]+f[i-3]\)
对于字符为 \(\texttt{7}\) 或 \(\texttt{9}\) 的情况，定义 \(g[i]\) 表示长为 i 的只有一种字符的字符串对应的文字信息种类数，可以得到类似的转移方程
\(g[i] = g[i-1]+g[i-2]+g[i-3]+g[i-4]\)
这样能算出每组字符串的文字信息种类数。
class Solution {
public int countTexts(String pressedKeys) {
int MOD = (int)Math.pow(10,9) + 7;
int n = pressedKeys.length();
long[] dp = new long[n];
dp[0] = 1;
for(int i = 1; i < n; ++i) {
dp[i] = dp[i-1];
int j = 3;
if(pressedKeys.charAt(i) == '7' ||pressedKeys.charAt(i) == '9') j = 4;
for(int k = 1; k < j;++k) {
if(i-k >=0 && pressedKeys.charAt(i) == pressedKeys.charAt(i-k))
if (i-k-1>=0) dp[i] += dp[i-k-1]%MOD;
else dp[i] += 1;
else break;
}
}
return (int)(dp[n-1]%MOD);
}
}
[Leetcode]2267. 检查是否有合法括号字符串路径
一个括号字符串是一个 非空 且只包含 '(' 和 ')' 的字符串。如果下面 任意 条件为 真 ，那么这个括号字符串就是 合法的 。
字符串是 () 。
字符串可以表示为 AB（A 连接 B），A 和 B 都是合法括号序列。
字符串可以表示为 (A) ，其中 A 是合法括号序列。
给你一个 m x n 的括号网格图矩阵 grid 。网格图中一个 合法括号路径 是满足以下所有条件的一条路径：
路径开始于左上角格子 (0, 0) 。
路径结束于右下角格子 (m - 1, n - 1) 。
路径每次只会向 下 或者向 右 移动。
路径经过的格子组成的括号字符串是 合法 的。
如果网格图中存在一条 合法括号路径 ，请返回 true ，否则返回 false 。
动态规划。判断一个括号序列是否合法是经典问题。对于一个括号序列，我们从左向右遍历每个字符，同时维护变量 now（初值为 0）。遇到左括号时，now += 1，遇到右括号时，now -= 1。如果过程中 now 始终非负，且最后 now 变成 0 则序列合法。
class Solution {
// DP
public boolean hasValidPath(char[][] grid) {
int n = grid.length, m = grid[0].length;
if(((n+m) & 1) == 0) return false;
if(grid[0][0]!='(' || grid[n-1][m-1]!=')') return false;
int k = (n+m+1) / 2;
boolean[][][] dp = new boolean[n][m][k+2];
for(int i=0;i<n;++i) {
for(int j=0;j<m;++j) {
if(i == 0 && j == 0) {
dp[0][0][1] = true;
continue;
}
for(int kk=0;kk<=k+1;++kk) {
if(grid[i][j] == '(') {
if(kk==0) continue;
if(i==0) dp[i][j][kk] = dp[i][j-1][kk-1];
else if(j == 0) dp[i][j][kk] = dp[i-1][j][kk-1];
else dp[i][j][kk] = dp[i][j-1][kk-1] || dp[i-1][j][kk-1];
}
else {
if(kk==k+1) continue;
if(i==0) dp[i][j][kk] = dp[i][j-1][kk+1];
else if(j == 0) dp[i][j][kk] = dp[i-1][j][kk+1];
else dp[i][j][kk] = dp[i][j-1][kk+1] || dp[i-1][j][kk+1];
}
}
}
}
return dp[n-1][m-1][0];
}
}