feat: add solutions to lc problem: No.0904

No.0904.Fruit Into Baskets

Author: yanglbme

solution/0900-0999/0904.Fruit Into Baskets/README.md

@@ -67,7 +67,39 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“计数器 + 滑动窗口”实现。
+**方法一：哈希表 + 滑动窗口**
+
+我们用哈希表 $cnt$ 维护当前窗口内的水果种类以及对应的数量，用双指针 $j$ 和 $i$ 维护窗口的左右边界。
+
+遍历数组 `fruits`，将当前水果 $x$ 加入窗口，即 $cnt[x]++$，然后判断当前窗口内的水果种类是否超过了 $2$ 种，如果超过了 $2$ 种，就需要将窗口的左边界 $j$ 右移，直到窗口内的水果种类不超过 $2$ 种为止。然后更新答案，即 $ans = \max(ans, i - j + 1)$。
+
+遍历结束后，即可得到最终的答案。
+
+```
+1 2 3 2 2 1 4
+^   ^
+j   i
+
+
+1 2 3 2 2 1 4
+  ^ ^
+  j i
+
+
+1 2 3 2 2 1 4
+  ^     ^
+  j     i
+```
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `fruits` 的长度。
+
+**方法二：滑动窗口优化**
+
+在方法一中，我们发现，窗口大小会时而变大，时而变小，这就需要我们每一次更新答案。
+
+但本题实际上求的是水果的最大数目，也就是“最大”的窗口，我们没有必要缩小窗口，只需要让窗口单调增大。于是代码就少了每次更新答案的操作，只需要在遍历结束后将此时的窗口大小作为答案返回即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `fruits` 的长度。
 
 <!-- tabs:start -->
 
@@ -77,18 +109,35 @@
 
 ```python
 class Solution:
-    def totalFruit(self, tree: List[int]) -> int:
-        counter = Counter()
-        i = res = 0
-        for j, type in enumerate(tree):
-            counter[type] += 1
-            while len(counter) > 2:
-                counter[tree[i]] -= 1
-                if counter[tree[i]] == 0:
-                    counter.pop(tree[i])
-                i += 1
-            res = max(res, j - i + 1)
-        return res
+    def totalFruit(self, fruits: List[int]) -> int:
+        cnt = Counter()
+        ans = j = 0
+        for i, x in enumerate(fruits):
+            cnt[x] += 1
+            while len(cnt) > 2:
+                y = fruits[j]
+                cnt[y] -= 1
+                if cnt[y] == 0:
+                    cnt.pop(y)
+                j += 1
+            ans = max(ans, i - j + 1)
+        return ans
+```
+
+```python
+class Solution:
+    def totalFruit(self, fruits: List[int]) -> int:
+        cnt = Counter()
+        j = 0
+        for x in fruits:
+            cnt[x] += 1
+            if len(cnt) > 2:
+                y = fruits[j]
+                cnt[y] -= 1
+                if cnt[y] == 0:
+                    cnt.pop(y)
+                j += 1
+        return len(fruits) - j
 ```
 
 ### **Java**
@@ -97,25 +146,133 @@ class Solution:
 
 ```java
 class Solution {
-    public int totalFruit(int[] tree) {
-        Map<Integer, Integer> counter = new HashMap<>();
-        int i = 0, res = 0;
-        for (int j = 0; j < tree.length; ++j) {
-            counter.put(tree[j], counter.getOrDefault(tree[j], 0) + 1);
-            while (counter.size() > 2) {
-                counter.put(tree[i], counter.get(tree[i]) - 1);
-                if (counter.get(tree[i]) == 0) {
-                    counter.remove(tree[i]);
+    public int totalFruit(int[] fruits) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        int ans = 0;
+        for (int i = 0, j = 0; i < fruits.length; ++i) {
+            int x = fruits[i];
+            cnt.put(x, cnt.getOrDefault(x, 0) + 1);
+            while (cnt.size() > 2) {
+                int y = fruits[j++];
+                cnt.put(y, cnt.get(y) - 1);
+                if (cnt.get(y) == 0) {
+                    cnt.remove(y);
                 }
-                ++i;
             }
-            res = Math.max(res, j - i + 1);
+            ans = Math.max(ans, i - j + 1);
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+```java
+class Solution {
+    public int totalFruit(int[] fruits) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        int j = 0, n = fruits.length;
+        for (int x : fruits) {
+            cnt.put(x, cnt.getOrDefault(x, 0) + 1);
+            if (cnt.size() > 2) {
+                int y = fruits[j++];
+                cnt.put(y, cnt.get(y) - 1);
+                if (cnt.get(y) == 0) {
+                    cnt.remove(y);
+                }
+            }
+        }
+        return n - j;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int totalFruit(vector<int>& fruits) {
+        unordered_map<int, int> cnt;
+        int ans = 0;
+        for (int i = 0, j = 0; i < fruits.size(); ++i) {
+            int x = fruits[i];
+            ++cnt[x];
+            while (cnt.size() > 2) {
+                int y = fruits[j++];
+                if (--cnt[y] == 0) cnt.erase(y);
+            }
+            ans = max(ans, i - j + 1);
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int totalFruit(vector<int>& fruits) {
+        unordered_map<int, int> cnt;
+        int j = 0, n = fruits.size();
+        for (int& x : fruits) {
+            ++cnt[x];
+            if (cnt.size() > 2) {
+                int y = fruits[j++];
+                if (--cnt[y] == 0) cnt.erase(y);
+            }
+        }
+        return n - j;
+    }
+};
+```
+
+### **Go**
+
+```go
+func totalFruit(fruits []int) int {
+	cnt := map[int]int{}
+	ans, j := 0, 0
+	for i, x := range fruits {
+		cnt[x]++
+		for ; len(cnt) > 2; j++ {
+			y := fruits[j]
+			cnt[y]--
+			if cnt[y] == 0 {
+				delete(cnt, y)
+			}
+		}
+		ans = max(ans, i-j+1)
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+```go
+func totalFruit(fruits []int) int {
+	cnt := map[int]int{}
+	j := 0
+	for _, x := range fruits {
+		cnt[x]++
+		if len(cnt) > 2 {
+			y := fruits[j]
+			cnt[y]--
+			if cnt[y] == 0 {
+				delete(cnt, y)
+			}
+			j++
+		}
+	}
+	return len(fruits) - j
+}
+```
+
 ### **...**
 
 ```