LeetCode第 280 场周赛

A

class Solution {
public:
    int countOperations(int num1, int num2) {
        int cnt = 0;
        while (num1 != 0 && num2 != 0) {
            if (num1 >= num2)   num1 -= num2;
            else num2 -= num1;
            cnt ++;
        }
        return cnt;
    }
};

B

#define PII pair<int, int>
class Solution {
public:
    int minimumOperations(vector<int>& nums) {
        if (nums.size() == 1)    return 0;
        map<int, int> Map1, Map2;
        int n = nums.size() / 2 + (nums.size() % 2);
        int m = nums.size() - n;
        int res = 0x3f3f3f3f;
        for (int i = 0; i < nums.size(); i ++ ) {
            if (i % 2 == 0) Map1[nums[i]] ++;
            else Map2[nums[i]] ++;
        }
        vector<PII> v1, v2;
        for (auto x : Map1) v1.push_back({x.first, x.second});
        for (auto x : Map2) v2.push_back({x.first, x.second});
        function<bool(PII, PII)> cmp = [&](PII a, PII b) {
            if (a.second == b.second)   return a.first < b.first;
            return a.second > b.second;
        };
        sort(v1.begin(), v1.end(), cmp);
        sort(v2.begin(), v2.end(), cmp);
        if (v1[0].first != v2[0].first) {
            res = (n - v1[0].second) + (m - v2[0].second);
        }
        else {
            if (v1.size() == 1 && v2.size() == 1) 
                res = min(n, m);
            else if (v1.size() == 1) 
                res = min(n + m - v2[0].second, m - v2[1].second);
            else if (v2.size() == 1) 
                res = min(m + n - v1[0].second, n - v1[1].second);
            else 
                res = min(n - v1[0].second + m - v2[1].second, n - v1[1].second + m - v2[0].second);
        }
        return res;
    }
};

C
前缀和

#define LL long long
class Solution {
public:
    LL sum[100010], sum1[100010], a[100010];
    LL minimumRemoval(vector<int>& beans) {
        int n = beans.size();
        for (int i = 0; i < beans.size(); i ++ )
            a[i + 1] = beans[i];
        sort(a + 1, a + 1 + n);
        LL res = 0x3f3f3f3f3f3f3f3f;
        for (int i = 1; i <= n; i ++ )  sum[i] = sum[i - 1] + a[i];
        for (int i = 1; i <= 100000; i ++ )  {
            int l = 0, r = n;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (a[mid] < i)    l = mid;
                else r = mid - 1;
            }
            res = min(res, sum[l] + sum[n] - sum[l] - (n - l) * 1LL * i);
        }
        return res;
    }
};

D
状压DP

class Solution {
public:
    int f[20][2 << 18 + 1], a[20];
    vector<int> state[20];
    int maximumANDSum(vector<int>& nums, int m) {
        int n = nums.size();
        for (int i = 0; i < 1 << (m * 2); i ++ ) {
            bool flag = 1;
            for (int j = 0; j < m; j ++ ) {
                if ((i >> j & 1) == 0 && (i >> (j + m) & 1) == 1)
                    flag = 0;
            }
            if (flag)   {
                int tot = 0;
                for (int j = 0; j < m * 2; j ++ )
                    if (i >> j & 1)
                        tot ++;
                state[tot].push_back(i);
            }
        }
        for (int i = 0; i < n; i ++ )   a[i + 1] = nums[i];
        for (int i = 1; i <= n; i ++ ) {
            for (auto x : state[i - 1]) {
                for (int j = 0; j < m; j ++ )
                    if ((x >> j & 1) == 0) 
                        f[i][x | (1 << j)] = max(f[i - 1][x] + (a[i] & (j + 1)), f[i][x | (1 << j)]);
                for (int j = m; j < m * 2; j ++ )
                    if ((x >> j & 1) == 0 && (x >> (j - m) & 1)) 
                        f[i][x | (1 << j)] = max(f[i - 1][x] + (a[i] & (j - m + 1)), f[i][x | (1 << j)]);
                        
            }
        }
        int res = 0;
        for (auto x : state[n])
            res = max(res, f[n][x]);
        return res;
    }
};