力扣日记8.2-【数组篇】长度最小的子数组相关题目推荐

力扣日记：【数组篇】长度最小的子数组相关题目推荐

日期：2023.8.2
参考：[代码随想录]

904.水果成篮

题目描述

难度：中等

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
给你一个整数数组fruits，返回你可以收集的水果的 最大 数目。

示例 1：

输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：

输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

提示：

• 1 <= fruits.length <= 105
• 0 <= fruits[i] < fruits.length

题解

class Solution {
#define SOLUTION 3
public:
    int totalFruit(vector<int>& fruits) {
        // 暴力（超出时间限制。。。）
#if SOLUTION == 1
        int len = fruits.size();
        int first = -1;
        int second = -1;
        int maxLen = 0;
        for (int i = 0; i < len; i++) {
            first = fruits[i];
            second = -1;
            for (int j = i; j < len; j++) {
                if (fruits[j] != first && second == -1) {
                    second = fruits[j];
                } else if (fruits[j] != first && fruits[j] != second) {
                    break;  
                }
                maxLen = (j - i + 1 > maxLen ? j - i + 1 : maxLen);
            }
            
        }
        return maxLen;
#elif SOLUTION == 2
        // 滑动窗口
        int len = fruits.size();
        int maxLen = 0;
        // 需要记录窗口中的值及其个数（可用哈希表代替）
        int first = -1; int firstCounter = 0;
        int second = -1; int secondCounter = 0;
        // 滑动窗口的起始位置和终止位置
        int start = 0; int end = 0;
        
        for (end = 0; end < len; end++) {
            if (firstCounter == 0) {
                first = fruits[end];
            } else if (secondCounter == 0 && fruits[end] != first) {
                second = fruits[end];
            }

            if (fruits[end] == first) {
                firstCounter++;
            } else if (fruits[end] == second) {
                secondCounter++;          
            } else { // 两个都不等
                maxLen = (firstCounter + secondCounter > maxLen) ? firstCounter + secondCounter : maxLen;
                while (firstCounter != 0 && secondCounter != 0) { // 移动start直到有一个counter为0
                    if(fruits[start] == first) firstCounter--;
                    else secondCounter--;
                    start++;
                }
                if (firstCounter == 0) {
                    first = fruits[end];
                    firstCounter++;
                } else if (secondCounter == 0) {
                    second = fruits[end];
                    secondCounter++;
                }
            }
        }

        maxLen = (firstCounter + secondCounter > maxLen) ? firstCounter + secondCounter : maxLen;

        return maxLen;

#else
        // 滑动窗口（哈希表）
        // 作者：力扣官方题解
        // https://leetcode.cn/problems/fruit-into-baskets/solutions/1893352/shui-guo-cheng-lan-by-leetcode-solution-1uyu/
        int n = fruits.size();
        unordered_map<int, int> cnt;

        int left = 0, ans = 0;
        for (int right = 0; right < n; ++right) {
            // 记录值及其对应个数
            ++cnt[fruits[right]];
            while (cnt.size() > 2) { // 当哈希表中出现超过两个键值对，则移动left
                auto it = cnt.find(fruits[left]);
                --it->second;
                if (it->second == 0) {
                    cnt.erase(it); // 当值的个数减小为0，则将对应键值对从哈希表中移除
                }
                ++left;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
#endif
    }
};

执行结果

1）暴力解法
状态：超出时间限制
时间复杂度：O(n^2)
空间复杂度：O(1)

2）滑动窗口（不用哈希表）
状态：通过
执行用时: 84 ms（93.24%）
内存消耗: 64.7MB （72.71%）
时间复杂度：O(n)
空间复杂度：O(1)

3）滑动窗口（哈希表）
状态：通过
执行用时: 148 ms（32.13 %）
内存消耗: 67.93 MB （26.29%）
时间复杂度：O(n)
空间复杂度：O(1)

思路总结

• 题目可简化为：选择两个值，使只包含这两个值的连续子数组长度最大
• 连续子数组 => 滑动窗口
• 滑动窗口的终止位置仍作为快指针遍历，起始位置作为慢指针（终止位置先行，起始位置始终在终止位置前方）
• 窗口越大越好，则终止位置尽可能往后移，直到不满足窗口条件（即窗口中超过（或即将超过）两个值），就开始移动起始位置，直到重新满足窗口条件。
• 本题最关键的地方是，在滑动窗口的基础上，要想到用哈希表或其他变量来表示窗口内的值及其对应个数。