LeetCode 第 200 场周赛

A 统计好三元组

class Solution {
public:
    int countGoodTriplets(vector<int>& arr, int a, int b, int c) {
        int n = arr.size();
        int ans = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                for (int k = j + 1; k < n; k++) {
                    if (abs(arr[i] - arr[j]) <= a && abs(arr[j]- arr[k]) <= b && abs(arr[i] - arr[k]) <= c) ans++;
                }
            }
        }
        return ans;
    }
};

B 找出数组游戏的赢家

class Solution {
public:
    int getWinner(vector<int>& arr, int k) {
        int n = arr.size();
        int cnt = 0;
        for (int i = 1; i < n; i++) {
            if (arr[0] > arr[i]) cnt++;
            else {
                arr[0] = arr[i];
                cnt = 1;
            }
            if (cnt == k) return arr[0];
        }
        return arr[0];
    }
};

C 排布二进制网格的最少交换次数

后缀0计数 + 贪心。从上往下遍历，遇到不符合的，从该位置往下找到符合的行换上来，中间计数并交换行和记录的后缀0。

class Solution {
public: 
    int minSwaps(vector<vector<int>>& grid) {
        vector<int> cnt;
        int n = grid.size();
        for (int i = 0; i < n; i++) {
            int c = 0;
            for (int j = n - 1; j >= 0; j--) {
                if (grid[i][j] == 0) c++;
                else break;
            }
            cnt.push_back(c);
        }
        int ans = 0;
        for (int i = 0; i < n - 1; i++) {
            bool ok = false;
            if (cnt[i] >= n - i - 1) continue;
            for (int j = i + 1; j < n; j++) {
                if (cnt[j] >= n - i - 1) {
                    int p = j;
                    for (;j > i;j--) {
                        swap(grid[j], grid[j - 1]);
                        swap(cnt[j], cnt[j - 1]);
                        ans++;
                    }
                    ok = true;
                    break;
                }
            }
            if(!ok) return -1;
        }
        return ans;
    }
};

D 最大得分

一开始写了个记忆化搜索，以nums里的值做标记转移，一直判我数组越界（怀疑给的nums[i]不止1e7，-.-，菜是原罪。之后看了下大佬们的做法，记录下各段交叉点之间的位置，计算分别的sum，取大的那段值即可。还有一种类似我写的记忆化搜索，只不过是以位置做标记，数组开到1e5就可以了的。

class Solution {
    typedef long long ll;
    const ll mod = 1000000007;
public:
    int maxSum(vector<int>& nums1, vector<int>& nums2) {
        vector<int> v1, v2;
        v1.push_back(0);
        v2.push_back(0);
        int i = 0, j = 0;
        int n = nums1.size(), m = nums2.size();
        while (i < n && j < m) {
            if (nums1[i] == nums2[j]) {
                v1.push_back(i);
                v2.push_back(j);
                i++;
            } else if (nums1[i] > nums2[j]) {
                j++;
            } else {
                i++;
            }
        }
        v1.push_back(n);
        v2.push_back(m);
        int k = v1.size();
        ll ans = 0;
        for (int i = 0; i < k - 1; i++) {
            ll sum1 = 0, sum2 = 0;
            for (int j = v1[i]; j < v1[i + 1]; j++) sum1 = sum1 + nums1[j];
            for (int j = v2[i]; j < v2[i + 1]; j++) sum2 = sum2 + nums2[j];
            ans = (ans + max(sum1, sum2)) % mod;
        }
        return ans % mod;
    }
};