leetcode竞赛：86 场双周赛

树不懒

已于 2023-10-21 10:55:53 修改

阅读量974

点赞数

文章标签： leetcode 算法职场和发展

于 2022-09-04 13:39:12 首次发布

本文链接：https://blog.csdn.net/weixin_43233774/article/details/126684648

版权

日期：20220903
链接：https://leetcode.cn/contest/biweekly-contest-86/

题目1

class Solution {
public:
    unordered_map<int, int> mmap;
    bool findSubarrays(vector<int>& nums) {
        int cur = nums[0] + nums[1];
        mmap[cur] = 1;
        int n = nums.size();
        for (int i = 2; i < n; i++) {
            cur -= nums[i - 2];
            cur += nums[i];
            if (mmap[cur] == 1) {
                return true;
            }
            mmap[cur] = 1;
        }
        return false;
    }
};

简洁版补充

class Solution {
public:
    bool findSubarrays(vector<int>& nums) {
        unordered_set<int> sset;
        for (int i = 1; i < nums.size(); i++) {
            int s = nums[i] + nums[i - 1];
            if (sset.find(s) != sset.end()) {
                return true;
            }
            sset.insert(s);
        }
        return false;
    }
};

题目2 6172. 严格回文的数字

回文数判断

class Solution {
public:
    bool isStrictlyPalindromic(int n) {
        for (int i = 2; i <= n - 2; i++) {
            if (!check(n, i)) {
                return false;
            }
        }
        return true;
    }
    bool check(int n, int b) {
        vector<int> num;
        while (n) {
            num.push_back(n % b);
            n /= b;
        }
        for (int i = 0, j = num.size() - 1; i < j; i++, j--) {
            if (num[i] != num[j]) {
                return false;
            }
        }
        return true;

    }
};

可以证明结果都是false，可以举 n - 2 进制的反例：

n > 4 时，其n - 2进制表示为12，不可能是回文的，所以直接返回false

class Solution {
public:
    bool isStrictlyPalindromic(int n) {
        return false;
    }
};

题目3 6173. 被列覆盖的最多行数

二进制枚举：枚举所有的覆盖情况

class Solution {
public:
    int maximumRows(vector<vector<int>>& mat, int cols) {
        int m = mat.size(), n = mat[0].size();
        int ret = 0;
        for (int i = 0; i < 1 << n; i++) {
            int x = 0, y = i;
            while (y) {
                y = y & (y - 1);
                x++;
            }
            if (x != cols) continue;
            int res = 0;
            for (int j = 0; j < m; j++) {
                int flag = 1;
                for (int k = 0; k < n; k++) {
                    if (mat[j][k] && !(i & (1 << k))) {
                        flag = false;
                        break;
                    }
                }
                if (flag) res++;
            }
            ret = max(ret, res);
        }
        return ret;
    }

};

二进制枚举：枚举所有覆盖 numSelect 列的情况

枚举 ${0,1, ...,n-1}$ 所有大小为 k 的子集

class Solution {
public:
    int maximumRows(vector<vector<int>>& matrix, int numSelect) {
        int m = matrix.size(), n = matrix[0].size(), res = 0;
        int comb = (1 << numSelect) - 1;
        while (comb < 1 << n) {
            int cnt = 0;
            for (int i = 0; i < m; i++) {
                int flag = 1;
                for (int j = 0; j < n; j++) {
                    if (matrix[i][j] == 1 && !(comb & (1 << j)))  {
                        flag = 0;
                        break;
                    }
                }
                cnt += flag;
            }
            res = max(res, cnt);
            int x = comb & -comb, y = comb + x;
            comb = ((comb & ~y) / x >> 1) | y;
        }
        return res;
    }
};

深度优先搜索，暴力枚举所有的覆盖情况，二者运行速度是一样的。

class Solution {
public:
    int res;
    int retu;
    int maximumRows(vector<vector<int>>& mat, int cols) {
        res = 0;
        retu = 0;
        dfs(mat, 0, cols, 0);
        return retu;
    }
    void dfs(vector<vector<int>>& mat, int cur, int cols, int cl) {
        int n = mat[0].size();
        if (cur == cols) {
            calc(mat);
        }
        if (cl == n) return ;
        // 选cl列
        res |= (1 << cl);
        dfs(mat, cur + 1, cols, cl + 1);
        // 不选cl列
        res &= ~(1 << cl);
        dfs(mat, cur, cols, cl + 1);
    }
    void calc(vector<vector<int>>& mat) {
        int m = mat.size(), n = mat[0].size();
        int ret = 0;
        for (int i = 0; i < m; i++) {
            int flag = 1;
            for (int j = 0; j < n; j++) {
                if (!(res & (1 << j)) && mat[i][j]) {
                    flag = 0;
                    break;
                }
            }
            if (flag) ret++;
        }
        
        retu = max(retu, ret);
    }
};

题目4 6143. 预算内的最多机器人数目

这个比赛的时候看错题目了，题目要求是连续的。而且想到解法了，就是没写出来。虽然写出来也是错的。。。
滑动窗口+单调队列做法：遍历一遍，查找左边的最大充电时间，用单减队列, O(n)复杂度
滑动窗口维护区间和，如果超出限制，左窗口右移。顺便判断单调队列是否被移出。O(n)复杂度

class Solution {
public:
    typedef long long LL;
    int maximumRobots(vector<int>& chargeTimes, vector<int>& runningCosts, long long budget) {
        int n = chargeTimes.size();
        deque<int> que;
        LL sum = 0;
        int res = 0;
        for (int i = 0, j = 0; i < n; i++) {
            while (!que.empty() && chargeTimes[que.back()] <= chargeTimes[i]) que.pop_back();
            que.push_back(i);
            sum += runningCosts[i];
            while (!que.empty() && sum * (i - j + 1) + chargeTimes[que.front()] > budget) {
                sum -= runningCosts[j];
                if (que.front() == j) que.pop_front();
                j++;
            }
            res = max(res, i - j + 1);
        }
        return res;
    }
};

如果是任意选取的，那么得用二分答案来做。O(log(n)) * O(nlog(n))。
第一个log(n)用来二分答案。后面的O(nlog(n))用来判断答案是否正确：以下代码不保证正确

typedef long long LL;
typedef pair<LL, LL> PLL;
class Solution {
public:
    int maximumRobots(vector<int>& x, vector<int>& y, long long m) {
        int n = x.size();
        vector<PLL> ms;
        for (int i = 0; i < n; i++) {
            ms.push_back({x[i], y[i]});
        }
        sort(ms.begin(), ms.end());
        int l = 0, r = n - 1;
        while (l < r) {
            int mid = (l + r + 1) / 2;
            if (check(ms, mid, m)) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        return l;
    }
    bool check(vector<PLL> &ms, int k, int m) {
        int n = ms.size();
        LL sum = 0;
        priority_queue<int> heap;
        for (int i = 0; i < n; i++) {
            if (heap.size() < k) {
                sum += ms[i].second;
                heap.push(ms[i].second);
            }
            if (heap.size() < k) continue;

            if (heap.top() > ms[i].second) {
                sum -= heap.top();
                heap.pop();
                heap.push(ms[i].second);
                sum += ms[i].second;
            }

            if (sum * k + ms[i].first < m) {
                return true;
            }

        }
        return false;
    }
};