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.

思路：DP+DFS

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size() == 0 || matrix[0].size() == 0)
        {
            return 0;
        }

        int maxNum = 0;
        int row = matrix.size();
        int lis = matrix[0].size();
        //二维数据结构构造
        vector<int> temp(matrix[0].size(),0);
        vector<vector<int>> cache(matrix.size(),temp);

        for(int i=0;i<row;i++)
        {
            for(int j=0;j<lis;j++)
            {
                maxNum = max(dfs(matrix,INT_MIN,i,j,row,lis,cache),maxNum);
            }
        }
        return maxNum;
    }

    int dfs(vector<vector<int>>& matrix,int min,int i,int j,int row,int lis,vector<vector<int>>& cache)
    {
        //超过边界了
        if(i < 0 || j < 0 || i >= row || j >= lis)
        {
            return 0;
        }

        //当前不是增序
        if(matrix[i][j] <= min)
        {
            return 0;
        }
        //cache里有
        if(cache[i][j] != 0)
        {
            return cache[i][j];
        }

        //否则可以把这个加到新的增序里
        min = matrix[i][j];

        //四个方向遍历计算到当前点的最大增序个数
        int a = dfs(matrix,min,i-1,j,row,lis,cache) + 1;
        int b = dfs(matrix,min,i+1,j,row,lis,cache) + 1;
        int c = dfs(matrix,min,i,j-1,row,lis,cache) + 1;
        int d = dfs(matrix,min,i,j+1,row,lis,cache) + 1;

        //保存到缓存
        int maxNum = max(a,max(b,max(c,d)));
        cache[i][j] = maxNum;
        return maxNum;
    }
};