Improved task 3459

Author: javadev

src/main/java/g3401_3500/s3459_length_of_longest_v_shaped_diagonal_segment/Solution.java

@@ -1,60 +1,79 @@
 package g3401_3500.s3459_length_of_longest_v_shaped_diagonal_segment;
 
 // #Hard #Array #Dynamic_Programming #Matrix #Memoization
-// #2025_02_18_Time_461_ms_(36.09%)_Space_127.47_MB_(39.48%)
-
-import java.util.Arrays;
+// #2025_02_21_Time_51_ms_(77.23%)_Space_75.55_MB_(90.55%)
 
 public class Solution {
-    private final int[][] ds = {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
-    private final int[] nx = {2, 2, 0};
-    private int[][] grid;
-    private int n;
-    private int m;
-    private int[][][][] dp;
+    private int[][] directions = {{-1, -1}, {-1, 1}, {1, 1}, {1, -1}};
 
-    public int lenOfVDiagonal(int[][] g) {
-        this.grid = g;
-        this.n = g.length;
-        this.m = g[0].length;
-        this.dp = new int[n][m][4][2];
-        for (int[][][] d1 : dp) {
-            for (int[][] d2 : d1) {
-                for (int[] d3 : d2) {
-                    Arrays.fill(d3, -1);
-                }
+    public int lenOfVDiagonal(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int[][] bottomLeft = new int[m][n];
+        int[][] bottomRight = new int[m][n];
+        int[][] topLeft = new int[m][n];
+        int[][] topRight = new int[m][n];
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                bottomLeft[i][j] = 1;
+                bottomRight[i][j] = 1;
+                topLeft[i][j] = 1;
+                topRight[i][j] = 1;
             }
         }
-        int res = 0;
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < m; j++) {
-                if (g[i][j] == 1) {
-                    for (int d = 0; d < 4; d++) {
-                        res = Math.max(res, dp(i, j, 1, d, 1));
-                    }
+        int ans = 0;
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                int x = grid[i][j];
+                if (x == 1) {
+                    ans = 1;
+                    continue;
+                }
+                if (i > 0 && j + 1 < n && grid[i - 1][j + 1] == 2 - x) {
+                    bottomLeft[i][j] = bottomLeft[i - 1][j + 1] + 1;
+                }
+                if (i > 0 && j > 0 && grid[i - 1][j - 1] == 2 - x) {
+                    bottomRight[i][j] = bottomRight[i - 1][j - 1] + 1;
                 }
             }
         }
-        return res;
-    }
-
-    private int dp(int i, int j, int x, int d, int k) {
-        if (i < 0 || i >= n || j < 0 || j >= m) {
-            return 0;
-        }
-        if (grid[i][j] != x) {
-            return 0;
-        }
-        if (dp[i][j][d][k] != -1) {
-            return dp[i][j][d][k];
+        for (int i = m - 1; i >= 0; --i) {
+            for (int j = n - 1; j >= 0; --j) {
+                int x = grid[i][j];
+                if (x == 1) {
+                    continue;
+                }
+                if (i + 1 < m && j + 1 < n && grid[i + 1][j + 1] == 2 - x) {
+                    topLeft[i][j] = topLeft[i + 1][j + 1] + 1;
+                }
+                if (i + 1 < m && j > 0 && grid[i + 1][j - 1] == 2 - x) {
+                    topRight[i][j] = topRight[i + 1][j - 1] + 1;
+                }
+            }
         }
-        int res = dp(i + ds[d][0], j + ds[d][1], nx[x], d, k) + 1;
-        if (k > 0) {
-            int d2 = (d + 1) % 4;
-            int res2 = dp(i + ds[d2][0], j + ds[d2][1], nx[x], d2, 0) + 1;
-            res = Math.max(res, res2);
+        int[][][] memo = {topLeft, topRight, bottomRight, bottomLeft};
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                int x = grid[i][j];
+                if (x == 1) {
+                    continue;
+                }
+                x >>= 1;
+                for (int k = 0; k < 4; ++k) {
+                    int v = memo[k][i][j];
+                    if ((v & 1) != x) {
+                        continue;
+                    }
+                    if (v + memo[k + 3 & 3][i][j] <= ans) {
+                        continue;
+                    }
+                    int[] d = directions[k];
+                    int ni = i - d[0] * v, nj = j - d[1] * v;
+                    if (ni >= 0 && nj >= 0 && ni < m && nj < n && grid[ni][nj] == 1) {
+                        ans = Math.max(ans, v + memo[k + 3 & 3][i][j]);
+                    }
+                }
+            }
         }
-        dp[i][j][d][k] = res;
-        return res;
+        return ans;
     }
 }