leetcode329 矩阵中的最长递增路径

思路：

拓扑排序或者记忆化搜索。

实现1：

class Solution
{
public:
    const vector<int> dx{0, 1, 0, -1};
    const vector<int> dy{1, 0, -1, 0};
    int longestIncreasingPath(vector<vector<int>>& matrix)
    {
        queue<pair<int, int>> q;
        if (matrix.empty()) return 0;
        int n = matrix.size(), m = matrix[0].size();
        vector<int> d(n * m, 0), dis(n * m, 1);
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                bool flg = true;
                for (int k = 0; k < 4; k++)
                {
                    int nx = i + dx[k], ny = j + dy[k];
                    if (nx >= 0 and nx < n and ny >= 0 and ny < m)
                    {
                        if (matrix[nx][ny] < matrix[i][j]) flg = false;
                        else if (matrix[nx][ny] > matrix[i][j])
                        {
                            int tmp = nx * m + ny;
                            d[tmp]++;
                        }
                    }
                }
                if (flg) q.push(make_pair(i, j));
            }
        }
        while (!q.empty())
        {
            auto tmp = q.front(); q.pop();
            int x = tmp.first, y = tmp.second;
            for (int i = 0; i < 4; i++)
            {
                int nx = x + dx[i], ny = y + dy[i]; 
                if (nx >= 0 and nx < n and ny >= 0 and ny < m and matrix[nx][ny] > matrix[x][y])
                {
                    d[nx * m + ny]--;
                    if (d[nx * m + ny] == 0)
                    {
                        q.push(make_pair(nx, ny)); dis[nx * m + ny] = dis[x * m + y] + 1;
                    }
                }
            }
        }
        return *max_element(dis.begin(), dis.end());
    }
};

实现2：

class Solution
{
public:
    const vector<int> dx{0, 1, 0, -1};
    const vector<int> dy{1, 0, -1, 0};
    int dfs(int x, int y, vector<vector<int>>& a, vector<vector<int>>& dp, vector<vector<bool>>& vis)
    {
        if (dp[x][y] != -1) return dp[x][y];
        int n = a.size(), m = a[0].size(), maxn = 0;
        for (int i = 0; i < 4; i++)
        {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx >= 0 and nx < n and ny >= 0 and ny < m and a[nx][ny] < a[x][y] and !vis[nx][ny])
            {
                vis[nx][ny] = true;
                maxn = max(maxn, dfs(nx, ny, a, dp, vis));
                vis[nx][ny] = false;
            }
        }
        return dp[x][y] = maxn + 1;
    }
    int longestIncreasingPath(vector<vector<int>>& matrix)
    {
        if (matrix.empty()) return 0;
        int n = matrix.size(), m = matrix[0].size();
        int res = 1;
        vector<vector<int>> dp(n, vector<int>(m, -1));
        vector<vector<bool>> vis(n, vector<bool>(m, false));
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < m; j++)
            {
                vis[i][j] = true;
                res = max(res, dfs(i, j, matrix, dp, vis));
                vis[i][j] = false;
            }
        }
        return res;
    }
};