矩阵中的最长递增路径

一开始我的想法就是记录最小的值，开始dfs，但是wa了一些测试集，因为不一定是最小的数开始就是最优的答案，后来我就对于dp[i][j] 还是未初始化的再次进行dfs操作，再次统计答案就可以过关了

int addx[] = { 0,0,1,-1 };
int addy[] = { 1,-1,0,0 };
class Solution {
public:
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        n = matrix.size();
        m = matrix[0].size();
        c = matrix;
        dp = vector<vector<int>>(n + 1, vector<int>(m,0));
        int now = 0x7ffffff; vector<pair<int, int>> a;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dp[i][j] = 0;
                if (now > matrix[i][j]) {
                    now = matrix[i][j]; a.push_back({ i,j });
                }
                else if (now == matrix[i][j]) a.push_back({ i,j });
            }
        }
        int ans = 0;
        for (auto [x, y] : a) {
            int t = dfs(x, y);
            ans = max(ans, t);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (!dp[i][j]) {
                    int t = dfs(i, j);
                    ans = max(ans, t);
                }
            }
        }
        return ans;
    }
    vector<vector<int>> dp;
    vector<vector<int>> c;
    int n, m;
    int dfs(int x, int y) {
        if (dp[x][y]) return dp[x][y];
        int now = 1;
        int big = 0;
        for (int i = 0; i < 4; i++) {
            int xx = x + addx[i], yy = y + addy[i];
            if (xx < 0 || xx >= n || yy < 0 || yy >= m || c[x][y] >= c[xx][yy]) continue;
            int t = dfs(xx, yy);
            big = max(big, t);
        }
        return dp[x][y] = now + big;
    }
};