Leetcode C++ 《第200场周赛》

还是因为enjoy做周赛的感觉，就像是定期锻炼注意力一样～一扫近日的浮躁

1. 题目1

1.1 问题

给你一个整数数组 arr ，以及 a、b 、c 三个整数。请你统计其中好三元组的数量。

如果三元组 (arr[i], arr[j], arr[k]) 满足下列全部条件，则认为它是一个 好三元组 。

0 <= i < j < k < arr.length
|arr[i] - arr[j]| <= a
|arr[j] - arr[k]| <= b
|arr[i] - arr[k]| <= c
其中 |x| 表示 x 的绝对值。

返回 好三元组的数量 。

示例 1：

输入：arr = [3,0,1,1,9,7], a = 7, b = 2, c = 3
输出：4
解释：一共有 4 个好三元组：[(3,0,1), (3,0,1), (3,1,1), (0,1,1)] 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/count-good-triplets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.2 思路

• 暴力n^3
• 可能考验的是逻辑思维

1.3 代码

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

2. 题目2

2.1 问题

给你一个由 不同 整数组成的整数数组 arr 和一个整数 k 。

每回合游戏都在数组的前两个元素（即 arr[0] 和 arr[1] ）之间进行。比较 arr[0] 与 arr[1] 的大小，较大的整数将会取得这一回合的胜利并保留在位置 0 ，较小的整数移至数组的末尾。当一个整数赢得 k 个连续回合时，游戏结束，该整数就是比赛的 赢家 。

返回赢得比赛的整数。

题目数据 保证 游戏存在赢家。

示例 1：

输入：arr = [2,1,3,5,4,6,7], k = 2
输出：5
解释：一起看一下本场游戏每回合的情况：

因此将进行 4 回合比赛，其中 5 是赢家，因为它连胜 2 回合。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-the-winner-of-an-array-game
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.2 思路

• 将问题抽象成数的比较，统计当前胜家的赢局个数

2.4 代码

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

3. 题目3

3.1 问题

给你一个 n x n 的二进制网格 grid，每一次操作中，你可以选择网格的 相邻两行 进行交换。

一个符合要求的网格需要满足主对角线以上的格子全部都是 0 。

请你返回使网格满足要求的最少操作次数，如果无法使网格符合要求，请你返回 -1 。

主对角线指的是从 (1, 1) 到 (n, n) 的这些格子。

示例 1：

输入：grid = [[0,0,1],[1,1,0],[1,0,0]]
输出：3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-swaps-to-arrange-a-binary-grid
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

3.2 思路

• 将网格抽象成数组，数组的元素是：每行从末尾开始连续0的个数
• 超时思路：每一行和其他行替换的可能性都遍历一遍，使用dfs，遍历所有结果，求minChangeTimes，在这个遍历的过程中可以进行剪枝
• AC思路：局部贪心，找到最近可以交换的行，交换之后放下一行元素【我纳闷这个一定是最优解嘛？目前还是没有想通，看了大佬的代码发现是这样就实现了下，等待思考】

3.3 超时代码

class Solution {
public:
    int minTimes = INT_MAX;
    int minSwaps(vector<vector<int>>& grid) {
        vector<int> v;
        int n = grid.size();
        for (int i = 0; i < n; i++) {
            int zeroNum = 0;
            for (int j = n-1; j >= 0; j--) {
                if (grid[i][j] != 0) {
                    v.push_back(zeroNum);
                    break;
                } else {
                    zeroNum++;
                }
            }
            if (zeroNum == n)
               v.push_back(zeroNum); 
        }
        /*for (int i = 0; i < n; i++) {
            cout << v[i] << " ";
        }
        cout << endl;*/
        dfs(v, 0, 0);
        if (minTimes == INT_MAX)
            return -1;
        return minTimes;
        
    }
    
    void dfs (vector<int> v, int times, int k) {
        // k is index, 0 对应的是 n-1-k的值， 要在这个位置放值
        int n = v.size();
        /*for (int i = 0; i < n; i++) {
            cout << v[i] << " ";
        }
        cout << endl;
        cout << "times: " << times <<  " , k: " << k <
        if (times >= minTimes)
            return;
        
        if (k == n) {
            if (times < minTimes)
                minTimes = times;
            return;
        }
        for (int i = k; i < n; i++) {
            if (v[i] >= n-1-k) {
                int temp = v[i];
                for (int j = i-1; j >= k; j--)
                    v[j+1] = v[j];
                v[k] = temp;
                dfs(v, times+(i-k), k+1);
                int temp1 = v[k];
                for (int j = k; j < i; j++)
                    v[j] = v[j+1];
                v[i] = temp1;
            }
        }
    }
};

3.4 AC代码

• 理论还没想明白，继续think

class Solution {
public:
    int minSwaps(vector<vector<int>>& grid) {
        vector<int> v;
        int res = 0;
        int n = grid.size();
        for (int i = 0; i < n; i++) {
            int zeroNum = 0;
            for (int j = n-1; j >= 0; j--) {
                if (grid[i][j] != 0) {
                    v.push_back(zeroNum);
                    break;
                } else {
                    zeroNum++;
                }
            }
            if (zeroNum == n)
               v.push_back(zeroNum); 
        }
        for (int i = 0; i < n; i++) {
            bool flag = false;
            for (int j = i; j < n; j++) {
                if (v[j] >= n-1-i) {
                    int temp = v[j];
                    for (int k = j; k > i; k--)
                        v[k] = v[k-1];
                    v[i] = temp;
                    res += (j-i);
                    flag = true;
                    break;
                }
            }
            if (!flag)
                return -1;
        }
        return res;
    }
    
};