LeetCoder_____周赛(158)

1.分割平衡字符串（5222）

题目链接： 5222. 分割平衡字符串

题目和括号匹配类似，扫描字符串，遇到L就+1，遇到R就-1，那么平衡字符串的时候一定为0。

class Solution {
public:
    int balancedStringSplit(string s) {
        int score = 0;
        int ret = 0;
        for(int i = 0; i < s.length(); ++i)
        {
            if(s[i] == 'L')
            {
                score ++;
            }
            if(s[i] == 'R')
            {
                score --;
            }
            if(score == 0)
            {
                ret ++;
            }
        }
        return ret;
    }
};

2.可以攻击国王的皇后（5223）

题目链接： 5223. 可以攻击国王的皇后

刚开始读题以为是一个很复杂的模拟题目，结果发现很简单，只需要从king的位置按照八个方向扫描，将第一个遇到的queen的记录一下就可以了。

class Solution {
public:
    vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {
        int mpt[8][8];
        memset(mpt, -1, sizeof(mpt));
        vector<vector<int>> ret;
        for(int i = 0 ; i < queens.size(); ++i)
        {
            mpt[queens[i][0]][queens[i][1]] = i; 
        }
        int dir[8][2] = {-1, 0, 1, 0, 0, 1, 0, -1, -1, -1, -1, 1, 1, -1, 1, 1 };
        for(int i = 0; i < 8; ++i)
        {
            int x = king[0], y = king[1];
            while(true)
            {
                x += dir[i][0];
                y += dir[i][1];
                if(!(x >= 0 && y >= 0 && x < 8 && y < 8))
                {
                    break;
                }
                if(mpt[x][y] > -1)
                {
                    vector<int> pos;
                    pos.push_back(x);
                    pos.push_back(y);
                    ret.push_back(pos);
                    break;
                }
            }
        }
        return ret;
    }
};

3.掷骰子模拟（5224）

题目链接： 5224. 掷骰子模拟

最开始以为是组合数学题，但是想了下之前遇到这种题好像都是可以直接dp出来的。

定义dp[i][j][k] = x 表示第i个数放置j并且当前j已经连续了k个了放法一共有x个。

那么要求的结果就是sum(dp[n][…][…])

class Solution {
public:
    typedef long long ll;
    const int mod = 1000000007;
    ll dp[5001][6][16];
    int dieSimulator(int n, vector<int>& rollMax) {
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < 6; ++i)
        {
            dp[1][i][1] = 1;
        }
        
        for(int i = 1; i < n; ++i)
        {
            for(int j = 0; j < 6; ++j) 
            {
                for(int k = 1; k <= 15; ++k)
                {
                    for(int l = 0; l < 6; ++l)
                    {
                        //在dp[i][j][k] 放l
                        if(l == j)
                        {
                            if(k + 1 > rollMax[l])
                                continue;
                            dp[i+1][j][k+1] =(dp[i+1][j][k+1] + dp[i][j][k]) % mod;
                        }
                        else
                        {
                            dp[i+1][l][1] = (dp[i][j][k] + dp[i+1][l][1]) % mod;
                        }
                    }
                }
            }
        }
        ll ret = 0;
        for(int i = 0; i < 6; ++i)
        {
            for(int j = 1; j <= 15; ++j)
            {
                ret = (ret + dp[n][i][j]) % mod;
            }
        }
        return ret;
        
    }
};

4.最大相等频率（5225）

题目链接： 5225. 最大相等频率

统计每个数的出现次数，在满足题意的要求前缀一共有下面这几种情况：

1. 每个数字都只有一个
2. 只有一个数有一个，其他数的数目都相同
3. 所有数都相同
4. 次数最多的数字去掉一个，然后所有的数字的次数都相同

class Solution {
public:
    int maxEqualFreq(vector<int>& nums) {
        //cnt表示每个数有多少个
        //fre[i] = j 表示有j个数的频率大于等于i
        //maxcn表示最大频率
        int cnt[100001] = {}, fre[100001] = {}, maxcn = 0;
        int ret = 0;
        for(int i = 0; i < nums.size(); ++i)
        {
            fre[++ cnt[nums[i]]]++;
            maxcn = max(maxcn, cnt[nums[i]]);
            if(maxcn == 1 //大家都只有一个
              || fre[maxcn] * maxcn == i // 只有一个数有1个，其余的数目都相同
              || maxcn == i + 1 //只有一个数
              || fre[maxcn-1]*(maxcn-1) == i) //最多的数少一个，大家数目都相同
            {
                ret = i + 1;
            }
        }
        return ret;
    }
};