LeetCode 329. Longest Increasing Path in a Matrix

Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down. You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

nums = [
  [9,9,4],
  [6,6,8],
  [2,1,1]
]

Return 4
The longest increasing path is [1, 2, 6, 9].

Example 2:

nums = [
  [3,4,5],
  [3,2,6],
  [2,2,1]
]

Return 4
The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

 This is to use DFS.

#include <vector>
#include <iostream>
using namespace std;

/*
    [[9, 9, 4]
     [6, 6, 8]
     [2, 1, 1]]
  The longest increasing path is : 1, 2, 6, 9, return 4, move up, down, left, right
*/

void longestIncreasingPath(vector< vector<int> >& matrix, int i, int j, vector<vector<bool> >& visited, int& len, int& maxLen) {
    maxLen = max(maxLen, len);
    vector< vector<int> > direction {
        {-1, 0},
        {1, 0},
        {0, -1},
        {0, 1}};
    for(int k = 0; k < 4; ++k) {
        int tx = i + direction[k][0];
        int ty = j + direction[k][1];
        if(tx >= 0 && tx < matrix.size() && ty >= 0 && ty < matrix[i].size() && matrix[tx][ty] > matrix[i][j] && !visited[tx][ty]) {
            visited[tx][ty] = true;
            len = len + 1;
            longestIncreasingPath(matrix, tx, ty, visited, len, maxLen);
            visited[tx][ty] = false;
            len = len - 1;
        }
    }
}


int longestIncreasingPath(vector< vector<int> >& matrix) {
    if(matrix.size() == 0 || matrix[0].size() == 0) return 0;
    vector< vector<bool> > visited(matrix.size(), vector<bool>(matrix[0].size(), false));
    int longestPath = 1;
    for(int i = 0; i < matrix.size(); ++i) {
        for(int j = 0; j < matrix[0].size(); ++j) {
            int maxLen = 1;
            int len = 1;
            visited[i][j] = true;
            longestIncreasingPath(matrix, i, j, visited, len, maxLen);
            visited[i][j] = false;
            longestPath = max(maxLen, longestPath);
        }
    }
    return longestPath;
}<pre name="code" class="cpp">int main(void) {
    vector< vector<int> > matrix {
        {9, 10, 11},
        {6, 13, 12},
        {2, 1, 0}};
    int maxLen = longestIncreasingPath(matrix);
    cout << maxLen << endl;
}

HOWEVER, THE CODE IS NOT CLEAN......

// Excellent code from LeetCode forum.

    int longestIncreasingPath(vector<vector<int>>& matrix) {
        int result=1;
        int m = matrix.size();
        if(m == 0)  return 0;
        int n = matrix[0].size();
        vector<vector<int>> visit(m, vector<int>(n, 1));
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                int temp = help(matrix, visit, i, j, m, n);
                result = max(result, temp);
            }
        }
        return result;
    }

    int help(vector<vector<int>>& matrix, vector<vector<int>>& visit, int i, int j, int m, int n){
        if(visit[i][j]>1)  return visit[i][j];
        int result = 1;
        for(auto dir : dirs){
            int x = i + dir[0], y = j + dir[1];
            if(x < 0 || x >= m || y < 0 || y >= n || matrix[i][j] >= matrix[x][y])  continue;
            result = max(result, help(matrix, visit, x, y, m, n) + 1);
        }
        visit[i][j] = result;
        return result;
    }