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 <<endl;*/
        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;
    }
    
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值