LCR 112. 矩阵中的最长递增路径

题解看到一个很新奇的思路，抽象成拓扑排序。可以找到比周围都小的坐标为出度0，然后依次出度，每次将0的再入队列。然后计算总次数

我这个思路就略显复杂了（稍微慢点），原理就是每个点都进行广搜，因为有的坐标可能之前的广搜已经搜到了，需要判断之前搜到的步数和当前走到的步数比较一下。如果当前步数少，就不用再走了，否则认为是一个更长的路径，继续搜

typedef struct Node{
        int x, y;
}Node;
int path[4][2] = {0,1,0,-1,1,0,-1,0};
int n, m;
class Solution {
public:
    bool check(int x, int y){
        if(x < 0 || x >= n || y < 0 || y >=m) return false;
        return true;
    }
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        m = matrix[0].size(), n = matrix.size();
        int maxn = 1;
        int sum[201][201] = {0};
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                queue<Node> que;
                que.push({i, j});
                sum[i][j] = 1;
                while(que.size() != 0){
                    Node node = que.front();
                    que.pop();
                    int x = node.x, y = node.y;
                    for(int k = 0;k < 4;k++){
                        int xx = path[k][0] + x;
                        int yy = path[k][1] + y;
                        if(check(xx, yy) && matrix[xx][yy] > matrix[x][y]){
                            if(sum[x][y] + 1 > sum[xx][yy]){
                                que.push({xx, yy});
                                sum[xx][yy] = sum[x][y] + 1;
                                maxn = max(maxn, sum[xx][yy]);
                            }
                            
                        }
                    }
                }
            }
        }
        return maxn;
    }
};