记忆化搜索 动态规划 LeetCode329 longest-increasing-path-in-a-matrix

LeetCode329 矩阵里的最长上升子序列

f[x][y]表示走到（x，y）的最长上升子序列的长度

dfs（x，y）递归搜索，返回f[x][y]的值

刚开始f[][]全部初始化为-1，表示还没有计算过

每个状态只会被计算一次

状态转移：f[x][y] = max(f[x][y],dfs(a,b)+1);  （（a，b）的值要比（x，y）的值小才可以转移）

class Solution {
public:
    int n,m;
    vector<vector<int>> f,g;
    int dx[4] = {-1,0,1,0};
    int dy[4] = {0,1,0,-1};
    int dfs(int x, int y)
    {
        if(f[x][y] != -1) return f[x][y];
        f[x][y] = 1;
        for(int i = 0; i < 4; i++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a>=0 && a<n && b>=0 && b<m && g[a][b] < g[x][y])
            {
                f[x][y] = max(f[x][y],dfs(a,b)+1);
            }
        }
        return f[x][y];
    }
    int longestIncreasingPath(vector<vector<int>>& matrix) {
        if(matrix.empty()) return 0;
        g = matrix;
        n = g.size(); m = g[0].size();
        f = vector<vector<int>>(n,vector<int>(m,-1));
        int res = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < m; j++)
                res = max(res,dfs(i,j));
        return res;
    }
};