feat: add solutions to lc problem: No.0877

No.0877.Stone Game

Author: yanglbme

solution/0800-0899/0877.Stone Game/README.md

@@ -51,51 +51,111 @@ Alice 先开始，只能拿前 5 颗或后 5 颗石子 。
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：动态规划**
+**方法一：记忆化搜索**
 
-设 $dp[i][j]$ 表示在石子堆 $[i,j]$ 中，当前玩家与另一个玩家的石子数量的最大差值。
+我们设计一个函数 $dfs(i, j)$，表示从第 $i$ 堆石子到第 $j$ 堆石子，当前玩家与另一个玩家的石子数量之差的最大值。那么答案就是 $dfs(0, n - 1) \gt 0$。
 
-若 $dp[0][n-1] \gt 0$，说明当前玩家能赢得比赛。
+函数 $dfs(i, j)$ 的计算方法如下：
 
-时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是石子堆的数量。
+-   如果 $i \gt j$，说明当前没有石子了，所以当前玩家没有石子可以拿，差值为 $0$，即 $dfs(i, j) = 0$。
+-   否则，当前玩家有两种选择，如果选择第 $i$ 堆石子，那么当前玩家与另一个玩家的石子数量之差为 $piles[i] - dfs(i + 1, j)$；如果选择第 $j$ 堆石子，那么当前玩家与另一个玩家的石子数量之差为 $piles[j] - dfs(i, j - 1)$。当前玩家会选择两种情况中差值较大的情况，也就是说 $dfs(i, j) = \max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1))$。
+
+最后，我们只需要判断 $dfs(0, n - 1) \gt 0$ 即可。
+
+为了避免重复计算，我们可以使用记忆化搜索的方法，用一个数组 $f$ 记录所有的 $dfs(i, j)$ 的值，当函数再次被调用到时，我们可以直接从 $f$ 中取出答案而不需要重新计算。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是石子的堆数。
+
+**方法二：动态规划**
+
+我们也可以使用动态规划的方法，定义 $f[i][j]$ 表示当前玩家在 $piles[i..j]$ 这部分石子中能够获得的最大石子数的差值。那么最后答案就是 $f[0][n - 1] \gt 0$。
+
+初始时 $f[i][i]=piles[i]$，因为只有一堆石子，所以当前玩家只能拿取这堆石子，差值为 $piles[i]$。
+
+考虑 $f[i][j]$，其中 $i \lt j$，有两种情况：
+
+-   如果当前玩家拿走了石子堆 $piles[i]$，那么剩下的石子堆为 $piles[i + 1..j]$，此时轮到另一个玩家进行游戏，所以 $f[i][j] = piles[i] - f[i + 1][j]$。
+-   如果当前玩家拿走了石子堆 $piles[j]$，那么剩下的石子堆为 $piles[i..j - 1]$，此时轮到另一个玩家进行游戏，所以 $f[i][j] = piles[j] - f[i][j - 1]$。
+
+因此，最终的状态转移方程为 $f[i][j] = \max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1])$。
+
+最后，我们只需要判断 $f[0][n - 1] \gt 0$ 即可。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是石子的堆数。
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```python
+class Solution:
+    def stoneGame(self, piles: List[int]) -> bool:
+        @cache
+        def dfs(i: int, j: int) -> int:
+            if i > j:
+                return 0
+            return max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1))
+
+        return dfs(0, len(piles) - 1) > 0
+```
+
 ```python
 class Solution:
     def stoneGame(self, piles: List[int]) -> bool:
         n = len(piles)
-        dp = [[0] * n for _ in range(n)]
-        for i, v in enumerate(piles):
-            dp[i][i] = v
+        f = [[0] * n for _ in range(n)]
+        for i, x in enumerate(piles):
+            f[i][i] = x
         for i in range(n - 2, -1, -1):
             for j in range(i + 1, n):
-                dp[i][j] = max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1])
-        return dp[0][-1] > 0
+                f[i][j] = max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1])
+        return f[0][n - 1] > 0
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
+```java
+class Solution {
+    private int[] piles;
+    private int[][] f;
+
+    public boolean stoneGame(int[] piles) {
+        this.piles = piles;
+        int n = piles.length;
+        f = new int[n][n];
+        return dfs(0, n - 1) > 0;
+    }
+
+    private int dfs(int i, int j) {
+        if (i > j) {
+            return 0;
+        }
+        if (f[i][j] != 0) {
+            return f[i][j];
+        }
+        return f[i][j] = Math.max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1));
+    }
+}
+```
+
 ```java
 class Solution {
     public boolean stoneGame(int[] piles) {
         int n = piles.length;
-        int[][] dp = new int[n][n];
+        int[][] f = new int[n][n];
         for (int i = 0; i < n; ++i) {
-            dp[i][i] = piles[i];
+            f[i][i] = piles[i];
         }
         for (int i = n - 2; i >= 0; --i) {
             for (int j = i + 1; j < n; ++j) {
-                dp[i][j] = Math.max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1]);
+                f[i][j] = Math.max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
             }
         }
