LeetCode第338场周赛

2023.3.26LeetCode第338场周赛

A. K 件物品的最大和

思路

通过数组模拟

代码

class Solution {
public:
    int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
        vector<int> x;
        for (int i = 0; i < numOnes; i ++ ) x.push_back(1);
        for (int i = 0; i < numZeros; i ++ ) x.push_back(0);
        for (int i = 0; i < numNegOnes; i ++ ) x.push_back(-1);
        int ans = 0;
        for (int i = 0; i < x.size() && i < k; i ++ ) ans += x[i];
        return ans;
    }
};

B. 质数减法运算

思路

筛质数+二分
线性筛法筛质数，然后用二分去枚举每个能减去最大的质数，找不到说明无法满足

代码

class Solution {
public:
    bool primeSubOperation(vector<int>& a) {
        int m = 1010;
        // 筛质数
        vector<int> p;
        vector<int> st(m + 1);
        for (int i = 2; i < m; i ++ ) {
            if (!st[i]) p.push_back(i);
            for (int j = 0; p[j] * i <= m; j ++ ) {
                st[p[j] * i] = 1;
                if (i % p[j] == 0) break;
            }
        }
        p.insert(p.begin(), 0); //减去0也可以
        int n = a.size();
        int la = 0; //上个数
        for (int i = 0; i < n; i ++ ) {
            int l = 0, r = p.size() - 1;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (p[mid] + la < a[i]) l = mid;
                else r = mid - 1;
            }
            if (p[l] + la < a[i]) {
                a[i] -= p[l];
                la = a[i];
            }
            else return false;
        }
        return true;
    }
};

C. 使数组元素全部相等的最少操作次数

思路

前缀和+二分
元素的顺序不影响结果，先排序便于二分
每次询问的答案可以转化为每个元素与目标数的绝对值之和
二分出刚好大于等于目标数的位置，前半部分用目标数减去前缀和，后半部分相反

代码

class Solution {
public:
    typedef long long ll;
    
    vector<long long> minOperations(vector<int>& a, vector<int>& queries) {
        sort(a.begin(), a.end());
        vector<ll> ans;
        int n = a.size();
        vector<ll> s(n + 1);
        for (int i = 1; i <= n; i ++ ) s[i] = s[i - 1] + a[i - 1];
        for (ll x : queries) {
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (a[mid] >= x) r = mid;
                else l = mid + 1;
            }
            if (x >= a[n - 1]) l = n;
            ll res = (l * x - s[l]) + (s[n] - s[l] - (n - l) * x);
            ans.push_back(res);
        }
        return ans;
    }
};

D. 收集树中金币

思路

拓扑排序
先用拓扑排序去除没有金币的子树，这些节点一定不会走到
然后去除有金币的节点，再去除他们的邻居，剩余的节点一定会走到
由于最后要返回起点，经历的边数为(节点数-1)*2

代码

class Solution {
public:
    int collectTheCoins(vector<int>& coins, vector<vector<int>>& edges) {
        vector<vector<int>> g; //记录图
        int n = coins.size();
        g.resize(n);
        vector<int> d(n); //记录入度
        for (auto e : edges) {
            g[e[0]].push_back(e[1]);
            g[e[1]].push_back(e[0]);
            d[e[0]] ++ ;
            d[e[1]] ++ ;
        }
        queue<int> q;
        for (int i = 0; i < n; i ++ ) {
            if (coins[i] == 0 && d[i] == 1)
                q.push(i);
        }
        while (q.size()) {
            auto t = q.front();
            d[t] = 0;
            q.pop();
            for (auto i : g[t]) {
                d[i] -- ;
                if (d[i] == 1 && coins[i] == 0)
                    q.push(i);
            }
        }
        vector<int> a;
        for (int i = 0; i < n; i ++ ) {
            if (coins[i] == 1 && d[i] == 1) //叶节点且含有金币
                a.push_back(i);
        }
        for (int t : a) {
            d[t] = 0;
            for (auto i : g[t]) {
                d[i] -- ;
                if (d[i] == 1) //邻居若为叶节点，也可去除
                    d[i] -- ;
            }
        }
        int cnt = 0; //仍在图中的节点数量
        for (int i = 0; i < n; i ++ )
            if (d[i] > 0) cnt ++ ;
        return max((cnt - 1) * 2, 0);
    }
};