leetcode329. 矩阵中的最长递增路径/记忆化dfs，拓扑排序bfs

题目：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]。注意不允许在对角线方向上移动。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

基本思想1：记忆化dfs

本题如果不进行记忆化搜索是会超时的。
记忆：以该元素作为开始元素的最长路径

class Solution {
private:
    int m, n;
    vector<vector<int>> dir;
public:     
    Solution()  {
        dir = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
    }
    int longestIncreasingPath(vector<vector<int>>& matrix) {  
        if(matrix.size() == 0)
            return 0;
        int res = 0;
        m = matrix.size();
        n = matrix[0].size();    
        vector<vector<int>> memo(matrix.size(), vector<int>(matrix[0].size(), 0));
        
        for(int i = 0; i < matrix.size(); ++i){
            for(int j = 0; j < matrix[0].size(); ++j){                
                res = max(res, dfs(memo, matrix, i, j));
            }
        }
        return res;
    }
    int dfs(vector<vector<int>> &memo, vector<vector<int>>& matrix, int x, int y){ 
        if(memo[x][y])
            return memo[x][y];
        ++memo[x][y];
        for(auto d : dir){
            int i = x + d[0];
            int j = y + d[1];
            if(i >= 0 && i < m && j >= 0 && j < n && matrix[i][j] > matrix[x][y]){
                memo[x][y] = max(memo[x][y], dfs(memo, matrix, i, j) + 1);
            }
        }
        return memo[x][y];
    }

};

基本思想2：bfs(借助拓扑排序来实现)

假设按照降序的方式进行拓扑排序，9 -> 2 -> 1.

• 首先统计每一个元素的入度，也就是周围四个方向上有几个元素是大于该元素的
• 然后从入度为0的元素开始bfs
• 这样处理可以不用把每一个元素遍历一遍，而是将尽可能小的元素也就是入度为0的元素作为起点开始遍历

class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.size() == 0)
            return 0;
        int m = matrix.size(), n = matrix[0].size();
        vector<vector<int>> indegree(m, vector<int>(n, 0));
        vector<vector<int>> dir = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                for(auto d : dir){
                    int x = i + d[0];
                    int y = j + d[1];
                    if(x >= 0 && x < m && y >= 0 && y < n){
                        if(matrix[x][y] > matrix[i][j]){
                            ++indegree[i][j];
                        }
                    }
                }
            }
        }
        
        int res = 0;
        queue<pair<int, int>> q;
        for(int i = 0; i < m; ++i){
            for(int j = 0; j < n; ++j){
                if(indegree[i][j] == 0)                   
                    q.push({i, j});
            }
        }
        while(!q.empty()){
            ++res;
            int l = q.size();
            while(l--){
                int x = q.front().first;
                int y = q.front().second;
                q.pop();
                for(auto d : dir){
                    int cx = x + d[0];
                    int cy = y + d[1];
                    if(cx >= 0 && cx < m && cy >= 0 && cy < n && matrix[x][y] > matrix[cx][cy]){
                        --indegree[cx][cy];
                        if(indegree[cx][cy] == 0)
                            q.push({cx, cy});
                    }
                }
            }          
        }
        return res;
    }
};