ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

[Leetcode Weekly Contest]292

2022-06-16 10:02:21  阅读:157  来源: 互联网

标签:TreeNode val Contest int root 括号 字符串 292 Leetcode


链接: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];
    }
}

标签:TreeNode,val,Contest,int,root,括号,字符串,292,Leetcode
来源: https://www.cnblogs.com/hellojamest/p/16380880.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有