第 336 场周赛

第 336 场周赛

Q1 简单判断

判断一下就行了

class Solution {
   public:
    int vowelStrings(vector<string>& words, int left, int right) {
        int ans=0;
        for(int i=left;i<=right;i++){
            int ok=0;
            if(words[i][0]=='a'||words[i][0]=='e'||words[i][0]=='i'||words[i][0]=='o'||words[i][0]=='u'){
                ok+=1;
            }
            int len=words[i].size();
            if(words[i][len-1]=='a'||words[i][len-1]=='e'||words[i][len-1]=='i'||words[i][len-1]=='o'||words[i][len-1]=='u'){
                ok+=1;
            }
            // printf("%d \n",ok);
            if(ok==2) ans+=1;
        }
        return ans;
    }
};

Q2 前缀和性质

根据前缀和的性质贪心一下，把大于等于0的放前面，小于等于0按绝对值小放前面，就是最佳结果。

结果要开long long

class Solution {
   public:
    int maxScore(vector<int>& nums) {
        int n=nums.size();
        vector<int> pos, neg;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > 0)
                pos.push_back(nums[i]);
            else
                neg.push_back(nums[i]);
        }
        sort(pos.begin(), pos.end());
        sort(neg.begin(), neg.end(), [&](int a, int b) { return a > b; });
        long long sum = 0, ans = 0;
        for (int i = 0; i < n; i++) {
            if (i < pos.size())
                sum += pos[i], ans += 1;
            else {
                sum += neg[i - pos.size()];
                if (sum > 0) ans += 1;
                else break;
            }
        }
        return ans;
    }
};

Q3 异或前缀+哈希表计数

1. 根据题意，要想把一个子数组全都变成0，则二进制的每一位的和，都必须偶数，就是要有偶数个1，根据异或的性质，偶数个1异或结果是0。
2. 那么很容易就可以想到，做一个前缀异或和，记为 pre。则如果存在 $0<=i,j<n,pre[j]$ xor $pre[j]==0$的话 ，那么区间 [i,j] 是一个漂亮数组
3. 再一次根据异或的性质，如果两个数异或等于 0 ，则这两个数相等。所以可以使用哈希表统计相同的数。
4. 在考虑pre数组，如果已经有 pre[i] 等于0，说明 [0,i] 是一个漂亮数组。所以 ans += mp[0]

代码：

class Solution {
   public:
    long long beautifulSubarrays(vector<int>& nums) {
        int n = nums.size();
        vector<int> pre_xor(n + 1, 0);
        map<int, int> mp;
        long long ans = 0;
        pre_xor[1] = nums[0];
        mp[pre_xor[1]]++;
        for (int i = 1; i < n; i++) {
            pre_xor[i + 1] = pre_xor[i] ^ nums[i];
            if (mp.count(pre_xor[i + 1])) {
                ans += mp[pre_xor[i + 1]];
            }
            mp[pre_xor[i + 1]]++;
        }
        ans+=mp[0];
        return ans;
    }
};

Q4 贪心+树状数组

确实不难

暴力也能过。

贪心，让所有任务尽可能的在一个时间点运行，从而减少总的运行时间。要坐到这一点，就可以将人按右端点排序，然后运行后面 duration 时间。

优化：如果之前已经有任务运行，则不用再次计算。所以这里要做一个求和遍历，找到vis[i]=false的时间点，即没有任务运行过的点。

树状数组，求区间内大于0的个数，使用一个vis标记数组搭配使用就可以。

// 树状数组
struct BIT {
    int n;
    vector<int> a;
    BIT(int n) : n(n), a(n + 1, 0) {}
    void add(int x, int v) {
        for (; x <= n; x += x & -x) {
            a[x] += v;
        }
    }
    int sum(int x) {
        int res = 0;
        for (; x > 0; x -= x & -x) {
            res += a[x];
        }
        return res;
    }
    void addLR(int l, int r, int v) {
        add(l, v);
        add(r + 1, -v);
    }
};

class Solution {
   public:
    int findMinimumTime(vector<vector<int>>& tasks) {
        sort(tasks.begin(), tasks.end(), [&](vector<int> a, vector<int> b) {
            return a[1] < b[1];
        });

        int len = tasks.size();

        BIT bit(20010);

        vector<int> vis(20010);

        int ans = 0;

        for (int i = 0; i < len; i++) {
            int begin = tasks[i][0], end = tasks[i][1], dur = tasks[i][2];

            int remain = dur - bit.sum(end) + bit.sum(begin - 1);

            for (int j = end; j >= begin; j--) {
                if (vis[j]) continue;
                if (remain <= 0) break;
                vis[j] = 1;
                bit.add(j, 1);
                ans += 1;
                remain--;
            }
        }

        return ans;
    }
};

暴力也可以过：

class Solution {
   public:
    int findMinimumTime(vector<vector<int>>& tasks) {
        sort(tasks.begin(), tasks.end(), [&](vector<int> a, vector<int> b) {
            return a[1] < b[1];
        });

        int len = tasks.size();
        vector<int> vis(20010);
        int ans = 0;

        for (int i = 0; i < len; i++) {
            int begin = tasks[i][0], end = tasks[i][1], dur = tasks[i][2];
            for(int i=begin;i<=end;i++){
                if(vis[i]) dur--;
            }
            for (int j = end; j >= begin; j--) {
                if (vis[j]) continue;
                if (dur <= 0) break;
                vis[j] = 1;
                ans += 1;
                dur--;
            }
        }
        return ans;
    }
};