329. 矩阵中的最长递增路径

题目

给定一个整数矩阵，找出最长递增路径的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

示例 1:

输入: nums =
[
[9,9,4],
[6,6,8],
[2,1,1]
]
输出: 4
解释: 最长递增路径为 [1, 2, 6, 9]。
示例 2:

输入: nums =
[
[3,4,5],
[3,2,6],
[2,2,1]
]
输出: 4
解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

思路

假设我们知道递增序列的起点，那么我们只要用dfs或者bfs就可以把最长的递增路径找出来。

但是我们不知道起点，那么我们也可以将矩阵转换成一个图来做，相邻的两个点，数值小的点可以有路到数值大的点。那么这就直接变成了要求这个图的直径长度的问题了，那也比较简单，进行两次dfs即可。

但是将一个矩阵转换成图感觉还是挺麻烦的，那样我们可以参考最先的想法，对每个点都进行bfs不就可以了吗，当然了，为了优化，如果这个点在之前的bfs中已经访问过了，那么这个点就不用bfs了，这样就可以省一点时间。

class Solution {
public:
    struct point{
        int row ;
        int col ;
        point(int row , int col){
            this->row = row;
            this->col = col;
        }
    };

    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size() == 0){
            return 0;
        }
        vector<vector<int> > dp(matrix.size() , vector<int>(matrix[0].size() , 1 ) );
        stack<point> posArr;
        int result = 0;
        for(int loop = 0 ; loop < matrix.size() ; loop++){
            for(int loop1 = 0 ; loop1 < matrix[loop].size(); loop1 ++){
                if(dp[loop][loop1] == 1){
                    posArr.push(point(loop , loop1) );
                    while(!posArr.empty() ){
                        int row = posArr.top().row , col = posArr.top().col;
                        int aimRow[4] = {row + 1 , row - 1 , row , row};
                        int aimCol[4] = {col , col , col + 1 , col - 1};
                        posArr.pop();
                        for(int pos = 0 ; pos < 4 ; pos++){
                            if(isBigger(row , col , aimRow[pos] , aimCol[pos] , matrix) ){
                                if(dp[aimRow[pos] ][aimCol[pos] ] < dp[row][col] + 1 ){
                                   dp[aimRow[pos] ][aimCol[pos] ] = dp[row][col] + 1 ;
                                   posArr.push(point(aimRow[pos] , aimCol[pos]) );
                                }
                            }
                        }
                    }
                }
            }
        }

        for(int loop = 0 ; loop < dp.size() ; loop++){
            for(int loop1 = 0 ; loop1 < dp[loop].size(); loop1 ++){
                result = max(result , dp[loop][loop1]);
            }
        }
        return result;
    }

    bool isBigger(int nowRow , int nowCol , int aimRow , int aimCol , vector<vector<int>>& matrix){
        if(aimRow < 0 || aimRow >= matrix.size() || aimCol < 0 || aimCol >= matrix[0].size() ){
            return false;
        }
        else{
            return matrix[nowRow][nowCol] < matrix[aimRow][aimCol];
        }
    }

};