leetcode 第 292 场周赛-CSDN博客

本文链接：https://blog.csdn.net/Shmilysw/article/details/124647890

这篇博客介绍了如何解决LeetCode上的两个编程问题：一是找出字符串中连续的最大三位数，二是计算二叉树中节点值等于子树平均值的节点数量。博主分享了高效和简洁的解决方案，并提供了详细的代码实现，包括弱鸡代码和大佬代码的对比。此外，还提到了一个统计打字方案数的问题，以及检查括号字符串路径是否合法的算法。

摘要由CSDN通过智能技术生成

字符串中最大的 3 位相同数字

https://leetcode-cn.com/problems/largest-3-same-digit-number-in-string/

class Solution {
public:
    string largestGoodInteger(string n) {
        int len = n.size();
        string ans = "";
        for (int i = 0; i < len - 2 ; i ++ ){
            if (n[i] == n[i + 1] && n[i + 1] == n[i + 2]){
                string tmp = "";
                tmp += n[i];
                tmp += n[i + 1];
                tmp += n[i + 2];
                ans = max(ans, tmp);
            }
        }
        return ans;
    }
};

统计值等于子树平均值的节点数

https://leetcode-cn.com/problems/count-nodes-equal-to-average-of-subtree/
大佬代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int res = 0;
    // pair中f表示这个根有多少个子节点，s表示所有字节点的权值和
    pair<int,int> dfs(TreeNode* root){
        int x = 1, y = root->val;
        if (root->left){
            auto t = dfs(root->left);
            x += t.first, y += t.second;
        }
        if (root->right){
            auto t = dfs(root->right);
            x += t.first, y += t.second;
        }
        if (y / x == root->val){
            res ++ ;
        }
        return {x,y};
    }
    int averageOfSubtree(TreeNode* root) {
        dfs(root);
        return res;
    }
};

弱鸡代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int count(TreeNode* root){
        if (root == NULL) return 0;
        return count(root->left) + count(root->right) + 1;
    }
    int val(TreeNode* root){
        if (root == NULL) return 0;
        return root->val + val(root->left) + val(root->right);
        
    }
    int avg(TreeNode* root){
        if (root == NULL) return 0;
        int n = count(root);
        int m = val(root);
        return m/n == root->val? 1:0;
    }
    int avgg(TreeNode* root){
        if (root == NULL) return 0;
        return avg(root->left) + avg(root->right) + avgg(root->left) + avgg(root->right); 
    }
    int averageOfSubtree(TreeNode* root) {
        int tmp = avgg(root);
        int tmpp = avg(root);
        return tmp + tmpp;
    }
};

统计打字方案数

https://leetcode-cn.com/problems/count-number-of-texts/
思路：预处理一下，字符串长度对应的变化情况，然后就是把字符串分成各个部分，最后乘起来，就是最后的答案，（本弱鸡不会预处理）。
代码：

class Solution {
public:
    typedef long long LL;
    int f[100001], v[100001];
    int MOD = 1000000007;
    int countTexts(string s) {
        f[0] = 1; // f[i]表示长度为i的串，一共的情况
        for (int i = 0; i < 100000 ; i ++ )
            for (int j = i + 1; j <= i + 3 && j <= 100000 ; j ++ )
                f[j] += f[i], f[j] %= MOD;
        v[0] = 1;
        for (int i = 0; i < 100000; i++)
            for (int j = i + 1; j <= i + 4 && j <= 100000 ; j ++ )
                v[j] += v[i], v[j] %= MOD;
        int n = s.size();
        int x = 0, y = 0;
        LL ans = 1;
        for (int i = 0; i < n ; i ++ ){
            if (y != s[i]){
                if (y == '7' || y == '9'){
                    ans *= v[x], ans %= MOD;
                }
                else{
                    ans *= f[x], ans %= MOD;
                }
                x = 0;
                y = s[i];
            }
            x ++ ;
        }//处理最后一段
        if (y == '7' || y == '9'){
            ans *= v[x], ans %= MOD;
        }
        else{
            ans *= f[x], ans %= MOD;
        }
        return ans;
    }
};

检查是否有合法括号字符串路径

https://leetcode-cn.com/problems/check-if-there-is-a-valid-parentheses-string-path/
思路：请添加图片描述
代码：

class Solution {
public:
    bool b[101][101][201]; 
    // b[i][j][k] 表示i,j这个位置中左括号的数量时k
    bool hasValidPath(vector<vector<char>>& s) {
        if (s[0][0] == ')') return false;
        else b[0][0][1] = true;
        int n = s.size(), m = s[0].size();
        for (int i = 0; i < n ; i ++ ){
            for (int j = 0; j < m ; j ++ ){
                for (int k = 0; k < 200; k ++ ){ // k最大有 200 种
                    if (b[i][j][k]){
                        if (j + 1 < m){
                            int l = k;
                            if (s[i][j + 1] == '('){
                                l ++ ;
                            }
                            else{
                                l -- ;
                            }
                            if (l >= 0) b[i][j + 1][l] = true;
                        }
                        if (i + 1 < n){
                            int l = k;
                            if (s[i + 1][j] == '('){
                                l ++ ;
                            }
                            else{
                                l -- ;
                            }
                            if (l >= 0) b[i + 1][j][l] = true;
                        }
                    }
                }
            }
        }
        return b[n - 1][m - 1][0];
    }
};

继续学习！