fd

Author: liwentian

README.md

@@ -248,6 +248,7 @@
 |324|[Wiggle Sort II](https://leetcode.com/problems/wiggle-sort-ii/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/WiggleSortII.java)|60|
 |325|[Maximum Size Subarray Sum Equals k](https://leetcode.com/problems/maximum-size-subarray-sum-equals-k/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/MaximumSizeSubarraySumEqualsK.java)|75|这题思路有意思，多做几遍|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/OddEvenLinkedList.java)|90|
+|329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/LongestIncreasingPathInAMatrix.java)|70|这题要多做几遍|
 |333|[Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/LargestBSTSubtree.java)|50|这道题虽然不难，但是折腾了很久，一定要多做|
 |334|[Increasing Triplet Subsequence](https://leetcode.com/problems/increasing-triplet-subsequence/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/IncreasingTripletSubsequence.java)|75|
 |335|[Self Crossing](https://leetcode.com/problems/self-crossing/)| [Java](https://github.com/dingjikerbo/leetcode/blob/master/solution/src/main/java/com/inuker/solution/SelfCrossing.java)|80|

google/src/main/java/com/leetcode/google/LongestIncreasingPathInAMatrix.java

@@ -0,0 +1,49 @@
+package com.leetcode.google;
+
+/**
+ * Created by liwentian on 2017/9/1.
+ */
+
+public class LongestIncreasingPathInAMatrix {
+
+    public int longestIncreasingPath(int[][] matrix) {
+        if (matrix.length == 0) {
+            return 0;
+        }
+        int row = matrix.length, col = matrix[0].length;
+        int max = 0;
+        int[][] cache = new int[row][col];
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                int len = dfs(matrix, i, j, cache);
+                max = Math.max(max, len);
+            }
+        }
+        return max;
+    }
+
+    private int dfs(int[][] matrix, int i, int j, int[][] cache) {
+        if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length) {
+            return 0;
+        }
+
+        if (cache[i][j] > 0) {
+            return cache[i][j];
+        }
+
+        int max = 1;
+
+        int[] dx = {1, -1, 0, 0}, dy = {0, 0, 1, -1};
+
+        for (int k = 0; k < dx.length; k++) {
+            int x = i + dx[k], y = j + dy[k];
+            if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[0].length || matrix[x][y] <= matrix[i][j]) {
+                continue;
+            }
+            max = Math.max(max, dfs(matrix, x, y, cache) + 1);
+        }
+
+        cache[i][j] = max;
+        return max;
+    }
+}

settings.gradle

@@ -1 +1 @@
-include ':app', ':tools', ':solution', ':google', ':library', ':facebook', ':amazon', ':topics', ':test'
+include ':app', ':solution', ':google', ':library', ':facebook', ':amazon', ':topics', ':test'

solution/src/main/java/com/inuker/solution/LongestIncreasingPathInAMatrix.java

@@ -0,0 +1,56 @@
+package com.inuker.solution;
+
+/**
+ * Created by liwentian on 2017/9/1.
+ */
+
+/**
+ * https://leetcode.com/articles/longest-increasing-path-matrix/
+ */
+
+/**
+ * 这题要注意缓存，否则会超时
+ */
+public class LongestIncreasingPathInAMatrix {
+
+    public int longestIncreasingPath(int[][] matrix) {
+        if (matrix.length == 0) {
+            return 0;
+        }
+        int row = matrix.length, col = matrix[0].length;
+        int max = 0;
+        int[][] cache = new int[row][col];
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                int len = dfs(matrix, i, j, cache);
+                max = Math.max(max, len);
+            }
+        }
+        return max;
+    }
+
+    private int dfs(int[][] matrix, int i, int j, int[][] cache) {
+        if (i < 0 || i >= matrix.length || j < 0 || j >= matrix[0].length) {
+            return 0;
+        }
+
+        if (cache[i][j] > 0) {
+            return cache[i][j];
+        }
+
+        int max = 1;
+
+        int[] dx = {1, -1, 0, 0}, dy = {0, 0, 1, -1};
+
+        for (int k = 0; k < dx.length; k++) {
+            int x = i + dx[k], y = j + dy[k];
+            if (x < 0 || x >= matrix.length || y < 0 || y >= matrix[0].length || matrix[x][y] <= matrix[i][j]) {
+                continue;
+            }
+            max = Math.max(max, dfs(matrix, x, y, cache) + 1);
+        }
+
+        cache[i][j] = max;
+        return max;
+    }
+}