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:

Input: nums = 
[
  [9,9,4],
  [6,6,8],
  [2,1,1]
] 
Output: 4 
Explanation: The longest increasing path is [1, 2, 6, 9].

Example 2:

Input: nums = 
[
  [3,4,5],
  [3,2,6],
  [2,2,1]
] 
Output: 4 
Explanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

How to find the length of the longest increasing path? If we get all lengths of the longest increasing path of every cell, then we get our resutl.
And it’s a good solution to make use of DFS to find the length of longest increasing path of some cell, but think about that, the longest increasing path with A as the beginning cell is {A, B, C, D, E, F}.
It’s certain that A < B < C < D < E < F, and there is no other cell with greater value than F. Then what’s the longest increasing path with B as the beginning cell.
There’s no doubt that it\’s {B, C, D, E, F}. Therefore, if we have gotten the length of the B’s longgest increasing path, the A’s length of increasing path is B’s length + 1.
I think using memorization to optimize the DFS solution is a not bad idea.

int longestIncreasingPathhelper(vector<vector<int>>& memo, vector<vector<int>>& matrix, int i, int j)
{
    //If we have gotten the longest length of pait from the cell[i, j], then return it.
    if(memo[i][j] != 1)return memo[i][j];
    //Search the four directions
    int max = 1;
    //Up
    if(i > 0 && matrix[i - 1][j] > matrix[i][j])
    {
        int temp = matrix[i][j];
        matrix[i][j] = INT32_MIN;
        int tempp = 1 + longestIncreasingPathhelper(memo, matrix, i - 1, j);
        matrix[i][j] = temp;
        max = max > tempp ? max : tempp;
    }
    if(i < memo.size() - 1 && matrix[i + 1][j] > matrix[i][j])
    {
        int temp = matrix[i][j];
        matrix[i][j] = INT32_MIN;
        int tempp = 1 + longestIncreasingPathhelper(memo, matrix, i + 1, j);
        matrix[i][j] = temp;
        max = max > tempp ? max : tempp;
    }
    if(j > 0 && matrix[i][j - 1] > matrix[i][j])
    {
        int temp = matrix[i][j];
        matrix[i][j] = INT32_MIN;
        int tempp = 1 + longestIncreasingPathhelper(memo, matrix, i, j - 1);
        matrix[i][j] = temp;
        max = max > tempp ? max : tempp;
    }
    if(j < memo[0].size() - 1 && matrix[i][j + 1] > matrix[i][j])
    {
        int temp = matrix[i][j];
        matrix[i][j] = INT32_MIN;
        int tempp = 1 + longestIncreasingPathhelper(memo, matrix, i, j + 1);
        matrix[i][j] = temp;
        max = max > tempp ? max : tempp;
    }
    memo[i][j] = max;
    return max;
}
int longestIncreasingPath(vector<vector<int>>& matrix)
{
    if(matrix.size() == 0)return 0;
    int m = matrix.size();
    int n = matrix[0].size();
    //The memorization vector initialized with 0
    vector<int> temp(n, 1);
    vector<vector<int>> memo(m, temp);
    //The result
    int result = 0;
    for(int i = 0; i < m; i++)
    {
        for(int j = 0; j < n; j++)
        {
            int temp_result = longestIncreasingPathhelper(memo, matrix, i, j);
            result = result > temp_result ? result : temp_result;
        }
    }
    return result;
}

www.sunshangyu.top