LC 904. 水果成篮

题目描述

这是 LeetCode 上的 904. 水果成篮 ，难度为 中等。

你正在探访一家农场，农场从左到右种植了一排果树。

这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果种类。

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

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

给你一个整数数组 fruits，返回你可以收集的水果的最大数目。

示例 1：

1
2
3
4
5
输入：fruits = [1,2,1]

输出：3

解释：可以采摘全部 3 棵树。

示例 2：
1
2
3
4
5
6
输入：fruits = [0,1,2,2]

输出：3

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

示例 3：
1
2
3
4
5
6
输入：fruits = [1,2,3,2,2]

输出：4

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

示例 4：
1
2
3
4
5
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]

输出：5

解释：可以采摘 [1,2,1,1,2] 这五棵树。

提示：

  • $1 <= fruits.length <= 10^5$
  • $0 <= fruits[i] < fruits.length$

滑动窗口

本题至少一半的难度在于理解题意。

坏消息是，像此类描述不够清晰的算法题，并不在少数。

好消息是，此类题目，通常都有对应的解决方案。就是如果读一遍题面，不能理解题意的时候，切勿来回阅读题面，而是从示例数据进行入手进行理解。

通过对先看「示例」再阅读「题面」的理解方式，整理出基本题意：从任意位置开始，同时使用两个篮子采集，一旦选择后不能修改篮子所装的水果种类，当所有树处理完或遇到第一棵种类不同的树则停止。

核心求解思路为滑动窗口：使用 j 和 i 分别代表滑动窗口的两端，窗口种类不超过 $2$ 种为合法。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
    public int totalFruit(int[] fruits) {
        int n = fruits.length, ans = 0;
        int[] cnts = new int[n + 10];
        for (int i = 0, j = 0, tot = 0; i < n; i++) {
            if (++cnts[fruits[i]] == 1) tot++;
            while (tot > 2) {
                if (--cnts[fruits[j++]] == 0) tot--;
            }
            ans = Math.max(ans, i - j + 1);
        }
        return ans;
    }
}

C++ 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size(), ans = 0;
        unordered_map<int, int> cnts;
        for (int i = 0, j = 0, tot = 0; i < n; i++) {
            if (++cnts[fruits[i]] == 1) tot++;
            while (tot > 2) {
                if (--cnts[fruits[j++]] == 0) tot--;
            }
            ans = max(ans, i - j + 1);
        }
        return ans;
    }
};

Python 代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution:
    def totalFruit(self, fruits: List[int]) -> int:
        n, ans = len(fruits), 0
        j, tot = 0, 0
        cnts = defaultdict(int)
        for i in range(n):
            cnts[fruits[i]] += 1
            if cnts[fruits[i]] == 1:
                tot += 1
            while tot > 2:
                cnts[fruits[j]] -= 1
                if cnts[fruits[j]] == 0:
                    tot -= 1
                j += 1
            ans = max(ans, i - j + 1)
        return ans

TypeScript 代码：
1
2
3
4
5
6
7
8
9
10
11
12
function totalFruit(fruits: number[]): number {
    let n = fruits.length, ans = 0
    const cnts = new Array<number>(n + 10).fill(0)
    for (let i = 0, j = 0, tot = 0; i < n; i++) {
        if (++cnts[fruits[i]] == 1) tot++
        while (tot > 2) {
            if (--cnts[fruits[j++]] == 0) tot--
        }
        ans = Math.max(ans, i - j + 1)
    }
    return ans
}

  • 时间复杂度：$O(n)$
  • 空间复杂度：$O(n)$

最后

这是我们「刷穿 LeetCode」系列文章的第 No.904 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。