Update README_EN.md

Author: yanglbme

solution/2700-2799/2799.Count Complete Subarrays in an Array/README_EN.md

@@ -63,7 +63,15 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Hash Table + Enumeration
+
+First, we use a hash table to count the number of distinct elements in the array, denoted as $cnt$.
+
+Next, we enumerate the left endpoint index $i$ of the subarray and maintain a set $s$ to store the elements in the subarray. Each time we move the right endpoint index $j$ to the right, we add $nums[j]$ to the set $s$ and check whether the size of the set $s$ equals $cnt$. If it equals $cnt$, it means the current subarray is a complete subarray, and we increment the answer by $1$.
+
+After the enumeration ends, we return the answer.
+
+Time complexity: $O(n^2)$, Space complexity: $O(n)$, where $n$ is the length of the array.
 
 <!-- tabs:start -->
 
@@ -178,23 +186,28 @@ function countCompleteSubarrays(nums: number[]): number {
 
 ```rust
 use std::collections::HashSet;
+
 impl Solution {
     pub fn count_complete_subarrays(nums: Vec<i32>) -> i32 {
-        let mut set: HashSet<&i32> = nums.iter().collect();
+        let mut s = HashSet::new();
+        for &x in &nums {
+            s.insert(x);
+        }
+        let cnt = s.len();
         let n = nums.len();
-        let m = set.len();
         let mut ans = 0;
+
         for i in 0..n {
-            set.clear();
+            s.clear();
             for j in i..n {
-                set.insert(&nums[j]);
-                if set.len() == m {
-                    ans += n - j;
-                    break;
+                s.insert(nums[j]);
+                if s.len() == cnt {
+                    ans += 1;
                 }
             }
         }
-        ans as i32
+
+        ans
     }
 }
 ```
@@ -205,7 +218,15 @@ impl Solution {
 
 <!-- solution:start -->
 
-### Solution 2
+### Solution 2: Hash Table + Two Pointers
+
+Similar to Solution 1, we can use a hash table to count the number of distinct elements in the array, denoted as $cnt$.
+
+Next, we use two pointers to maintain a sliding window, where the right endpoint index is $j$ and the left endpoint index is $i$.
+
+Each time we fix the left endpoint index $i$, we move the right endpoint index $j$ to the right. When the number of distinct elements in the sliding window equals $cnt$, it means that all subarrays from the left endpoint index $i$ to the right endpoint index $j$ and beyond are complete subarrays. We then increment the answer by $n - j$, where $n$ is the length of the array. Afterward, we move the left endpoint index $i$ one step to the right and repeat the process.
+
+Time complexity: $O(n)$, Space complexity: $O(n)$, where $n$ is the length of the array.
 
 <!-- tabs:start -->
 
@@ -342,27 +363,33 @@ function countCompleteSubarrays(nums: number[]): number {
 
 ```rust
 use std::collections::HashMap;
-use std::collections::HashSet;
+
 impl Solution {
     pub fn count_complete_subarrays(nums: Vec<i32>) -> i32 {
-        let n = nums.len();
-        let m = nums.iter().collect::<HashSet<&i32>>().len();
-        let mut map = HashMap::new();
+        let mut d = HashMap::new();
+        for &x in &nums {
+            d.insert(x, 1);
+        }
+        let cnt = d.len();
         let mut ans = 0;
-        let mut i = 0;
-        for j in 0..n {
-            *map.entry(nums[j]).or_insert(0) += 1;
-            while map.len() == m {
-                ans += n - j;
-                let v = map.entry(nums[i]).or_default();
-                *v -= 1;
-                if *v == 0 {
-                    map.remove(&nums[i]);
+        let n = nums.len();
+        d.clear();
+
+        let (mut i, mut j) = (0, 0);
+        while j < n {
+            *d.entry(nums[j]).or_insert(0) += 1;
+            while d.len() == cnt {
+                ans += (n - j) as i32;
+                let e = d.get_mut(&nums[i]).unwrap();
+                *e -= 1;
+                if *e == 0 {
+                    d.remove(&nums[i]);
                 }
                 i += 1;
             }
+            j += 1;
         }
-        ans as i32
+        ans
     }
 }
 ```