周赛补题

leetcode 单 ：  

第一题https://leetcode.cn/problems/largest-positive-integer-that-exists-with-its-negative/数据范围比较小，直接枚举就好了

class Solution {
public:
    int findMaxK(vector<int>& nums) {
        vector<int> ans;
        
        for(int i = 0; i < nums.size(); i ++){
            for(int j = 0; j < nums.size(); j ++){
                if(nums[j] == - nums[i])  ans.push_back(abs(nums[j]));
            }
        }
                
        if(ans.size() == 0)  return -1;                                        
                                                    
        sort(ans.begin(), ans.end());
        return ans[ans.size() - 1];                                                
    }
};

当然可以用 set 来优化，枚举每个正数，检查 set 里是否有对应负数

class Solution {
public:
    int findMaxK(vector<int>& nums) {
        unordered_set<int> res;

        for(auto &c : nums)  res.insert(c);

        int ans = -1;
        for(auto &c : nums){
            if(c > 0 && res.count(-c))  ans = max(ans, c);
        }

        return ans;
    }
};

第二题https://leetcode.cn/problems/count-number-of-distinct-integers-after-reverse-operations/比赛时代码还是太繁琐了，数字反转硬是搞得这么复杂

class Solution {
public:
    int zhuan(int n){
        string x = to_string(n);
        string w;
        
        for(int i = x.size(); i >= 0; i --){
            w += x[i];
        }
        
        string ans;
        for(int i = 0; i < w.size(); i ++){
            if(w[i] != 0){
                ans = w.substr(i);
                break;
            }
        }
        
        int q = stoi(ans);
        
        return q;
    }   
    
    int countDistinctIntegers(vector<int>& nums) {
        vector<int> res;
        
        for(int i = 0; i < nums.size(); i ++){
            res.push_back(zhuan(nums[i]));
        }
        
        set<int> ans;
        for(int i = 0; i < nums.size(); i ++){
            //cout << nums[i] << " " << res[i] << endl;
            ans.insert(nums[i]);
            ans.insert(res[i]);
        }
        
        return ans.size();
    }
};

一行就可以解决的 

class Solution {
public:
    int countDistinctIntegers(vector<int>& nums) {
        unordered_set<int> st;

        for (int x : nums) st.insert(x);

        for (int x : nums) {
            int y = 0;
            for (int t = x; t; t /= 10) y = y * 10 + t % 10;

            st.insert(y);
        }

        return st.size();
    }
};

第三题https://leetcode.cn/problems/sum-of-number-and-its-reverse/和上一题一样了，直接枚举就好了

class Solution {
public:
    int zhuan(int n){
        string x = to_string(n);
        string w;
        
        for(int i = x.size() - 1; i >= 0; i --){
            w += x[i];
        }
        
        int q = stoi(w);
        
        return q;
    }
    
    bool sumOfNumberAndReverse(int num) {
        if(num == 0)  return true;
        
        for(int i = 1; i < num; i ++){
            if(zhuan(i) + i == num)  return true;
        }
        
        return false;
    }
};

第四题https://leetcode.cn/problems/count-subarrays-with-fixed-bounds/description/注意到定界子数组里一定不包含小于 minK 以及大于 maxK 的数。从原数组里把不符合要求的数都去掉后，原数组被分成好多个子数组，每个子数组里的元素都在 [minK, maxK] 之间。最终答案就是所有子数组的答案之和。接下来我们只考虑元素在 [minK, maxK] 之间的子数组。

大佬的这种简洁学法真的写不出来，在 min_i, max_i, i0 的初始化和ans的计算上真的巧妙

class Solution {
public:
    long long countSubarrays(vector<int>& nums, int minK, int maxK) {
        long long ans = 0;
        int min_i = -1, max_i = -1, i0 = -1;

        for(int i = 0; i < nums.size(); i ++){
            int x = nums[i];

            if(x == minK)  min_i = i;
            if(x == maxK)  max_i = i;
            if(x < minK || x > maxK)  i0 = i;

            ans += max(0, min(min_i, max_i) - i0);
        }

        return ans;
    }
};

leetcode 双 ： 

第一题https://leetcode.cn/problems/number-of-valid-clock-times/description/分情况枚举

class Solution {
public:
    int countTime(string time) {
        int rst = 0;

        for(int i = 0; i < 24; i++){
            for(int j = 0; j < 60; j++){
                if((time[0] == '?' || time[0] == i / 10 + '0')
                &&
                (time[1] == '?' || time[1] == i % 10 + '0')
                &&
                (time[3] == '?' || time[3] == j / 10 + '0')
                &&
                (time[4] == '?' || time[4] == j % 10 + '0')){
                    rst += 1;
                }
            }
        }
        
        return rst;
    }
};

第二题https://leetcode.cn/problems/range-product-queries-of-powers/首先把 n 的二进制分解结果存在 powers 里，由于 powers 的长度最多为 log⁡n，每个询问暴力处理即可通过

class Solution {
    const int MAXP = 30;
    const int MOD = 1e7;

public:
    vector<int> productQueries(int n, vector<vector<int>>& queries) {
        vector<int> vec;
        for (int i = 0; i <= MAXP; i++) if (n >> i & 1) vec.push_back(1 << i);

        vector<int> ans;
        for (auto &qry : queries) {
            int L = qry[0], R = qry[1];
            long long t = 1;

            for (int i = L; i <= R; i++) t = t * vec[i] % MOD;

            ans.push_back(t);
        }

        return ans;
    }
};

第三题https://leetcode.cn/problems/minimize-maximum-of-array/description/ 二分来实现，前方的较小数可以接受后方较大数多余的数字

class Solution {
public:
    bool check(vector<int> &nums, int k) {
        long long have = 0;

        for (int n : nums) {
            if (n <= k) {
                have += k - n;
            } else {
                if (have < n - k) return 0;
                else have -= (n - k);
            }
        }
        return 1;
    }

    int minimizeArrayValue(vector<int> &nums) {
        int left = 0, right = *max_element(nums.begin(), nums.end());
        
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (check(nums, mid)) right = mid;
            else left = mid + 1;
        }

        return left;
    }
};