74双周赛的反思与小结

一、总览

表面上AK了，实际T4将被rejudge掉

写T2的时候一言难尽，没写出来赶紧开的3，所幸3挺简单。T4吐槽数据点，，造的啥数据啊🤣

二、各题详解

T1

字典计数，没有难度

class Solution {
public:
    bool divideArray(vector<int>& nums) {
        unordered_map<int, int> m;
        for(auto i : nums) m[i] ++;
        for(auto &[x, y] : m) if(y & 1) return false;
        return true;
    }
};

T2

我觉得这题可以和T3换个位置

一开始就想的二分查找下标，越写越复杂。咱就是说比完后看别人的代码恍然大悟，确实是我没有想到QWQ

先把本菜鸟写的二分贴出来供佬们嘲笑orz

//二分做法
typedef long long LL;
class Solution {
public:
    long long maximumSubsequenceCount(string text, string p) {
        vector<int> idx1, idx2;
        for(int i = 0; i < text.size(); ++ i)
            if(text[i] == p[1])
                idx2.push_back(i);
            else if(text[i] == p[0])
                idx1.push_back(i);
        
        if(p[0] == p[1])
        {
            LL res = 0;
            int n = idx2.size();
            //n ++;
            while(n)
                res += (n --);
            return res;
        }
        
        LL res1 = 0, res2 = 0;
        int n2 = idx2.size(), n1 = idx1.size();
        
        //没有出现[1]
        if(n2 == 0)
            return idx1.size();
        if(n1 == 0)
            return idx2.size();
        
        for(int i = 0; i < n1; ++ i)
        {
            auto it = upper_bound(idx2.begin(), idx2.end(), idx1[i]);
            if(it != idx2.end())
            {
                int t = it - idx2.begin();
                t = n2 - t;
                res1 += t;               
            }

        }
        
        for(int i = 0; i < n2; ++ i)
        {
            auto it = upper_bound(idx1.begin(), idx1.end(), idx2[i]);
            it --;
            if(it >= idx1.begin())
            {
                int t = it - idx1.begin() + 1;
                res2 += t;
            }
        }
        
        return max(res1 + n2, res2 + n1);
    }
};

其实不必这么麻烦🤣，只是计数需求开常量跑一遍即可。

typedef long long LL;
class Solution {
public:
    long long maximumSubsequenceCount(string s, string p) {
        LL t1 = 0, t2 = 0; //t1记录p[0]的次数 t2记录p[1]的次数
        LL res2 = 0;
        int n = s.size();
        //p[0] + p[1]组合
        for(int i = 0; i < n; ++ i)
        {
            if(s[i] == p[0]) t1 ++;
            else if(s[i] == p[1])
            {
                t2 ++;
                res2 += t1;
            }
        }
        
        if(p[0] == p[1]) return C(t1 + 1);
        return max(res2 + t1, res2 + t2);
    }

    LL C(int x)
    {
        LL res = 0;
        for(LL i = 1; i < x; ++ i) res +=i;
        return res;
    }
};

T3

裸的堆 不会堆的移步我之前写的博客：STL实现堆

class Solution {
public:
    int halveArray(vector<int>& nums) {
        double sum = 0;
        for(auto &i : nums) sum += i;
        
        priority_queue<double> q;
        for(int &i : nums) q.push(i);
        double tmp = 0;
        int res = 0;
        while(tmp < sum / 2.0)
        {
            res ++;
            double x = q.top();
            q.pop();
            tmp += x / 2;
            q.push(x / 2);
        }
        
        return res;
    }
};

T4

这题看起来像个贪心，但它不能贪心。

我只想到了贪心。一直在一个例子wa。后来加了个能全覆盖返回0就过了。。。只能说数据太弱，让我白高兴了一晚上。

不能贪心的例子如下：

"0101111"
2 //num
3 //len

贴上灵佬题解

class Solution {
public:
    int minimumWhiteTiles(string &floor, int n, int len) {
        int m = floor.size();
        vector<vector<int>> dp(n + 1, vector<int> (m));
        dp[0][0] = (floor[0] == '1');
        for(int i = 1; i < m; ++ i)
            dp[0][i] = dp[0][i-1] + (floor[i] == '1');
        
        for(int i = 1; i <= n; ++ i)
            for(int j = len; j < m; ++ j)
                dp[i][j] = min(dp[i][j-1] + (floor[j] == '1'), dp[i-1][j - len]);
        //dp[i][j-1]含义是: 前j-1用了i张
        //dp[i-1][j - len]含义是: 用1张地毯、将len长度直接覆盖掉
        return dp[n][m - 1];
    }
};