LeetCode 第 202 场周赛 题解

第 202 场周赛

题目1：5185. 存在连续三个奇数的数组

思路：暴力

签到题，暴力遍历即可。

代码：

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

复杂度分析：

遍历数组，时间复杂度O(N)；

没有使用额外变量，空间复杂度为O(1)

有收获？希望老铁们来个三连击，给更多的人看到这篇文章

1、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

2、老铁们，关注我的原创微信公众号「Grand Theft Algorithm」，专注于写算法题解 + 计算机基础知识！回复01即送算法大礼包！！！

题目2：5488. 使数组中所有元素相等的最小操作数

思路：数学

根据题意，可以直接将数组以中心元素为对称点，两两配对，操作的次数相同。所以只需要针对数组长度奇偶进行分析即可。

实现细节：

我们假设 n 为奇数，不妨设 n = 2k + 1，那么我们可以将数组分为如下三段：第一段为a[1] - a[k]，第二段为单独一个元素a[k + 1]，第三段为a[k + 2] - a[2k + 1]（注意这里使用的下标元素是从1开始，便于理解，下同）。根据题意，我们可以将 a[1] 与 a[2k + 1]配对，二者同时操作 2k 次，即可达到值相等；同理，将a[2] 与 a[2k]配对，二者同时操作 2k - 2次即相等。以此类推，a[k + 1]不需要变换值，单独作为一组。故总共需要操作的次数为：
$$2+4+...+2k=k\ast (k+1)=\frac{(n-1)(n+1)}{4}$$

同理，若 n 为偶数，不妨设 n = 2k，可以将数组分为两段：第一段为 a[1] - a[k]，第二段为a[k + 1] - a[2k]，此时，a[1] 与 a[2k]配对，二者同时操作 2k - 1次，a[3] 与 a[2k - 1]配对，二者同时操作 2k - 3次，以此类推，a[k] 与 a[k + 1] 配对，二者同时操作1次，故总共需要操作的次数为：
$$1+3+...+2k-1=k^2=\frac{n^2}{4}$$

代码：

class Solution {
public:
    int minOperations(int n) {
        if(n % 2 == 1) {
            return (n + 1) * (n - 1) / 4;
        } else {
            return n * n / 4;
        }
    }
};

复杂度分析：

时间、空间复杂度均为O(1)

有收获？希望老铁们来个三连击，给更多的人看到这篇文章

1、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

2、老铁们，关注我的原创微信公众号「Grand Theft Algorithm」，专注于写算法题解 + 计算机基础知识！回复01即送算法大礼包！！！

题目3：5489. 两球之间的磁力

思路：二分搜索

题意求最大化最小，类似这样的求最大化最小值、最小化最大值等都可以用二分搜索解决。

实现细节：

首先要找到二分搜索的边界，根据题意，要返回的是最小磁力，所以第一步要找到最小磁力的最小可能取值和最大可能取值。

对于最小可能取值，当然就是给定数组中距离最近的两个位置之间的磁力，所以对数组进行排序，并遍历数组找到相邻两个位置的最小距离。

对于最大可能取值，一共有m个球，所以有 m - 1 个间隔，最大的可能取值便是最平均的取值，所以根据给定数组最大值与最小值之差与间隔数的比值计算出平均距离，就是给定的最大可能取值。

这里给定简单证明，假设有 k 个间隔，给定数组规定的篮子间最大距离为 x，那么最小磁力的最大可能取值是 x / k，假设有某一可能取值 y 大于最大可能取值，那么所有距离都一定大于等于 y，此时假设 k 个间隔距离均为 y，总距离 ky > k * x / k = x，也大于给定的最大距离，所以不成立。

确定好了边界后，每次二分搜索时需要判断当前计算值是否满足条件，这里我们引入 check 函数，对当前计算出的最小磁力进行验证。验证过程使用贪心算法，遍历数组，若找到两位置之间距离大于等于最小磁力，则计数值加1，最后只需要判断总计数值是否大于等于给定间隔数 m - 1即可。

