Add solution and test-cases for problem 3459

Author: 0xff-dev

leetcode/3401-3500/3459.Length-of-Longest-V-Shaped-Diagonal-Segment/1.jpg

@@ -1,28 +1,75 @@
 # [3459.Length of Longest V-Shaped Diagonal Segment][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+You are given a 2D integer matrix `grid` of size `n x m`, where each element is either `0`, `1`, or `2`.
+
+A **V-shaped diagonal segment** is defined as:
+
+- The segment starts with `1`.
+- The subsequent elements follow this infinite sequence: `2, 0, 2, 0, ...`.
+- The segment:
+
+    - Starts **along** a diagonal direction (top-left to bottom-right, bottom-right to top-left, top-right to bottom-left, or bottom-left to top-right).
+    - Continues the **sequence** in the same diagonal direction.
+    - Makes **at most one clockwise 90-degree turn** to another diagonal direction while **maintaining** the sequence.
+
+![e](./e.jpg)
+
+Return the **length** of the **longest V-shaped diagonal segment**. If no valid segment exists, return 0.
+
+**Example 1:**  
+
+![1](./1.jpg)
+
+```
+Input: grid = [[2,2,1,2,2],[2,0,2,2,0],[2,0,1,1,0],[1,0,2,2,2],[2,0,0,2,2]]
+
+Output: 5
+
+Explanation:
+
+The longest V-shaped diagonal segment has a length of 5 and follows these coordinates: (0,2) → (1,3) → (2,4), takes a 90-degree clockwise turn at (2,4), and continues as (3,3) → (4,2).
+```
 
-**Example 1:**
+**Example 2:**  
+
+![2](./2.jpg)
 
 ```
-Input: a = "11", b = "1"
-Output: "100"
+Input: grid = [[2,2,2,2,2],[2,0,2,2,0],[2,0,1,1,0],[1,0,2,2,2],[2,0,0,2,2]]
+
+Output: 4
+
+Explanation:
+
+The longest V-shaped diagonal segment has a length of 4 and follows these coordinates: (2,3) → (3,2), takes a 90-degree clockwise turn at (3,2), and continues as (2,1) → (1,0).
+```
+
+**Example 3:**  
+
+![3](./3.jpg)
+
 ```
+Input: grid = [[1,2,2,2,2],[2,2,2,2,0],[2,0,0,0,0],[0,0,2,2,2],[2,0,0,2,0]]
+
+Output: 5
 
-## 题意
-> ...
+Explanation:
+
+The longest V-shaped diagonal segment has a length of 5 and follows these coordinates: (0,0) → (1,1) → (2,2) → (3,3) → (4,4).
+```
 
-## 题解
+**Example 4:**
 
-### 思路1
-> ...
-Length of Longest V-Shaped Diagonal Segment
-```go
 ```
+Input: grid = [[1]]
 
+Output: 1
+
+Explanation:
+
+The longest V-shaped diagonal segment has a length of 1 and follows these coordinates: (0,0).
+```
 
 ## 结语
 

leetcode/3401-3500/3459.Length-of-Longest-V-Shaped-Diagonal-Segment/2.jpg

@@ -1,5 +1,55 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(grid [][]int) int {
+	dirs := [4][2]int{{1, 1}, {1, -1}, {-1, -1}, {-1, 1}}
+	m, n := len(grid), len(grid[0])
+	memo := make([][][4][2]int, m)
+	for i := range memo {
+		memo[i] = make([][4][2]int, n)
+		for j := range memo[i] {
+			for k := range memo[i][j] {
+				for l := range memo[i][j][k] {
+					memo[i][j][k][l] = -1
+				}
+			}
+		}
+	}
+
+	var dfs func(cx, cy, direction int, turn bool, target int) int
+	dfs = func(cx, cy, direction int, turn bool, target int) int {
+		nx, ny := cx+dirs[direction][0], cy+dirs[direction][1]
+		/* If it goes beyond the boundary or the next node's value is not the target value, then return */
+		if nx < 0 || ny < 0 || nx >= m || ny >= n || grid[nx][ny] != target {
+			return 0
+		}
+
+		turnInt := 0
+		if turn {
+			turnInt = 1
+		}
+		if memo[nx][ny][direction][turnInt] != -1 {
+			return memo[nx][ny][direction][turnInt]
+		}
+
+		/* Continue walking in the original direction. */
+		maxStep := dfs(nx, ny, direction, turn, 2-target)
+		if turn {
+			/* Clockwise rotate 90 degrees turn */
+			maxStep = max(maxStep, dfs(nx, ny, (direction+1)%4, false, 2-target))
+		}
+		memo[nx][ny][direction][turnInt] = maxStep + 1
+		return maxStep + 1
+	}
+
+	res := 0
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			if grid[i][j] == 1 {
+				for direction := 0; direction < 4; direction++ {
+					res = max(res, dfs(i, j, direction, true, 2)+1)
+				}
+			}
+		}
+	}
+	return res
 }

leetcode/3401-3500/3459.Length-of-Longest-V-Shaped-Diagonal-Segment/3.jpg

@@ -10,12 +10,12 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs [][]int
+		expect int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", [][]int{{2, 2, 1, 2, 2}, {2, 0, 2, 2, 0}, {2, 0, 1, 1, 0}, {1, 0, 2, 2, 2}, {2, 0, 0, 2, 2}}, 5},
+		{"TestCase2", [][]int{{2, 2, 2, 2, 2}, {2, 0, 2, 2, 0}, {2, 0, 1, 1, 0}, {1, 0, 2, 2, 2}, {2, 0, 0, 2, 2}}, 4},
+		{"TestCase3", [][]int{{1, 2, 2, 2, 2}, {2, 2, 2, 2, 0}, {2, 0, 0, 0, 0}, {0, 0, 2, 2, 2}, {2, 0, 0, 2, 0}}, 5},
 	}
 
 	//	开始测试
@@ -30,10 +30,10 @@ func TestSolution(t *testing.T) {
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }