diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/README.md b/solution/1200-1299/1289.Minimum Falling Path Sum II/README.md
index 783090cd12826..42d21abd1306d 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/README.md	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/README.md	
@@ -78,7 +78,7 @@ $$
 
 时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为矩阵的行数。
 
-实际上，我们也可以维护三个变量 $f$, $g$ 和 $fp$，分别表示前 $i$ 行的最小数字和、第 $i$ 行的第二小数字和以及第 $i$ 行的最小数字在第 $fp$ 列。这样我们就可以将时间复杂度降低到 $O(n^2)$，空间复杂度降低到 $O(1)$。
+我们注意到，状态 $f[i][j]$ 只与 $f[i - 1][k]$ 有关，因此我们可以使用滚动数组优化空间复杂度，将空间复杂度优化到 $O(n)$。
 
 <!-- tabs:start -->
 
@@ -88,12 +88,13 @@ $$
 class Solution:
     def minFallingPathSum(self, grid: List[List[int]]) -> int:
         n = len(grid)
-        f = [[0] * n for _ in range(n + 1)]
-        for i, row in enumerate(grid, 1):
-            for j, v in enumerate(row):
-                x = min((f[i - 1][k] for k in range(n) if k != j), default=0)
-                f[i][j] = v + x
-        return min(f[n])
+        f = [0] * n
+        for row in grid:
+            g = row[:]
+            for i in range(n):
+                g[i] += min((f[j] for j in range(n) if j != i), default=0)
+            f = g
+        return min(f)
 ```
 
 #### Java
@@ -102,24 +103,22 @@ class Solution:
 class Solution {
     public int minFallingPathSum(int[][] grid) {
         int n = grid.length;
-        int[][] f = new int[n + 1][n];
+        int[] f = new int[n];
         final int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = Math.min(x, f[i - 1][k]);
+        for (int[] row : grid) {
+            int[] g = row.clone();
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = Math.min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = g;
         }
-        int ans = inf;
-        for (int x : f[n]) {
-            ans = Math.min(ans, x);
-        }
-        return ans;
+        return Arrays.stream(f).min().getAsInt();
     }
 }
 ```