例如，示例1中，假设我们当前二分搜索计算出的距离为 2，那么我们遍历数组，假设第一个位置为 1，那么下一个找到的位置应该是3，因为 3 - 1 >= 2，计数值加1；再下面找到的是 7，因为 7 - 3 >= 2，计数值加1。此时数组遍历完成，总计数值为 2，而给定间隔数 m - 1 = 2，满足条件，说明最小磁力为2是可以做到的。但如果我们当前计算出的距离为4，那么第一个位置为1，找到的第二个位置就只能是7，数组遍历完成总计数值为1，小于给定间隔数，说明最小磁力为4是不成立的。

在判断计算值满足条件与否之后，我们要对二分搜索边界进行转化，由于题目要求的是最大化的最小磁力，所以若当前计算出的最小磁力满足条件，我们要将左边界右移，去判断稍大一点的数值是否满足条件；若当前计算出的最小磁力不满足条件，我们要将右边界左移，判断稍小的数值是否满足条件。

由于每次满足条件后左边界右移，所以左边界的左边一个数值是一定满足条件的，所以最后返回值为 l - 1，具体返回值根据边界移动的判定规则进行判断。

代码：

class Solution {
public:
    bool check(int x, vector<int>& a, int m) {
        int cnt = 0;
        int target = a[0] + x;
        for(int i = 0; i < a.size() - 1; i++) {
            if(a[i] < target && a[i + 1] >= target) {
                cnt++;
                target = a[i + 1] + x;
            }
        }
        return cnt >= m - 1;
    }
    
    int maxDistance(vector<int>& a, int m) {
        sort(a.begin(), a.end());
        int len = a.size();
        int diff = a[len - 1] - a[0];	 // 最大间隔
        int mn = INT_MAX;	// 记录最小间隔
        for(int i = 0; i < len - 1; i++) {
            if(mn > a[i + 1] - a[i]) {
                mn = a[i + 1] - a[i];
            }
        }
        if(m == 2) {	// 这里特判了m = 2的情况，也可以归到底下的代码中。
            return diff;
        } else {
            int l = mn, r = diff / (m - 1);	// 确定左右边界
            while(l <= r) {	// 二分搜索
                int mid = (l + r) / 2;
                // printf("l = %d, r = %d, mid = %d\n", l, r, mid);
                if(check(mid, a, m)) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
            return l - 1;
        }
    }
};

复杂度分析：

数组排序时间复杂度O(NlgN)，二分搜索复杂度为O(lgN)，每次进行check需要遍历数组，复杂度O(N)，所以二分整体复杂度也为O(NlgN)，故时间复杂度为O(NlgN)；

维护了几个变量，空间复杂度为O(1)。

有收获？希望老铁们来个三连击，给更多的人看到这篇文章

1、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

2、老铁们，关注我的原创微信公众号「Grand Theft Algorithm」，专注于写算法题解 + 计算机基础知识！回复01即送算法大礼包！！！

题目4：5490. 吃掉 N 个橘子的最少天数

思路：递归 + 记忆化

根据题意，主要思路是要把n配成2的倍数或者3的倍数，然后就可以大规模减少橘子的数量，所以利用简单递归 + 记忆化即可。

实现细节：

假设当前有 n 个橘子，我们若想将其配成 2 的倍数，只需要花 n % 2 天每天吃一个橘子即可；而配成 3 的倍数只需要花 n % 3 天每天吃一个橘子即可。为了避免递归过程中的重复计算，利用unordered_map记录中间过程。

代码：

class Solution {
public:
    unordered_map<int, int> mp;
    int minDays(int n) {
        if(n == 0) {    // 边界条件
            return 0;
        } else if(n == 1) {
            return 1;
        } else if(mp.count(n)) {    // 记忆化
            return mp[n];
        }
        int res = min(minDays(n / 2) + n % 2 + 1, minDays(n / 3) + n % 3 + 1);  // 配成倍数，注意最后要加一，因为按倍数吃橘子也算一天
        mp[n] = res;    // 记录中间过程
        return res;
    }
};

复杂度分析：

使用了记忆化，所以避免了重复计算子过程；递归的过程将 N 转化为 N / 2 或 N / 3处理，时间复杂度为O(lgN)；

维护了哈希表，空间复杂度为O(lgN)。

有收获？希望老铁们来个三连击，给更多的人看到这篇文章

1、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我，嘻嘻。

2、老铁们，关注我的原创微信公众号「Grand Theft Algorithm」，专注于写算法题解 + 计算机基础知识！回复01即送算法大礼包！！！