feat: add solutions to lc problem: No.2297 (doocs#1284)

No.2297.Jump Game VIII

Author: yanglbme

solution/0700-0799/0771.Jewels and Stones/README.md

@@ -44,7 +44,7 @@
 
 我们可以先用一个哈希表或数组 $s$ 记录所有宝石的类型。然后遍历所有石头，如果当前石头是宝石，就将答案加一。
 
-时间复杂度 $O(m+n)$。其中 $m$ 和 $n$ 分别是字符串 $jewels$ 和 $stones$ 的长度。
+时间复杂度 $O(m+n)$，空间复杂度 $O(|\Sigma|)$，其中 $m$ 和 $n$ 分别是字符串 $jewels$ 和 $stones$ 的长度，而 $\Sigma$ 是字符集，本题中字符集为所有大小写英文字母的集合。
 
 <!-- tabs:start -->
 
@@ -98,7 +98,7 @@ public:
 
 ```go
 func numJewelsInStones(jewels string, stones string) (ans int) {
-	s := make([]int, 128)
+	s := [128]int{}
 	for _, c := range jewels {
 		s[c] = 1
 	}
@@ -127,10 +127,10 @@ var numJewelsInStones = function (jewels, stones) {
 
 ```ts
 function numJewelsInStones(jewels: string, stones: string): number {
-    const set = new Set([...jewels]);
+    const s = new Set([...jewels]);
     let ans = 0;
     for (const c of stones) {
-        set.has(c) && ans++;
+        s.has(c) && ans++;
     }
     return ans;
 }

solution/0700-0799/0771.Jewels and Stones/README_EN.md

@@ -75,7 +75,7 @@ public:
 
 ```go
 func numJewelsInStones(jewels string, stones string) (ans int) {
-	s := make([]int, 128)
+	s := [128]int{}
 	for _, c := range jewels {
 		s[c] = 1
 	}
@@ -104,10 +104,10 @@ var numJewelsInStones = function (jewels, stones) {
 
 ```ts
 function numJewelsInStones(jewels: string, stones: string): number {
-    const set = new Set([...jewels]);
+    const s = new Set([...jewels]);
     let ans = 0;
     for (const c of stones) {
-        set.has(c) && ans++;
+        s.has(c) && ans++;
     }
     return ans;
 }

solution/0700-0799/0771.Jewels and Stones/Solution.go

@@ -1,5 +1,5 @@
 func numJewelsInStones(jewels string, stones string) (ans int) {
-	s := make([]int, 128)
+	s := [128]int{}
 	for _, c := range jewels {
 		s[c] = 1
 	}

solution/0700-0799/0771.Jewels and Stones/Solution.ts

@@ -1,8 +1,8 @@
 function numJewelsInStones(jewels: string, stones: string): number {
-    const set = new Set([...jewels]);
+    const s = new Set([...jewels]);
     let ans = 0;
     for (const c of stones) {
-        set.has(c) && ans++;
+        s.has(c) && ans++;
     }
     return ans;
 }

solution/2200-2299/2297.Jump Game VIII/README.md

@@ -55,28 +55,213 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：单调栈 + 动态规划**
+
+根据题目描述，我们实际上需要找到 $nums[i]$ 的下一个大于等于 $nums[i]$ 的位置 $j$，以及下一个小于 $nums[i]$ 的位置 $j$。我们利用单调栈可以在 $O(n)$ 的时间内找到这两个位置，然后构建邻接表 $g$，其中 $g[i]$ 表示下标 $i$ 可以跳转到的下标。
+
+然后我们使用动态规划求解最小代价。设 $f[i]$ 表示跳转到下标 $i$ 的最小代价，初始时 $f[0] = 0$，其余 $f[i] = \infty$。我们从小到大枚举下标 $i$，对于每个 $i$，我们枚举 $g[i]$ 中的每个下标 $j$，进行状态转移 $f[j] = \min(f[j], f[i] + costs[j])$。答案为 $f[n - 1]$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minCost(self, nums: List[int], costs: List[int]) -> int:
+        n = len(nums)
+        g = defaultdict(list)
+        stk = []
+        for i in range(n - 1, -1, -1):
+            while stk and nums[stk[-1]] < nums[i]:
+                stk.pop()
+            if stk:
+                g[i].append(stk[-1])
+            stk.append(i)
+
+        stk = []
+        for i in range(n - 1, -1, -1):
+            while stk and nums[stk[-1]] >= nums[i]:
+                stk.pop()
+            if stk:
+                g[i].append(stk[-1])
+            stk.append(i)
+
+        f = [inf] * n
+        f[0] = 0
+        for i in range(n):
+            for j in g[i]:
+                f[j] = min(f[j], f[i] + costs[j])
+        return f[n - 1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long minCost(int[] nums, int[] costs) {
+        int n = nums.length;
+        List<Integer>[] g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        Deque<Integer> stk = new ArrayDeque<>();
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && nums[stk.peek()] < nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                g[i].add(stk.peek());
+            }
+            stk.push(i);
+        }
+        stk.clear();
+        for (int i = n - 1; i >= 0; --i) {
+            while (!stk.isEmpty() && nums[stk.peek()] >= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.isEmpty()) {
+                g[i].add(stk.peek());
+            }
+            stk.push(i);
+        }
+        long[] f = new long[n];
+        Arrays.fill(f, 1L << 60);
+        f[0] = 0;
+        for (int i = 0; i < n; ++i) {
+            for (int j : g[i]) {
+                f[j] = Math.min(f[j], f[i] + costs[j]);
+            }
+        }
+        return f[n - 1];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    long long minCost(vector<int>& nums, vector<int>& costs) {
+        int n = nums.size();
+        vector<int> g[n];
+        stack<int> stk;
+        for (int i = n - 1; ~i; --i) {
+            while (!stk.empty() && nums[stk.top()] < nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                g[i].push_back(stk.top());
+            }
+            stk.push(i);
+        }
+        stk = stack<int>();
+        for (int i = n - 1; ~i; --i) {
+            while (!stk.empty() && nums[stk.top()] >= nums[i]) {
+                stk.pop();
+            }
+            if (!stk.empty()) {
+                g[i].push_back(stk.top());
+            }
+            stk.push(i);
+        }
+        vector<long long> f(n, 1e18);
+        f[0] = 0;
+        for (int i = 0; i < n; ++i) {
+            for (int j : g[i]) {
+                f[j] = min(f[j], f[i] + costs[j]);
+            }
+        }
+        return f[n - 1];
+    }
+};
+```
 
+### **Go**
+
+```go
+func minCost(nums []int, costs []int) int64 {
+	n := len(nums)
+	g := make([][]int, n)
+	stk := []int{}
+	for i := n - 1; i >= 0; i-- {
+		for len(stk) > 0 && nums[stk[len(stk)-1]] < nums[i] {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			g[i] = append(g[i], stk[len(stk)-1])
+		}
+		stk = append(stk, i)
+	}
+	stk = []int{}
+	for i := n - 1; i >= 0; i-- {
+		for len(stk) > 0 && nums[stk[len(stk)-1]] >= nums[i] {
+			stk = stk[:len(stk)-1]
+		}
+		if len(stk) > 0 {
+			g[i] = append(g[i], stk[len(stk)-1])
+		}
+		stk = append(stk, i)
+	}
+	f := make([]int64, n)
+	for i := 1; i < n; i++ {
+		f[i] = math.MaxInt64
+	}
+	for i := 0; i < n; i++ {
+		for _, j := range g[i] {
+			f[j] = min(f[j], f[i]+int64(costs[j]))
+		}
+	}
+	return f[n-1]
+}
+
+func min(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **TypeScript**
 
 ```ts
-
+function minCost(nums: number[], costs: number[]): number {
+    const n = nums.length;
+    const g: number[][] = Array.from({ length: n }, () => []);
+    const stk: number[] = [];
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && nums[stk[stk.length - 1]] < nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            g[i].push(stk[stk.length - 1]);
+        }
+        stk.push(i);
+    }
+    stk.length = 0;
+    for (let i = n - 1; i >= 0; --i) {
+        while (stk.length && nums[stk[stk.length - 1]] >= nums[i]) {
+            stk.pop();
+        }
+        if (stk.length) {
+            g[i].push(stk[stk.length - 1]);
+        }
+        stk.push(i);
+    }
+    const f: number[] = Array.from({ length: n }, () => Infinity);
+    f[0] = 0;
+    for (let i = 0; i < n; ++i) {
+        for (const j of g[i]) {
+            f[j] = Math.min(f[j], f[i] + costs[j]);
+        }
+    }
+    return f[n - 1];
+}
 ```
 
 ### **...**