@@ -131,21 +130,22 @@ class Solution {
 public:
     int minFallingPathSum(vector<vector<int>>& grid) {
         int n = grid.size();
-        int f[n + 1][n];
-        memset(f, 0, sizeof(f));
-        const int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = min(x, f[i - 1][k]);
+        vector<int> f(n);
+        const int inf = 1e9;
+        for (const auto& row : grid) {
+            vector<int> g = row;
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = move(g);
         }
-        return *min_element(f[n], f[n] + n);
+        return ranges::min(f);
     }
 };
 ```
@@ -154,149 +154,75 @@ public:
 
 ```go
 func minFallingPathSum(grid [][]int) int {
-	n := len(grid)
-	f := make([][]int, n+1)
-	for i := range f {
-		f[i] = make([]int, n)
-	}
-	const inf = 1 << 30
-	for i, row := range grid {
-		i++
-		for j, v := range row {
-			x := inf
-			for k := range row {
-				if k != j {
-					x = min(x, f[i-1][k])
+	f := make([]int, len(grid))
+	const inf = math.MaxInt32
+	for _, row := range grid {
+		g := slices.Clone(row)
+		for i := range f {
+			t := inf
+			for j := range row {
+				if j != i {
+					t = min(t, f[j])
 				}
 			}
-			if x == inf {
-				x = 0
+			if t != inf {
+				g[i] += t
 			}
-			f[i][j] = v + x
 		}
+		f = g
 	}
-	return slices.Min(f[n])
+	return slices.Min(f)
 }
 ```
 
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### 方法二
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def minFallingPathSum(self, grid: List[List[int]]) -> int:
-        f = g = 0
-        fp = -1
-        for row in grid:
-            ff = gg = inf
-            ffp = -1
-            for j, v in enumerate(row):
-                s = (g if j == fp else f) + v
-                if s < ff:
-                    gg = ff
-                    ff = s
-                    ffp = j
-                elif s < gg:
-                    gg = s
-            f, g, fp = ff, gg, ffp
-        return f
-```
-
-#### Java
-
-```java
-class Solution {
-    public int minFallingPathSum(int[][] grid) {
-        int f = 0, g = 0;
-        int fp = -1;
-        final int inf = 1 << 30;
-        for (int[] row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < row.length; ++j) {
-                int s = (j != fp ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
+#### TypeScript
+
+```ts
+function minFallingPathSum(grid: number[][]): number {
+    const n = grid.length;
+    const f: number[] = Array(n).fill(0);
+    for (const row of grid) {
+        const g = [...row];
+        for (let i = 0; i < n; ++i) {
+            let t = Infinity;
+            for (let j = 0; j < n; ++j) {
+                if (j !== i) {
+                    t = Math.min(t, f[j]);
                 }
             }
-            f = ff;
-            g = gg;
-            fp = ffp;
+            g[i] += t === Infinity ? 0 : t;
         }
-        return f;
+        f.splice(0, n, ...g);
     }
+    return Math.min(...f);
 }
 ```
 
-#### C++
-
-```cpp
-class Solution {
-public:
-    int minFallingPathSum(vector<vector<int>>& grid) {
-        int n = grid.size();
-        int f = 0, g = 0, fp = -1;
-        const int inf = 1 << 30;
-        for (auto& row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < n; ++j) {
-                int s = (fp != j ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_falling_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut f = vec![0; n];
+        let inf = i32::MAX;
+
+        for row in grid {
+            let mut g = row.clone();
+            for i in 0..n {
+                let mut t = inf;
+                for j in 0..n {
+                    if j != i {
+                        t = t.min(f[j]);
+                    }
                 }
+                g[i] += if t == inf { 0 } else { t };
             }
-            f = ff;
-            g = gg;
-            fp = ffp;
+            f = g;
         }
-        return f;
-    }
-};
-```
-
-#### Go
 
-```go
-func minFallingPathSum(grid [][]int) int {
-	const inf = 1 << 30
-	f, g := 0, 0
-	fp := -1
-	for _, row := range grid {
-		ff, gg := inf, inf
-		ffp := -1
-		for j, v := range row {
-			s := f
-			if j == fp {
-				s = g
-			}
-			s += v
-			if s < ff {
-				ff, gg, ffp = s, ff, j
-			} else if s < gg {
-				gg = s
-			}
-		}
-		f, g, fp = ff, gg, ffp
-	}
-	return f
+        *f.iter().min().unwrap()
+    }
 }
 ```
 
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/README_EN.md b/solution/1200-1299/1289.Minimum Falling Path Sum II/README_EN.md
index a523050532e50..8d526eeb8ab0c 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/README_EN.md	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/README_EN.md	
@@ -30,7 +30,7 @@ tags:
 <pre>
 <strong>Input:</strong> grid = [[1,2,3],[4,5,6],[7,8,9]]
 <strong>Output:</strong> 13
-<strong>Explanation:</strong> 
+<strong>Explanation:</strong>
 The possible falling paths are:
 [1,5,9], [1,5,7], [1,6,7], [1,6,8],
 [2,4,8], [2,4,9], [2,6,7], [2,6,8],
@@ -60,7 +60,21 @@ The falling path with the smallest sum is&nbsp;[1,5,7], so the answer is&nbsp;13
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Dynamic Programming
+
+We define $f[i][j]$ to represent the minimum sum of the first $i$ rows, with the last number in the $j$-th column. The state transition equation is:
+
+$$
+f[i][j] = \min_{k \neq j} f[i - 1][k] + grid[i - 1][j]
+$$
+
+where $k$ represents the column of the number in the $(i - 1)$-th row, and the number in the $i$-th row and $j$-th column is $grid[i - 1][j]$.
+
+The final answer is the minimum value in $f[n]$.
+
+The time complexity is $O(n^3)$, and the space complexity is $O(n^2)$. Here, $n$ is the number of rows in the matrix.
+
+We note that the state $f[i][j]$ only depends on $f[i - 1][k]$, so we can use a rolling array to optimize the space complexity to $O(n)$.
 
 <!-- tabs:start -->
 
@@ -70,12 +84,13 @@ The falling path with the smallest sum is&nbsp;[1,5,7], so the answer is&nbsp;13
 class Solution:
     def minFallingPathSum(self, grid: List[List[int]]) -> int:
         n = len(grid)
-        f = [[0] * n for _ in range(n + 1)]
-        for i, row in enumerate(grid, 1):
-            for j, v in enumerate(row):
-                x = min((f[i - 1][k] for k in range(n) if k != j), default=0)
-                f[i][j] = v + x
-        return min(f[n])
+        f = [0] * n
+        for row in grid:
+            g = row[:]
+            for i in range(n):
+                g[i] += min((f[j] for j in range(n) if j != i), default=0)
+            f = g
+        return min(f)
 ```
 
 #### Java
@@ -84,24 +99,22 @@ class Solution:
 class Solution {
     public int minFallingPathSum(int[][] grid) {
         int n = grid.length;
-        int[][] f = new int[n + 1][n];
+        int[] f = new int[n];
         final int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = Math.min(x, f[i - 1][k]);
+        for (int[] row : grid) {
+            int[] g = row.clone();
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = Math.min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = g;
         }
-        int ans = inf;
-        for (int x : f[n]) {
-            ans = Math.min(ans, x);
-        }
-        return ans;
+        return Arrays.stream(f).min().getAsInt();
     }
 }
 ```
@@ -113,21 +126,22 @@ class Solution {
 public:
     int minFallingPathSum(vector<vector<int>>& grid) {
         int n = grid.size();
-        int f[n + 1][n];
-        memset(f, 0, sizeof(f));
-        const int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = min(x, f[i - 1][k]);
+        vector<int> f(n);
+        const int inf = 1e9;
+        for (const auto& row : grid) {
+            vector<int> g = row;
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = move(g);
         }
-        return *min_element(f[n], f[n] + n);
+        return ranges::min(f);
     }
 };
 ```
@@ -136,149 +150,75 @@ public:
 
 ```go
 func minFallingPathSum(grid [][]int) int {
-	n := len(grid)
-	f := make([][]int, n+1)
-	for i := range f {
-		f[i] = make([]int, n)
-	}
-	const inf = 1 << 30
-	for i, row := range grid {
-		i++
-		for j, v := range row {
-			x := inf
-			for k := range row {
-				if k != j {
-					x = min(x, f[i-1][k])
+	f := make([]int, len(grid))
+	const inf = math.MaxInt32
+	for _, row := range grid {
+		g := slices.Clone(row)
+		for i := range f {
+			t := inf
+			for j := range row {
+				if j != i {
+					t = min(t, f[j])
 				}
 			}
-			if x == inf {
-				x = 0
+			if t != inf {
+				g[i] += t
 			}
-			f[i][j] = v + x
 		}
+		f = g
 	}
-	return slices.Min(f[n])
+	return slices.Min(f)
 }
 ```
 
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### Solution 2
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def minFallingPathSum(self, grid: List[List[int]]) -> int:
-        f = g = 0
-        fp = -1
-        for row in grid:
-            ff = gg = inf
-            ffp = -1
-            for j, v in enumerate(row):
-                s = (g if j == fp else f) + v
-                if s < ff:
-                    gg = ff
-                    ff = s
-                    ffp = j
-                elif s < gg:
-                    gg = s
-            f, g, fp = ff, gg, ffp
-        return f
-```
-
-#### Java
-
-```java
-class Solution {
-    public int minFallingPathSum(int[][] grid) {
-        int f = 0, g = 0;
-        int fp = -1;
-        final int inf = 1 << 30;
-        for (int[] row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < row.length; ++j) {
-                int s = (j != fp ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
+#### TypeScript
+
+```ts
+function minFallingPathSum(grid: number[][]): number {
+    const n = grid.length;
+    const f: number[] = Array(n).fill(0);
+    for (const row of grid) {
+        const g = [...row];
+        for (let i = 0; i < n; ++i) {
+            let t = Infinity;
+            for (let j = 0; j < n; ++j) {
+                if (j !== i) {
+                    t = Math.min(t, f[j]);
                 }
             }
-            f = ff;
-            g = gg;
-            fp = ffp;
+            g[i] += t === Infinity ? 0 : t;
         }
-        return f;
+        f.splice(0, n, ...g);
     }
+    return Math.min(...f);
 }
 ```
 
-#### C++
-
-```cpp
-class Solution {
-public:
-    int minFallingPathSum(vector<vector<int>>& grid) {
-        int n = grid.size();
-        int f = 0, g = 0, fp = -1;
-        const int inf = 1 << 30;
-        for (auto& row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < n; ++j) {
-                int s = (fp != j ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_falling_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut f = vec![0; n];
+        let inf = i32::MAX;
+
+        for row in grid {
+            let mut g = row.clone();
+            for i in 0..n {
+                let mut t = inf;
+                for j in 0..n {
+                    if j != i {
+                        t = t.min(f[j]);
+                    }
                 }
+                g[i] += if t == inf { 0 } else { t };
             }
-            f = ff;
-            g = gg;
-            fp = ffp;
+            f = g;
         }
-        return f;
-    }
-};
-```
 
-#### Go
-
-```go
-func minFallingPathSum(grid [][]int) int {
-	const inf = 1 << 30
-	f, g := 0, 0
-	fp := -1
-	for _, row := range grid {
-		ff, gg := inf, inf
-		ffp := -1
-		for j, v := range row {
-			s := f
-			if j == fp {
-				s = g
-			}
-			s += v
-			if s < ff {
-				ff, gg, ffp = s, ff, j
-			} else if s < gg {
-				gg = s
-			}
-		}
-		f, g, fp = ff, gg, ffp
-	}
-	return f
+        *f.iter().min().unwrap()
+    }
 }
 ```
 
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.cpp b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.cpp
index e7f1259a6ba0d..4cdd588ceee42 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.cpp	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.cpp	
@@ -2,20 +2,21 @@ class Solution {
 public:
     int minFallingPathSum(vector<vector<int>>& grid) {
         int n = grid.size();
-        int f[n + 1][n];
-        memset(f, 0, sizeof(f));
-        const int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = min(x, f[i - 1][k]);
+        vector<int> f(n);
+        const int inf = 1e9;
+        for (const auto& row : grid) {
+            vector<int> g = row;
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = move(g);
         }
-        return *min_element(f[n], f[n] + n);
+        return ranges::min(f);
     }
-};
\ No newline at end of file
+};
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.go b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.go
index d433f003dc9c9..7c5e515fd0b13 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.go	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.go	
@@ -1,24 +1,20 @@
 func minFallingPathSum(grid [][]int) int {
-	n := len(grid)
-	f := make([][]int, n+1)
-	for i := range f {
-		f[i] = make([]int, n)
-	}
-	const inf = 1 << 30
-	for i, row := range grid {
-		i++
-		for j, v := range row {
-			x := inf
-			for k := range row {
-				if k != j {
-					x = min(x, f[i-1][k])
+	f := make([]int, len(grid))
+	const inf = math.MaxInt32
+	for _, row := range grid {
+		g := slices.Clone(row)
+		for i := range f {
+			t := inf
+			for j := range row {
+				if j != i {
+					t = min(t, f[j])
 				}
 			}
-			if x == inf {
-				x = 0
+			if t != inf {
+				g[i] += t
 			}
-			f[i][j] = v + x
 		}
+		f = g
 	}
-	return slices.Min(f[n])
-}
\ No newline at end of file
+	return slices.Min(f)
+}
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.java b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.java
index 6d0a1d8932781..7fd75fa6f5b98 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.java	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.java	
@@ -1,23 +1,21 @@
 class Solution {
     public int minFallingPathSum(int[][] grid) {
         int n = grid.length;
-        int[][] f = new int[n + 1][n];
+        int[] f = new int[n];
         final int inf = 1 << 30;
-        for (int i = 1; i <= n; ++i) {
-            for (int j = 0; j < n; ++j) {
-                int x = inf;
-                for (int k = 0; k < n; ++k) {
-                    if (k != j) {
-                        x = Math.min(x, f[i - 1][k]);
+        for (int[] row : grid) {
+            int[] g = row.clone();
+            for (int i = 0; i < n; ++i) {
+                int t = inf;
+                for (int j = 0; j < n; ++j) {
+                    if (j != i) {
+                        t = Math.min(t, f[j]);
                     }
                 }
-                f[i][j] = grid[i - 1][j] + (x == inf ? 0 : x);
+                g[i] += (t == inf ? 0 : t);
             }
+            f = g;
         }
-        int ans = inf;
-        for (int x : f[n]) {
-            ans = Math.min(ans, x);
-        }
-        return ans;
+        return Arrays.stream(f).min().getAsInt();
     }
-}
\ No newline at end of file
+}
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.py b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.py
index 11b746546e142..6c562d62f17f9 100644
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.py	
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.py	
@@ -1,9 +1,10 @@
 class Solution:
     def minFallingPathSum(self, grid: List[List[int]]) -> int:
         n = len(grid)
-        f = [[0] * n for _ in range(n + 1)]
-        for i, row in enumerate(grid, 1):
-            for j, v in enumerate(row):
-                x = min((f[i - 1][k] for k in range(n) if k != j), default=0)
-                f[i][j] = v + x
-        return min(f[n])
+        f = [0] * n
+        for row in grid:
+            g = row[:]
+            for i in range(n):
+                g[i] += min((f[j] for j in range(n) if j != i), default=0)
+            f = g
+        return min(f)
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.rs b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.rs
new file mode 100644
index 0000000000000..213d65019fc6f
--- /dev/null
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.rs	
@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn min_falling_path_sum(grid: Vec<Vec<i32>>) -> i32 {
+        let n = grid.len();
+        let mut f = vec![0; n];
+        let inf = i32::MAX;
+
+        for row in grid {
+            let mut g = row.clone();
+            for i in 0..n {
+                let mut t = inf;
+                for j in 0..n {
+                    if j != i {
+                        t = t.min(f[j]);
+                    }
+                }
+                g[i] += if t == inf { 0 } else { t };
+            }
+            f = g;
+        }
+
+        *f.iter().min().unwrap()
+    }
+}
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.ts b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.ts
new file mode 100644
index 0000000000000..637247c512627
--- /dev/null
+++ b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution.ts	
@@ -0,0 +1,18 @@
+function minFallingPathSum(grid: number[][]): number {
+    const n = grid.length;
+    const f: number[] = Array(n).fill(0);
+    for (const row of grid) {
+        const g = [...row];
+        for (let i = 0; i < n; ++i) {
+            let t = Infinity;
+            for (let j = 0; j < n; ++j) {
+                if (j !== i) {
+                    t = Math.min(t, f[j]);
+                }
+            }
+            g[i] += t === Infinity ? 0 : t;
+        }
+        f.splice(0, n, ...g);
+    }
+    return Math.min(...f);
+}
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.cpp b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.cpp
deleted file mode 100644
index dd8103dbee49a..0000000000000
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.cpp	
+++ /dev/null
@@ -1,26 +0,0 @@
-class Solution {
-public:
-    int minFallingPathSum(vector<vector<int>>& grid) {
-        int n = grid.size();
-        int f = 0, g = 0, fp = -1;
-        const int inf = 1 << 30;
-        for (auto& row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < n; ++j) {
-                int s = (fp != j ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
-                }
-            }
-            f = ff;
-            g = gg;
-            fp = ffp;
-        }
-        return f;
-    }
-};
\ No newline at end of file
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.go b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.go
deleted file mode 100644
index 676046a11d8be..0000000000000
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.go	
+++ /dev/null
@@ -1,23 +0,0 @@
-func minFallingPathSum(grid [][]int) int {
-	const inf = 1 << 30
-	f, g := 0, 0
-	fp := -1
-	for _, row := range grid {
-		ff, gg := inf, inf
-		ffp := -1
-		for j, v := range row {
-			s := f
-			if j == fp {
-				s = g
-			}
-			s += v
-			if s < ff {
-				ff, gg, ffp = s, ff, j
-			} else if s < gg {
-				gg = s
-			}
-		}
-		f, g, fp = ff, gg, ffp
-	}
-	return f
-}
\ No newline at end of file
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.java b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.java
deleted file mode 100644
index 270e4c3995dbc..0000000000000
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.java	
+++ /dev/null
@@ -1,25 +0,0 @@
-class Solution {
-    public int minFallingPathSum(int[][] grid) {
-        int f = 0, g = 0;
-        int fp = -1;
-        final int inf = 1 << 30;
-        for (int[] row : grid) {
-            int ff = inf, gg = inf;
-            int ffp = -1;
-            for (int j = 0; j < row.length; ++j) {
-                int s = (j != fp ? f : g) + row[j];
-                if (s < ff) {
-                    gg = ff;
-                    ff = s;
-                    ffp = j;
-                } else if (s < gg) {
-                    gg = s;
-                }
-            }
-            f = ff;
-            g = gg;
-            fp = ffp;
-        }
-        return f;
-    }
-}
\ No newline at end of file
diff --git a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.py b/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.py
deleted file mode 100644
index 6798c1c2f38f4..0000000000000
--- a/solution/1200-1299/1289.Minimum Falling Path Sum II/Solution2.py	
+++ /dev/null
@@ -1,17 +0,0 @@
-class Solution:
-    def minFallingPathSum(self, grid: List[List[int]]) -> int:
-        f = g = 0
-        fp = -1
-        for row in grid:
-            ff = gg = inf
-            ffp = -1
-            for j, v in enumerate(row):
-                s = (g if j == fp else f) + v
-                if s < ff:
-                    gg = ff
-                    ff = s
-                    ffp = j
-                elif s < gg:
-                    gg = s
-            f, g, fp = ff, gg, ffp
-        return f