feat: add solutions to lc problem: No.3459

No.3459.Length of Longest V-Shaped Diagonal Segment

Author: yanglbme

solution/3400-3499/3459.Length of Longest V-Shaped Diagonal Segment/README.md

@@ -114,65 +114,203 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：记忆化搜索
 
-<!-- tabs:start -->
+我们设计一个函数 $\text{dfs}(i, j, k, \textit{cnt})$，表示上一个位置为 $(i, j)$，当前方向为 $k$，剩余可转向次数为 $\textit{cnt}$ 时，返回最长的 V 形对角线段长度。
 
-#### Python3
+函数 $\text{dfs}$ 的执行逻辑如下：
 
-```python
-class Solution:
-    def lenOfVDiagonal(self, grid: List[List[int]]) -> int:
-        m, n = len(grid), len(grid[0])
-        next_digit = {1: 2, 2: 0, 0: 2}
+我们首先基于上一个位置以及当前的方向，计算当前得到当前位置 $(x, y)$，然后计算当前目标值 $\textit{target}$。如果 $x$ 或 $y$ 不在矩阵范围内，或者 $\textit{grid}[x][y] \neq \textit{target}$，返回 $0$。
 
-        def within_bounds(i, j):
-            return 0 <= i < m and 0 <= j < n
+否则，我们有两种选择：
 
-        @cache
-        def f(i, j, di, dj, turned):
-            result = 1
-            successor = next_digit[grid[i][j]]
+1. 继续沿着当前方向前进。
+2. 在当前位置进行顺时针 90 度转向，然后继续前进。
+
+我们可以通过改变方向来实现顺时针 90 度转向。具体来说，如果当前方向为 $k$，则顺时针 90 度转向后的新方向为 $(k + 1) \bmod 4$。最后，我们选择这两种选择中的最大值作为当前状态的结果。
+
+在主函数中，我们遍历整个矩阵，对于每个值为 1 的位置，尝试四个方向的搜索，并更新答案。
+
+遍历结束后，返回答案即可。
 
-            if within_bounds(i + di, j + dj) and grid[i + di][j + dj] == successor:
-                result = 1 + f(i + di, j + dj, di, dj, turned)
+为了避免重复计算，我们使用记忆化搜索来缓存中间结果。
 
-            if not turned:
-                di, dj = dj, -di
-                if within_bounds(i + di, j + dj) and grid[i + di][j + dj] == successor:
-                    result = max(result, 1 + f(i + di, j + dj, di, dj, True))
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
-            return result
+<!-- tabs:start -->
 
-        directions = ((1, 1), (-1, 1), (1, -1), (-1, -1))
-        result = 0
+#### Python3
 
-        for i in range(m):
-            for j in range(n):
-                if grid[i][j] != 1:
-                    continue
-                for di, dj in directions:
-                    result = max(result, f(i, j, di, dj, False))
+```python
+class Solution:
+    def lenOfVDiagonal(self, grid: List[List[int]]) -> int:
+        @cache
+        def dfs(i: int, j: int, k: int, cnt: int) -> int:
+            x, y = i + dirs[k], j + dirs[k + 1]
+            target = 2 if grid[i][j] == 1 else (2 - grid[i][j])
+            if not 0 <= x < m or not 0 <= y < n or grid[x][y] != target:
+                return 0
+            res = dfs(x, y, k, cnt)
+            if cnt > 0:
+                res = max(res, dfs(x, y, (k + 1) % 4, 0))
+            return 1 + res
 
-        return result
+        m, n = len(grid), len(grid[0])
+        dirs = (1, 1, -1, -1, 1)
+        ans = 0
+        for i, row in enumerate(grid):
+            for j, x in enumerate(row):
+                if x == 1:
+                    for k in range(4):
+                        ans = max(ans, dfs(i, j, k, 1) + 1)
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private int m, n;
+    private final int[] dirs = {1, 1, -1, -1, 1};
+    private Integer[][][][] f;
+
+    public int lenOfVDiagonal(int[][] grid) {
+        m = grid.length;
+        n = grid[0].length;
+        f = new Integer[m][n][4][2];
+        int ans = 0;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (grid[i][j] == 1) {
+                    for (int k = 0; k < 4; k++) {
+                        ans = Math.max(ans, dfs(grid, i, j, k, 1) + 1);
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+
+    private int dfs(int[][] grid, int i, int j, int k, int cnt) {
+        if (f[i][j][k][cnt] != null) {
+            return f[i][j][k][cnt];
+        }
+        int x = i + dirs[k];
+        int y = j + dirs[k + 1];
+        int target = grid[i][j] == 1 ? 2 : (2 - grid[i][j]);
+        if (x < 0 || x >= m || y < 0 || y >= n || grid[x][y] != target) {
+            f[i][j][k][cnt] = 0;
+            return 0;
+        }
+        int res = dfs(grid, x, y, k, cnt);
+        if (cnt > 0) {
+            res = Math.max(res, dfs(grid, x, y, (k + 1) % 4, 0));
+        }
+        f[i][j][k][cnt] = 1 + res;
+        return 1 + res;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    static constexpr int MAXN = 501;
+    int f[MAXN][MAXN][4][2];
+
+    int lenOfVDiagonal(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        int dirs[5] = {1, 1, -1, -1, 1};
+        memset(f, -1, sizeof(f));
+
+        auto dfs = [&](this auto&& dfs, int i, int j, int k, int cnt) -> int {
+            if (f[i][j][k][cnt] != -1) {
+                return f[i][j][k][cnt];
+            }
+            int x = i + dirs[k];
+            int y = j + dirs[k + 1];
+            int target = grid[i][j] == 1 ? 2 : (2 - grid[i][j]);
+            if (x < 0 || x >= m || y < 0 || y >= n || grid[x][y] != target) {
+                f[i][j][k][cnt] = 0;
+                return 0;
+            }
+            int res = dfs(x, y, k, cnt);
+            if (cnt > 0) {
+                res = max(res, dfs(x, y, (k + 1) % 4, 0));
+            }
+            f[i][j][k][cnt] = 1 + res;
+            return 1 + res;
+        };
+
+        int ans = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (grid[i][j] == 1) {
+                    for (int k = 0; k < 4; ++k) {
+                        ans = max(ans, dfs(i, j, k, 1) + 1);
+                    }
+                }
+            }
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
-
+func lenOfVDiagonal(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	dirs := []int{1, 1, -1, -1, 1}
+	f := make([][][4][2]int, m)
+	for i := range f {
+		f[i] = make([][4][2]int, n)
+	}
+
+	var dfs func(i, j, k, cnt int) int
+	dfs = func(i, j, k, cnt int) int {
+		if f[i][j][k][cnt] != 0 {
+			return f[i][j][k][cnt]
+		}
+
+		x := i + dirs[k]
+		y := j + dirs[k+1]
+
+		var target int
+		if grid[i][j] == 1 {
+			target = 2
+		} else {
+			target = 2 - grid[i][j]
+		}
+
+		if x < 0 || x >= m || y < 0 || y >= n || grid[x][y] != target {
+			f[i][j][k][cnt] = 0
+			return 0
+		}
+
+		res := dfs(x, y, k, cnt)
+		if cnt > 0 {
+			res = max(res, dfs(x, y, (k+1)%4, 0))
+		}
+		f[i][j][k][cnt] = res + 1
+		return res + 1
+	}
+
+	ans := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				for k := 0; k < 4; k++ {
+					ans = max(ans, dfs(i, j, k, 1)+1)
+				}
+			}
+		}
+	}
+	return ans
+}
 ```
 
 <!-- tabs:end -->