LeetCode Weekly Contest 292
字符串中最大的 3 位相同数字
题目
给你一个字符串 num ，表示一个大整数。如果一个整数满足下述所有条件，则认为该整数是一个 优质整数 ：
该整数是 num 的一个长度为 3 的 子字符串 。
该整数由唯一一个数字重复 3 次组成。
以字符串形式返回 最大的优质整数 。如果不存在满足要求的整数，则返回一个空字符串 "" 。
注意：
子字符串 是字符串中的一个连续字符序列。
num 或优质整数中可能存在 前导零 。
示例 1：
输入：num = "6777133339"
输出："777"
解释：num 中存在两个优质整数："777" 和 "333" 。
"777" 是最大的那个，所以返回 "777" 。
示例 2：
输入：num = "2300019"
输出："000"
解释："000" 是唯一一个优质整数。
示例 3：
输入：num = "42352338"
输出：""
解释：不存在长度为 3 且仅由一个唯一数字组成的整数。因此，不存在优质整数。
提示：
3 <= num.length <= 1000
num 仅由数字（0 - 9）组成
思路
找最大的连续三位数字字符，也就可以从9开始向下遍历，如果字符串中包含了当前数字直接返回。
AC代码
点击查看代码
class Solution {
public String largestGoodInteger(String num) {
for(int i=9; i>=0; i--) {
String str = ""+i+i+i;
if( num.contains(str) ) {
return str;
}
}
return "";
}
}
统计值等于子树平均值的节点数
题目
给你一棵二叉树的根节点 root ，找出并返回满足要求的节点数，要求节点的值等于其 子树 中值的 平均值 。
注意：
n 个元素的平均值可以由 n 个元素 求和 然后再除以 n ，并 向下舍入 到最近的整数。
root 的 子树 由 root 和它的所有后代组成。
示例 1：
输入：root = [4,8,5,0,1,null,6]
输出：5
解释：
对值为 4 的节点：子树的平均值 (4 + 8 + 5 + 0 + 1 + 6) / 6 = 24 / 6 = 4 。
对值为 5 的节点：子树的平均值 (5 + 6) / 2 = 11 / 2 = 5 。
对值为 0 的节点：子树的平均值 0 / 1 = 0 。
对值为 1 的节点：子树的平均值 1 / 1 = 1 。
对值为 6 的节点：子树的平均值 6 / 1 = 6 。
示例 2：
输入：root = [1]
输出：1
解释：对值为 1 的节点：子树的平均值 1 / 1 = 1。
提示：
树中节点数目在范围 [1, 1000] 内
0 <= Node.val <= 1000
思路
比赛的时候没多想，直接按照题目意思暴力写了一版，没想到过了，还好数据比较范围比较小。总体思路其实就是遍历每个节点，分别求出当前节点下所有节点的总和以及节点个数，然后判断平均数是否等于当前值即可。
AC代码
点击查看代码
/**
* 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 cnt;
int num;
public int DFS(TreeNode root) {
if( root == null) {
return 0;
}
return root.val + DFS(root.left) + DFS(root.right);
}
public int countNode(TreeNode root) {
if( root == null) {
return 0;
}
return 1 + countNode(root.left) + countNode(root.right);
}
public void tttt(TreeNode root) {
if( root==null ) {
return ;
}
int sum = DFS(root);
int num = countNode(root);
// System.out.println("sum = " + sum + " num = " + num);
if( sum/num==root.val ) {
cnt ++;
}
tttt(root.left);
tttt(root.right);
}
public int averageOfSubtree(TreeNode root) {
cnt = 0;
tttt(root);
return cnt;
}
}
统计打字方案数
题目
Alice 在给 Bob 用手机打字。数字到字母的 对应 如下图所示。
为了 打出 一个字母，Alice 需要 按 对应字母 i 次，i 是该字母在这个按键上所处的位置。
比方说，为了按出字母 's' ，Alice 需要按 '7' 四次。类似的， Alice 需要按 '5' 两次得到字母 'k' 。
注意，数字 '0' 和 '1' 不映射到任何字母，所以 Alice 不 使用它们。
但是，由于传输的错误，Bob 没有收到 Alice 打字的字母信息，反而收到了 按键的字符串信息 。
比方说，Alice 发出的信息为 "bob" ，Bob 将收到字符串 "2266622" 。
给你一个字符串 pressedKeys ，表示 Bob 收到的字符串，请你返回 Alice 总共可能发出多少种文字信息 。
由于答案可能很大，将它对 109 + 7 取余 后返回。
示例 1：
输入：pressedKeys = "22233"
输出：8
解释：
Alice 可能发出的文字信息包括：
"aaadd", "abdd", "badd", "cdd", "aaae", "abe", "bae" 和 "ce" 。
由于总共有 8 种可能的信息，所以我们返回 8 。
示例 2：
输入：pressedKeys = "222222222222222222222222222222222222"
输出：82876089
解释：
总共有 2082876103 种 Alice 可能发出的文字信息。
由于我们需要将答案对 109 + 7 取余，所以我们返回 2082876103 % (109 + 7) = 82876089 。
提示：
1 <= pressedKeys.length <= 105
pressedKeys 只包含数字 '2' 到 '9' 。
思路
递推式，比赛的时候以为是公式，先跳过的，后面也没有时间看了。附上大佬的AC代码。
AC代码
点击查看代码
class Solution {
public int countTexts(String pressedKeys) {
int[] dp = new int[pressedKeys.length() + 1];
dp[0] = 1;
for (int i = 0; i < pressedKeys.length(); i++) {
for (int j = i; j >= 0 && j > i - ("79".contains("" + pressedKeys.charAt(i)) ? 4 : 3)
&& pressedKeys.charAt(j) == pressedKeys.charAt(i); j--) {
dp[i + 1] = (dp[i + 1] + dp[j]) % 1000000007;
}
}
return dp[pressedKeys.length()];
}
}
检查是否有合法括号字符串路径
题目
一个括号字符串是一个 非空 且只包含 '(' 和 ')' 的字符串。如果下面 任意 条件为 真 ，那么这个括号字符串就是 合法的 。
字符串是 () 。
字符串可以表示为 AB（A 连接 B），A 和 B 都是合法括号序列。
字符串可以表示为 (A) ，其中 A 是合法括号序列。
给你一个 m x n 的括号网格图矩阵 grid 。网格图中一个 合法括号路径 是满足以下所有条件的一条路径：
路径开始于左上角格子 (0, 0) 。
路径结束于右下角格子 (m - 1, n - 1) 。
路径每次只会向 下 或者向 右 移动。
路径经过的格子组成的括号字符串是 合法 的。
如果网格图中存在一条 合法括号路径 ，请返回 true ，否则返回 false 。
示例 1：
输入：grid = [["(","(","("],[")","(",")"],["(","(",")"],["(","(",")"]]
输出：true
解释：上图展示了两条路径，它们都是合法括号字符串路径。
第一条路径得到的合法字符串是 "()(())" 。
第二条路径得到的合法字符串是 "((()))" 。
注意可能有其他的合法括号字符串路径。
示例 2：
输入：grid = [[")",")"],["(","("]]
输出：false
解释：两条可行路径分别得到 "))(" 和 ")((" 。由于它们都不是合法括号字符串，我们返回 false 。
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 100
grid[i][j] 要么是 '(' ，要么是 ')' 。
思路
DFS
普通的暴力搜索肯定会超时，那就可以做一个记忆化的搜索，记录下之前已经搜素过的状态，减少重复搜索。故定义了一个三维Boolean数组 vis，vis[i][j][left]表示(i,j)这个位置在左括号=left个的时候已经进行过搜索了。
DP
其实就是将上面的记忆化搜索的思路转化成DP数组就可以，AC代码是贴的大佬的AC代码。
AC代码
DFS
点击查看代码
class Solution {
int[] dr = new int[]{0, 1};
int[] dc = new int[]{1, 0};
boolean[][][] vis;
int n;
int m;
public boolean DFS(char[][] grid, int row, int col, int left) {
// 看大佬的题解新加的剪枝，加了后快了5ms
if (left > m - row + n - col - 1) {
return false;
}
if( row>=m || col>=n ) {
return false;
}
if( vis[row][col][left] ) {
return false;
}
vis[row][col][left] = true;
left += ( grid[row][col]=='(' ? 1:-1);
if( row==m-1 && col==n-1 ) {
return left==0;
}
return left>=0 && (DFS(grid, row+1, col, left) || DFS(grid, row, col+1, left));
}
public boolean hasValidPath(char[][] grid) {
m = grid.length;
if( m == 0 ) {
return false;
}
n = grid[0].length;
vis = new boolean[m][n][n+m];
return DFS(grid, 0, 0, 0);
}
}
DP
点击查看代码
class Solution {
public boolean hasValidPath(char[][] grid) {
boolean[][][] dp = new boolean[grid.length + 1][grid[0].length + 1][103];
dp[0][0][1] = true;
for (int i = 0; i < grid.length; i++) {
for (int j = 0; j < grid[0].length; j++) {
for (int k = 1; k <= 101; k++) {
dp[i][j + 1][k] |= dp[i][j][k + (grid[i][j] == '(' ? -1 : 1)];
dp[i + 1][j][k] |= dp[i][j][k + (grid[i][j] == '(' ? -1 : 1)];
}
}
}
return dp[grid.length - 1][grid[0].length][1];
}
}
