329

Author: lzl124631x

leetcode/329. Longest Increasing Path in a Matrix/README.md

@@ -35,39 +35,39 @@ For each position `matrix[x][y]`,
 * otherwise, probe the 4 directions, `cnt[x][y]` is one greater than its largest neightbor.
 
 ```cpp
-// OJ: https://leetcode.com/problems/longest-increasing-path-in-a-matrix
+// OJ: https://leetcode.com/problems/longest-increasing-path-in-a-matrix/
 // Author: github.com/lzl124631x
 // Time: O(MN)
 // Space: O(MN)
 class Solution {
-private:
-  int M, N, ans = 0, dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
-  vector<vector<int>> cnt;
-  int dfs(vector<vector<int>> &matrix, int x, int y) {
-    if (cnt[x][y]) return cnt[x][y];
-    cnt[x][y] = 1;
-    for (auto dir : dirs) {
-      int i = x + dir[0], j = y + dir[1];
-      if (i < 0 || i >= M || j < 0 || j >= N || matrix[i][j] <= matrix[x][y]) continue;
-      cnt[x][y] = max(cnt[x][y], 1 + dfs(matrix, i, j));
+    vector<vector<int>> cnt;
+    int ans = 0, M, N, dirs[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+    int dfs(vector<vector<int>> &A, int x, int y) {
+        if (cnt[x][y]) return cnt[x][y];
+        cnt[x][y] = 1;
+        for (auto &dir : dirs) {
+            int a = x + dir[0], b = y + dir[1];
+            if (a < 0 || b < 0 || a >= M || b >= N || A[a][b] <= A[x][y]) continue;
+            cnt[x][y] = max(cnt[x][y], 1 + dfs(A, a, b));
+        }
+        return cnt[x][y];
     }
-    ans = max(ans, cnt[x][y]);
-    return cnt[x][y];
-  }
 public:
-  int longestIncreasingPath(vector<vector<int>>& matrix) {
-    if (matrix.empty() || matrix[0].empty()) return 0;
-    M = matrix.size(), N = matrix[0].size();
-    cnt = vector<vector<int>> (M, vector<int>(N, 0));
-    for (int i = 0; i < M; ++i)
-      for (int j = 0; j < N; ++j)
-        dfs(matrix, i, j);
-    return ans;
-  }
+    int longestIncreasingPath(vector<vector<int>>& A) {
+        if (A.empty() || A[0].empty()) return 0;
+        M = A.size(), N = A[0].size();
+        cnt.assign(M, vector<int>(N));
+        for (int i = 0; i < M; ++i) 
+            for (int j = 0; j < N; ++j) 
+                ans = max(ans, dfs(A, i, j));
+        return ans;
+    }
 };
 ```
 
-## Solution 2. Topological Sort
+## Solution 2. Topological Sort (BFS)
+
+Note that the DFS version of topological sort solution is the same as the Solution 1.
 
 ```cpp
 // OJ: https://leetcode.com/problems/longest-increasing-path-in-a-matrix/

leetcode/329. Longest Increasing Path in a Matrix/s1.cpp

@@ -1,30 +1,28 @@
-// OJ: https://leetcode.com/problems/longest-increasing-path-in-a-matrix
+// OJ: https://leetcode.com/problems/longest-increasing-path-in-a-matrix/
 // Author: github.com/lzl124631x
 // Time: O(MN)
 // Space: O(MN)
 class Solution {
-private:
-  int M, N, ans = 0, dirs[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
-  vector<vector<int>> cnt;
-  int dfs(vector<vector<int>> &matrix, int x, int y) {
-    if (cnt[x][y]) return cnt[x][y];
-    cnt[x][y] = 1;
-    for (auto dir : dirs) {
-      int i = x + dir[0], j = y + dir[1];
-      if (i < 0 || i >= M || j < 0 || j >= N || matrix[i][j] <= matrix[x][y]) continue;
-      cnt[x][y] = max(cnt[x][y], 1 + dfs(matrix, i, j));
+    vector<vector<int>> cnt;
+    int ans = 0, M, N, dirs[4][2] = {{0,1},{0,-1},{1,0},{-1,0}};
+    int dfs(vector<vector<int>> &A, int x, int y) {
+        if (cnt[x][y]) return cnt[x][y];
+        cnt[x][y] = 1;
+        for (auto &dir : dirs) {
+            int a = x + dir[0], b = y + dir[1];
+            if (a < 0 || b < 0 || a >= M || b >= N || A[a][b] <= A[x][y]) continue;
+            cnt[x][y] = max(cnt[x][y], 1 + dfs(A, a, b));
+        }
+        return cnt[x][y];
     }
-    ans = max(ans, cnt[x][y]);
-    return cnt[x][y];
-  }
 public:
-  int longestIncreasingPath(vector<vector<int>>& matrix) {
-    if (matrix.empty() || matrix[0].empty()) return 0;
-    M = matrix.size(), N = matrix[0].size();
-    cnt = vector<vector<int>> (M, vector<int>(N, 0));
-    for (int i = 0; i < M; ++i)
-      for (int j = 0; j < N; ++j)
-        dfs(matrix, i, j);
-    return ans;
-  }
+    int longestIncreasingPath(vector<vector<int>>& A) {
+        if (A.empty() || A[0].empty()) return 0;
+        M = A.size(), N = A[0].size();
+        cnt.assign(M, vector<int>(N));
+        for (int i = 0; i < M; ++i) 
+            for (int j = 0; j < N; ++j) 
+                ans = max(ans, dfs(A, i, j));
+        return ans;
+    }
 };