第 402 场 LeetCode 周赛题解

最新推荐文章于 2024-06-22 22:59:06 发布

xhchen2024

最新推荐文章于 2024-06-22 22:59:06 发布

阅读量667

点赞数 11

分类专栏： LeetCode 文章标签： leetcode 计数哈希动态规划树状数组前缀和

本文链接：https://blog.csdn.net/weixin_40519680/article/details/139842351

版权

LeetCode 专栏收录该内容

72 篇文章 0 订阅

订阅专栏

A 构成整天的下标对数目 I

在这里插入图片描述

计数：遍历 $h o u rs$ ，记录 $hours[i]\%24$ 的出现次数

class Solution {
  public:
    long long countCompleteDayPairs(vector<int>& hours) {
        vector<int> cnt(24);
        long long res = 0;
        for (auto x : hours) {
            res += cnt[(24 - x % 24) % 24];
            cnt[x % 24]++;
        }
        return res;
    }
};

B 构成整天的下标对数目 II

在这里插入图片描述

计数：遍历 $h o u rs$ ，记录 $hours[i]\%24$ 的出现次数

class Solution {
  public:
    long long countCompleteDayPairs(vector<int>& hours) {
        vector<int> cnt(24);
        long long res = 0;
        for (auto x : hours) {
            res += cnt[(24 - x % 24) % 24];
            cnt[x % 24]++;
        }
        return res;
    }
};

C 施咒的最大总伤害

在这里插入图片描述

动态规划：设 $p [i]$ 为最大伤害值不超过 $i$ 的最大伤害值之和

class Solution {
  public:
    using ll = long long;
    long long maximumTotalDamage(vector<int>& power) {
        map<int, ll> s;
        for (auto x : power)
            s[x] += x;
        map<int, ll> p;
        for (auto it = s.begin(); it != s.end(); it++) {
            p[it->first] = it == s.begin() ? 0 : p[prev(it)->first];
            auto lb = s.lower_bound(it->first - 2);
            if (lb == s.begin())
                p[it->first] = max(p[it->first], it->second);
            else {
                p[it->first] = max(p[it->first], p[prev(lb)->first] + it->second);
            }
        }
        return p.rbegin()->second;
    }
};

D 数组中的峰值

在这里插入图片描述

树状数组：用树状数组维护前缀区间内的峰值元素数，对于更新 $n u m s [in d e x]$ 的操作，可能改变是否为峰值的位置有 $in d e x - 1$ 、 $in d e x$ 和 $in d e x + 1$

class Solution {
  public:
    vector<int> countOfPeaks(vector<int>& nums, vector<vector<int>>& queries) {
        int n = nums.size();
        BinaryIndexedTree bit(n);
        auto isval = [](int i, int j, int k) { return j > i && j > k; };
        for (int i = 1; i < n - 1; i++)
            if (isval(nums[i - 1], nums[i], nums[i + 1]))
                bit.add(i + 1, 1);//初始化
        vector<int> res;
        for (auto& qi : queries) {
            if (qi[0] == 1) {
                if (qi[2] - qi[1] + 1 > 2)
                    res.push_back(bit.query(qi[2]) - bit.query(qi[1] + 1));
                else
                    res.push_back(0);
            } else { // update
                int i = qi[1];
                int val = qi[2];
                if (i - 1 > 0) {//判断nums[i-1]是否改变峰值性
                    if (!isval(nums[i - 2], nums[i - 1], nums[i]) && isval(nums[i - 2], nums[i - 1], val))
                        bit.add(i - 1 + 1, 1);
                    else if (isval(nums[i - 2], nums[i - 1], nums[i]) && !isval(nums[i - 2], nums[i - 1], val))
                        bit.add(i - 1 + 1, -1);
                }
                if (i + 1 < n - 1) {//判断nums[i+1]是否改变峰值性
                    if (!isval(nums[i], nums[i + 1], nums[i + 2]) && isval(val, nums[i + 1], nums[i + 2]))
                        bit.add(i + 1 + 1, 1);
                    else if (isval(nums[i], nums[i + 1], nums[i + 2]) && !isval(val, nums[i + 1], nums[i + 2]))
                        bit.add(i + 1 + 1, -1);
                }
                if (i != 0 && i != n - 1) {//判断nums[i]是否改变峰值性
                    if (!isval(nums[i - 1], nums[i], nums[i + 1]) && isval(nums[i - 1], val, nums[i + 1]))
                        bit.add(i + 1, 1);
                    if (isval(nums[i - 1], nums[i], nums[i + 1]) && !isval(nums[i - 1], val, nums[i + 1]))
                        bit.add(i + 1, -1);
                }
                nums[i] = val;
            }
        }
        return res;
    }

    class BinaryIndexedTree {//树状数组模板
      public:
        int N;
        vector<int> a;

        BinaryIndexedTree(int n) {
            N = n;
            a = vector<int>(N + 1);
        }

        inline int lowbit(int x) {
            return x & -x;
        }

        void add(int loc, int val) { // li[loc]+=val;
            for (; loc <= N; loc += lowbit(loc))
                a[loc] += val;
        }

        int query(int loc) { // sum{li[k] | 1<=k<=loc}
            int res = 0;
            for (; loc > 0; loc -= lowbit(loc))
                res += a[loc];
            return res;
        }
    };
};