Leetcode C++ 《第202场周赛》

1.题目1

1.1问题

给你一个整数数组 arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

示例 1：

输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况。
示例 2：

输入：arr = [1,2,34,3,4,5,7,23,12]
输出：true
解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

提示：

1 <= arr.length <= 1000
1 <= arr[i] <= 1000

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

1.2思路

• 暴力统计，用n的复杂度，而不是kn

1.3代码

class Solution {
public:
    bool threeConsecutiveOdds(vector<int>& arr) {
        int count = 0;
        for (int i = 0; i < arr.size(); i++) {
            if (arr[i]%2 == 1) {
                count++;
                if (count == 3)
                    return true;
            } else {
                if (count == 3)
                    return true;
                else
                    count = 0;
            }
        }
        if (count == 3)
            return true;
        else
            return false;
    }
};

2.题目2

2.1问题

存在一个长度为 n 的数组 arr ，其中 arr[i] = (2 * i) + 1 （ 0 <= i < n ）。

一次操作中，你可以选出两个下标，记作 x 和 y （ 0 <= x, y < n ）并使 arr[x] 减去 1 、arr[y] 加上 1 （即 arr[x] -=1 且 arr[y] += 1 ）。最终的目标是使数组中的所有元素都 相等 。题目测试用例将会 保证 ：在执行若干步操作后，数组中的所有元素最终可以全部相等。

给你一个整数 n，即数组的长度。请你返回使数组 arr 中所有元素相等所需的 最小操作数 。

示例 1：

输入：n = 3
输出：2
解释：arr = [1, 3, 5]
第一次操作选出 x = 2 和 y = 0，使数组变为 [2, 3, 4]
第二次操作继续选出 x = 2 和 y = 0，数组将会变成 [3, 3, 3]

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

2.2思路

• 此题目应该划分为easy题目，过于简单

2.3代码

class Solution {
public:
    int minOperations(int n) {
        return n*n/4;
    }
};

3.题目3

3.1问题

在代号为 C-137 的地球上，Rick 发现如果他将两个球放在他新发明的篮子里，它们之间会形成特殊形式的磁力。Rick 有 n 个空的篮子，第 i 个篮子的位置在 position[i] ，Morty 想把 m 个球放到这些篮子里，使得任意两球间 最小磁力 最大。

已知两个球如果分别位于 x 和 y ，那么它们之间的磁力为 |x - y| 。

给你一个整数数组 position 和一个整数 m ，请你返回最大化的最小磁力。

示例 1：

输入：position = [1,2,3,4,7], m = 3
输出：3
解释：将 3 个球分别放入位于 1，4 和 7 的三个篮子，两球间的磁力分别为 [3, 3, 6]。最小磁力为 3 。我们没办法让最小磁力大于 3 。

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

3.2思路

• 这个题目非常巧妙，最右侧有一个max值，从i的位置尝试放，如果j间距超过max/2，下一个从j往后开始放，如果放够m个表明一种可能的答案，因为间距最大的两个理论上分布在mid中间，如果不存在这样的值，证明max比较大
• 最小磁力通过二分来查找，是nlogn的复杂度

3.3代码

class Solution {
public:
    int maxDistance(vector<int>& position, int m) {
        sort(position.begin(), position.end());
        int l = 0, r = position[position.size()-1];
        int count, j;
        while (l+1 < r) {  //can put
            int mid = (l+r)/2;
            j = 0, count = 1;
            for (int i = 1;  i < position.size(); i++) {
                if (position[i] - position[j] >= mid) {
                    count++;
                    j = i;   //下一个从j往后放
                }
            }
            if (count >= m) { // 放多了，证明最小磁力在【mid，mid*2】
                l = mid;
            } else {   //没有放够证明最小磁力在【0，mid】之间，而不是【mid，mid*2】
                r = mid;
            }
        }
        return l;
    }
};

4.题目4

4.1问题

厨房里总共有 n 个橘子，你决定每一天选择如下方式之一吃这些橘子：

吃掉一个橘子。
如果剩余橘子数 n 能被 2 整除，那么你可以吃掉 n/2 个橘子。
如果剩余橘子数 n 能被 3 整除，那么你可以吃掉 2*(n/3) 个橘子。
每天你只能从以上 3 种方案中选择一种方案。

请你返回吃掉所有 n 个橘子的最少天数。

示例 1：

输入：n = 10
输出：4
解释：你总共有 10 个橘子。
第 1 天：吃 1 个橘子，剩余橘子数 10 - 1 = 9。
第 2 天：吃 6 个橘子，剩余橘子数 9 - 2*(9/3) = 9 - 6 = 3。（9 可以被 3 整除）
第 3 天：吃 2 个橘子，剩余橘子数 3 - 2*(3/3) = 3 - 2 = 1。
第 4 天：吃掉最后 1 个橘子，剩余橘子数 1 - 1 = 0。
你需要至少 4 天吃掉 10 个橘子。

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

4.2思路

• 动态规划，但是没有必要计算所有的1-n的值
• 优化：只需要计算必要的中间值即可

4.3代码

class Solution {
public:

//case 1
/*
    int minDays(int n) {

        int* dp = new int[n+1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = min(i, dp[i-1]+1);
            if (i % 2 == 0 && i >= 2) {
                dp[i] = min(dp[i], dp[i/2]+1);
            }
            if (i % 3 == 0 && i >= 3) {
                dp[i] = min(dp[i], dp[i/3]+1);
            }
        }
        return dp[n];
    }
    */
    //case 2
    unordered_map<int, int> dp;
    int minDays(int n) {
        //一个一个吃或者一次吃n/2或者n/3
        if (dp.count(n))
            return dp[n];
        if (n == 0) {
            dp[0] = 0;
            return 0;
        }
        if (n == 1) {
            dp[1] = 1;
            return 1;
        }
        dp[n] = min(min(1+n%2+minDays(n/2), 1+n%3+minDays(n/3)), n);
        return dp[n];
    }

};