Added longest increasing sequence in matrix

Author: FreeTymeKiyan

Other/LongestIncreasingSequenceInMat.java

@@ -0,0 +1,71 @@
+import java.util.*;
+
+/**
+ * Find the longest increasing(increasing means one step) sequence in an 
+ * integer matrix in 4 directions (up down left right), return the sequence
+ * 
+ * For Example:
+ * |1 2 3 4|
+ * |8 7 6 5|
+ * 
+ * Output: 
+ * [1, 2, 3, 4, 5, 6, 7, 8]
+ * 
+ * Tags: DP, DFS
+ */
+class LongestIncreasingSequenceInMat {
+    public static void main(String[] args) {
+        LongestIncreasingSequenceInMat l = new LongestIncreasingSequenceInMat();
+        int[][] mat = {
+            {1, 2, 3, 4}, 
+            {8, 7, 6, 5},
+            {9, 10, 11, 12}
+        };
+        System.out.println(Arrays.toString(l.longest(mat)));
+    }
+    
+    public static final int[][] DIRS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+    int[][] cache;
+    
+    /**
+     * DP
+     * d[i][j] = max{d[i+1][j], d[i-1][j], d[i][j+1], d[i][j-1]} + 1
+     */
+    public int[] longest(int[][] mat) {
+        int[] res = new int[]{};
+        if (mat == null || mat.length == 0 || mat[0].length == 0) return res;
+        int m = mat.length;
+        int n = mat[0].length;
+        cache = new int[m][n];
+        int maxStart = 0;
+        int maxPath = 0;
+        for (int i = 0; i < m; i++)
+            for (int j = 0; j < n; j++) {
+                int path = dfs(i, j, mat);
+                if (path > maxPath) {
+                    maxStart = mat[i][j];
+                    maxPath = path;
+                }
+            }
+        res = new int[maxPath];
+        // TODO recover the path, from maxStart with maxPath
+        for (int i = 0; i < maxPath; i++) res[i] = maxStart + i;
+        return res;
+    }
+    
+    private int dfs(int i, int j, int[][] mat) {
+        if (cache[i][j] != 0) return cache[i][j]; // has cache
+        int m = mat.length;
+        int n = mat[0].length;
+        for (int[] d : DIRS) { // search 4 directions
+            int ni = i + d[0]; // get next coordinates
+            int nj = j + d[1];
+            if (ni >= 0 && ni < m && nj >= 0 && nj < n 
+                    && mat[ni][nj] == mat[i][j] + 1) {
+                // if dfs(ni, nj) is bigger, update cache[i][j]
+                cache[i][j] = Math.max(cache[i][j], dfs(ni, nj, mat));
+            }
+        }
+        return ++cache[i][j]; // add cache[i][j] by 1 and return!
+    }
+}