-        return dp[0][n - 1] > 0;
+        return f[0][n - 1] > 0;
     }
 }
 ```
@@ -107,12 +167,38 @@ class Solution {
 public:
     bool stoneGame(vector<int>& piles) {
         int n = piles.size();
-        vector<vector<int>> dp(n, vector<int>(n));
-        for (int i = 0; i < n; ++i) dp[i][i] = piles[i];
-        for (int i = n - 2; ~i; --i)
-            for (int j = i + 1; j < n; ++j)
-                dp[i][j] = max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1]);
-        return dp[0][n - 1] > 0;
+        int f[n][n];
+        memset(f, 0, sizeof(f));
+        function<int(int, int)> dfs = [&](int i, int j) -> int {
+            if (i > j) {
+                return 0;
+            }
+            if (f[i][j]) {
+                return f[i][j];
+            }
+            return f[i][j] = max(piles[i] - dfs(i + 1, j), piles[j] - dfs(i, j - 1));
+        };
+        return dfs(0, n - 1) > 0;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    bool stoneGame(vector<int>& piles) {
+        int n = piles.size();
+        int f[n][n];
+        memset(f, 0, sizeof(f));
+        for (int i = 0; i < n; ++i) {
+            f[i][i] = piles[i];
+        }
+        for (int i = n - 2; ~i; --i) {
+            for (int j = i + 1; j < n; ++j) {
+                f[i][j] = max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
+            }
+        }
+        return f[0][n - 1] > 0;
     }
 };
 ```
@@ -122,17 +208,45 @@ public:
 ```go
 func stoneGame(piles []int) bool {
 	n := len(piles)
-	dp := make([][]int, n)
-	for i, v := range piles {
-		dp[i] = make([]int, n)
-		dp[i][i] = v
+	f := make([][]int, n)
+	for i := range f {
+		f[i] = make([]int, n)
+	}
+	var dfs func(i, j int) int
+	dfs = func(i, j int) int {
+		if i > j {
+			return 0
+		}
+		if f[i][j] == 0 {
+			f[i][j] = max(piles[i]-dfs(i+1, j), piles[j]-dfs(i, j-1))
+		}
+		return f[i][j]
+	}
+	return dfs(0, n-1) > 0
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
+```go
+func stoneGame(piles []int) bool {
+	n := len(piles)
+	f := make([][]int, n)
+	for i, x := range piles {
+		f[i] = make([]int, n)
+		f[i][i] = x
 	}
 	for i := n - 2; i >= 0; i-- {
 		for j := i + 1; j < n; j++ {
-			dp[i][j] = max(piles[i]-dp[i+1][j], piles[j]-dp[i][j-1])
+			f[i][j] = max(piles[i]-f[i+1][j], piles[j]-f[i][j-1])
 		}
 	}
-	return dp[0][n-1] > 0
+	return f[0][n-1] > 0
 }
 
 func max(a, b int) int {
@@ -143,6 +257,44 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function stoneGame(piles: number[]): boolean {
+    const n = piles.length;
+    const f: number[][] = new Array(n).fill(0).map(() => new Array(n).fill(0));
+    const dfs = (i: number, j: number): number => {
+        if (i > j) {
+            return 0;
+        }
+        if (f[i][j] === 0) {
+            f[i][j] = Math.max(
+                piles[i] - dfs(i + 1, j),
+                piles[j] - dfs(i, j - 1),
+            );
+        }
+        return f[i][j];
+    };
+    return dfs(0, n - 1) > 0;
+}
+```
+
+```ts
+function stoneGame(piles: number[]): boolean {
+    const n = piles.length;
+    const f: number[][] = new Array(n).fill(0).map(() => new Array(n).fill(0));
+    for (let i = 0; i < n; ++i) {
+        f[i][i] = piles[i];
+    }
+    for (let i = n - 2; i >= 0; --i) {
+        for (let j = i + 1; j < n; ++j) {
+            f[i][j] = Math.max(piles[i] - f[i + 1][j], piles[j] - f[i][j - 1]);
+        }
+    }
+    return f[0][n - 1] > 0;
+}
+```
+
 ### **...**
 
 ```