feat: add solutions to lc problem: No.1671

yanglbme · yanglbme · commit 4792e0aa8e36 · 2023-01-28T12:00:26.000+08:00
No.1671.Minimum Number of Removals to Make Mountain Array
diff --git a/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README.md b/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README.md
@@ -60,7 +60,7 @@
 
 那么最终答案就是 $n - \max(left[i] + right[i] - 1)$，其中 $1 \leq i \leq n$，并且 $left[i] \gt 1$ 且 $right[i] \gt 1$。
 
-时间复杂度 $O(n^2)$。
+时间复杂度 $O(n^2)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
 
 <!-- tabs:start -->
 
@@ -195,6 +195,37 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minimumMountainRemovals(nums: number[]): number {
+    const n = nums.length;
+    const left = new Array(n).fill(1);
+    const right = new Array(n).fill(1);
+    for (let i = 1; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] > nums[j]) {
+                left[i] = Math.max(left[i], left[j] + 1);
+            }
+        }
+    }
+    for (let i = n - 2; i >= 0; --i) {
+        for (let j = i + 1; j < n; ++j) {
+            if (nums[i] > nums[j]) {
+                right[i] = Math.max(right[i], right[j] + 1);
+            }
+        }
+    }
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (left[i] > 1 && right[i] > 1) {
+            ans = Math.max(ans, left[i] + right[i] - 1);
+        }
+    }
+    return n - ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README_EN.md b/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/README_EN.md
@@ -175,6 +175,37 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minimumMountainRemovals(nums: number[]): number {
+    const n = nums.length;
+    const left = new Array(n).fill(1);
+    const right = new Array(n).fill(1);
+    for (let i = 1; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] > nums[j]) {
+                left[i] = Math.max(left[i], left[j] + 1);
+            }
+        }
+    }
+    for (let i = n - 2; i >= 0; --i) {
+        for (let j = i + 1; j < n; ++j) {
+            if (nums[i] > nums[j]) {
+                right[i] = Math.max(right[i], right[j] + 1);
+            }
+        }
+    }
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (left[i] > 1 && right[i] > 1) {
+            ans = Math.max(ans, left[i] + right[i] - 1);
+        }
+    }
+    return n - ans;
+};
+```
+
 ### **...**
 
 ```
diff --git a/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.ts b/solution/1600-1699/1671.Minimum Number of Removals to Make Mountain Array/Solution.ts
@@ -0,0 +1,26 @@
+function minimumMountainRemovals(nums: number[]): number {
+    const n = nums.length;
+    const left = new Array(n).fill(1);
+    const right = new Array(n).fill(1);
+    for (let i = 1; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] > nums[j]) {
+                left[i] = Math.max(left[i], left[j] + 1);
+            }
+        }
+    }
+    for (let i = n - 2; i >= 0; --i) {
+        for (let j = i + 1; j < n; ++j) {
+            if (nums[i] > nums[j]) {
+                right[i] = Math.max(right[i], right[j] + 1);
+            }
+        }
+    }
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (left[i] > 1 && right[i] > 1) {
+            ans = Math.max(ans, left[i] + right[i] - 1);
+        }
+    }
+    return n - ans;
+};
diff --git a/solution/1600-1699/1672.Richest Customer Wealth/README.md b/solution/1600-1699/1672.Richest Customer Wealth/README.md
@@ -80,6 +80,7 @@ class Solution {
     public int maximumWealth(int[][] accounts) {
         int ans = 0;
         for (var e : accounts) {
+            // int s = Arrays.stream(e).sum();
             int s = 0;
             for (int v : e) {
                 s += v;
diff --git a/solution/1600-1699/1672.Richest Customer Wealth/README_EN.md b/solution/1600-1699/1672.Richest Customer Wealth/README_EN.md
@@ -67,6 +67,7 @@ class Solution {
     public int maximumWealth(int[][] accounts) {
         int ans = 0;
         for (var e : accounts) {
+            // int s = Arrays.stream(e).sum();
             int s = 0;
             for (int v : e) {
                 s += v;
diff --git a/solution/1600-1699/1672.Richest Customer Wealth/Solution.java b/solution/1600-1699/1672.Richest Customer Wealth/Solution.java
@@ -2,6 +2,7 @@ class Solution {
     public int maximumWealth(int[][] accounts) {
         int ans = 0;
         for (var e : accounts) {
+            // int s = Arrays.stream(e).sum();
             int s = 0;
             for (int v : e) {
                 s += v;
diff --git a/solution/1600-1699/1679.Max Number of K-Sum Pairs/README.md b/solution/1600-1699/1679.Max Number of K-Sum Pairs/README.md
@@ -49,16 +49,26 @@
 
 **方法一：排序**
 
-对 nums 进行排序。然后 l, r 分别指向 nums 首尾元素，判断两整数之和 s 与 k 的大小关系。
+我们对 `nums` 进行排序。然后 $l$, $r$ 分别指向 `nums` 首尾元素，判断两整数之和 $s$ 与 $k$ 的大小关系。
 
--   若 `s == k`，说明找到了两个整数，满足和为 k，答案 ans 加 1，然后 l, r 向中间移动；
--   若 `s > k`，则 r 指针向左移动；
--   若 `s > k`，则 l 指针向右移动；
--   继续循环判断，直至 l >= r。
+-   若 $s = k$，说明找到了两个整数，满足和为 $k$，答案加一，然后 $l$, $r$ 向中间移动；
+-   若 $s \gt k$，则 $r$ 指针向左移动；
+-   若 $s \lt k$，则 $l$ 指针向右移动；
+-   继续循环判断，直至 $l \geq r$。
 
-循环结束，返回 ans。
+循环结束，返回答案。
 
-时间复杂度 $O(n\times \log n)$，其中 $n$ 为 `nums` 的长度。
+时间复杂度 $O(n\times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为 `nums` 的长度。
+
+**方法二：哈希表**
+
+我们使用哈希表 `cnt` 记录当前剩余整数及其出现的次数。
+
+遍历 `nums`，对于当前整数 $x$，判断 $k - x$ 是否在 `cnt` 中，若存在，则说明找到了两个整数，满足和为 $k$，答案加一，然后将 $k - x$ 的出现次数减一；否则，将 $x$ 的出现次数加一。
+
+遍历结束，返回答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为 `nums` 的长度。
 
 <!-- tabs:start -->
 
@@ -83,6 +93,20 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def maxOperations(self, nums: List[int], k: int) -> int:
+        cnt = Counter()
+        ans = 0
+        for x in nums:
+            if cnt[k - x]:
+                ans += 1
+                cnt[k - x] -= 1
+            else:
+                cnt[x] += 1
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -110,6 +134,26 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int maxOperations(int[] nums, int k) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        int ans = 0;
+        for (int x : nums) {
+            if (cnt.containsKey(k - x)) {
+                ++ans;
+                if (cnt.merge(k - x, -1, Integer::sum) == 0) {
+                    cnt.remove(k - x);
+                }
+            } else {
+                cnt.merge(x, 1, Integer::sum);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -135,6 +179,25 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int maxOperations(vector<int>& nums, int k) {
+        unordered_map<int, int> cnt;
+        int ans = 0;
+        for (int& x : nums) {
+            if (cnt[k - x]) {
+                --cnt[k - x];
+                ++ans;
+            } else {
+                ++cnt[x];
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -157,6 +220,39 @@ func maxOperations(nums []int, k int) int {
 }
 ```
 
+```go
+func maxOperations(nums []int, k int) (ans int) {
+	cnt := map[int]int{}
+	for _, x := range nums {
+		if cnt[k-x] > 0 {
+			cnt[k-x]--
+			ans++
+		} else {
+			cnt[x]++
+		}
+	}
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxOperations(nums: number[], k: number): number {
+    const cnt = new Map();
+    let ans = 0;
+    for (const x of nums) {
+        if (cnt.get(k - x)) {
+            cnt.set(k - x, cnt.get(k - x) - 1);
+            ++ans;
+        } else {
+            cnt.set(x, (cnt.get(x) | 0) + 1);
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1600-1699/1679.Max Number of K-Sum Pairs/README_EN.md b/solution/1600-1699/1679.Max Number of K-Sum Pairs/README_EN.md
@@ -62,6 +62,20 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def maxOperations(self, nums: List[int], k: int) -> int:
+        cnt = Counter()
+        ans = 0
+        for x in nums:
+            if cnt[k - x]:
+                ans += 1
+                cnt[k - x] -= 1
+            else:
+                cnt[x] += 1
+        return ans
+```
+
 ### **Java**
 
 ```java
@@ -87,6 +101,26 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int maxOperations(int[] nums, int k) {
+        Map<Integer, Integer> cnt = new HashMap<>();
+        int ans = 0;
+        for (int x : nums) {
+            if (cnt.containsKey(k - x)) {
+                ++ans;
+                if (cnt.merge(k - x, -1, Integer::sum) == 0) {
+                    cnt.remove(k - x);
+                }
+            } else {
+                cnt.merge(x, 1, Integer::sum);
+            }
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -112,6 +146,25 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int maxOperations(vector<int>& nums, int k) {
+        unordered_map<int, int> cnt;
+        int ans = 0;
+        for (int& x : nums) {
+            if (cnt[k - x]) {
+                --cnt[k - x];
+                ++ans;
+            } else {
+                ++cnt[x];
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -134,6 +187,39 @@ func maxOperations(nums []int, k int) int {
 }
 ```
 
+```go
+func maxOperations(nums []int, k int) (ans int) {
+	cnt := map[int]int{}
+	for _, x := range nums {
+		if cnt[k-x] > 0 {
+			cnt[k-x]--
+			ans++
+		} else {
+			cnt[x]++
+		}
+	}
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function maxOperations(nums: number[], k: number): number {
+    const cnt = new Map();
+    let ans = 0;
+    for (const x of nums) {
+        if (cnt.get(k - x)) {
+            cnt.set(k - x, cnt.get(k - x) - 1);
+            ++ans;
+        } else {
+            cnt.set(x, (cnt.get(x) | 0) + 1);
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```
diff --git a/solution/1600-1699/1679.Max Number of K-Sum Pairs/Solution.ts b/solution/1600-1699/1679.Max Number of K-Sum Pairs/Solution.ts
