一【题目类别】

深度优先搜索

二【题目难度】

困难

三【题目编号】

329.矩阵中的最长递增路径

四【题目描述】

给定一个 m x n 整数矩阵 matrix ，找出其中最长递增路径的长度。
对于每个单元格，你可以往上，下，左，右四个方向移动。你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

五【题目示例】

示例 1：
- 输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
- 输出：4
- 解释：最长递增路径为 [1, 2, 6, 9]。
示例 2：
- 输入：matrix = [[3,4,5],[3,2,6],[2,2,1]]
- 输出：4
- 解释：最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。
示例 3：
- 输入：matrix = [[1]]
- 输出：1

六【解题思路】

利用记忆化深度优先搜索的思路
使用一个二维数组，此二维数组大小与输入的二维数组大小相等，目的是保存每一个位置的最长路径长度
然后按照【LeetCode每日一题】——695.岛屿的最大面积的思路进行深度优先搜索
每次搜索都要去新建的二维数组中对比之前的路径长度，如果更长就需要更新
而且，每次搜索的路径长度可能与新建的二维数组中保存的路径长度产生更长的路径长度
这就是记忆化深度优先搜索，其实就是使用一个新的与原来二维数组一样大的二维数组将状态保存
最后最长的路径长度即可

七【题目提示】

$m == ma t r i x . l e n g t h$
$n == ma t r i x [i] . l e n g t h$
$1 <= m, n <= 200$
$0 <= matrix[i][j] <= 2^{31} - 1$

八【时间频度】

时间复杂度： $O (m * n)$ ，其中 $m, n$ 分别为传入的二维数组的行和列
空间复杂度： $O (m * n)$ ，其中 $m, n$ 分别为传入的二维数组的行和列

九【代码实现】

Java语言版

class Solution {
    
    

    int[][] dirs = {
    
    {
    
    1,0},{
    
    0,1},{
    
    -1,0},{
    
    0,-1}};

    public int longestIncreasingPath(int[][] matrix) {
    
    
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] temp = new int[m][n];
        int res = 0;
        for(int i = 0;i<m;i++){
    
    
            for(int j = 0;j<n;j++){
    
    
                if(temp[i][j] == 0){
    
    
                    res = Math.max(res,dfs(matrix,i,j,temp));
                }
            }
        }
        return res;
    }

    public int dfs(int[][] matrix,int i,int j,int[][] temp){
    
    
        if(temp[i][j] != 0){
    
    
            return temp[i][j];
        }
        int res = 1;
        for(int[] dir : dirs){
    
    
            int newRow = i + dir[0];
            int newCol = j + dir[1];
            if(newRow >= 0 && newRow < matrix.length && newCol >= 0 && newCol < matrix[0].length && matrix[newRow][newCol] > matrix[i][j]){
    
    
                res = Math.max(res,dfs(matrix,newRow,newCol,temp) + 1);
            }
        }
        temp[i][j] = res;
        return res;
    }

}

C语言版

const int dirs[4][2] = {
    
    {
    
    1,0},{
    
    0,1},{
    
    -1,0},{
    
    0,-1}};

int dfs(int** matrix,int m,int n,int i, int j,int** temp)
{
    
    
    if(temp[i][j] != 0)
    {
    
    
        return temp[i][j];
    }
    temp[i][j]++;
    for(int k = 0;k<4;k++)
    {
    
    
        int newRow = i + dirs[k][0];
        int newCol = j + dirs[k][1];
        if(newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && matrix[newRow][newCol] > matrix[i][j])
        {
    
    
            temp[i][j] = fmax(temp[i][j],dfs(matrix,m,n,newRow,newCol,temp) + 1);
        }
    }
    return temp[i][j];
}

int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize)
{
    
    
    int m = matrixSize;
    int n = matrixColSize[0];
    int** temp = (int**)malloc(sizeof(int*) * m);
    for(int i = 0;i<m;i++)
    {
    
    
        temp[i] = (int*)calloc(n,sizeof(int));
    }
    int res = 0;
    for(int i = 0;i<m;i++)
    {
    
    
        for(int j = 0;j<n;j++)
        {
    
    
            res = fmax(res,dfs(matrix,m,n,i,j,temp));
        }
    }
    free(temp);
    return res;
}

Python语言版

class Solution:
    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
        def dfs(x,y):
            if temp[x][y] != 0:
                return temp[x][y]
            temp[x][y] += 1
            for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
                newX = x + dx
                newY = y + dy
                if 0 <= newX < m and 0 <= newY < n and matrix[newX][newY] > matrix[x][y]:
                    temp[x][y] = max(temp[x][y],dfs(newX,newY) + 1)
            return temp[x][y]
        m = len(matrix)
        n = len(matrix[0])
        temp = [[0] * n for _ in range(m)]
        res = 0
        for i in range(m):
            for j in range(n):
                res = max(res,dfs(i,j))
        return res

C++语言版

class Solution {
    
    
public:
    static constexpr int dirs[4][2] = {
    
    {
    
    1,0},{
    
    0,1},{
    
    -1,0},{
    
    0,-1}};

    int dfs(vector<vector<int>>& matrix,int m,int n,int x,int y,vector<vector<int>>& memo)
    {
    
    
        if(memo[x][y] != 0)
        {
    
    
            return memo[x][y];
        }
        memo[x][y]++;
        for(int i = 0;i<4;i++)
        {
    
    
            int newX = x + dirs[i][0];
            int newY = y + dirs[i][1];
            if(newX >= 0 && newX < m && newY >= 0 && newY < n && matrix[newX][newY] > matrix[x][y])
            {
    
    
                memo[x][y] = max(memo[x][y],dfs(matrix,m,n,newX,newY,memo) + 1);
            }
        }
        return memo[x][y];
    }

    int longestIncreasingPath(vector<vector<int>>& matrix) {
    
    
        int m = matrix.size();
        int n = matrix[0].size();
        auto memo = vector<vector<int>>(m,vector<int>(n));
        int res = 0;
        for(int i = 0;i<m;i++)
        {
    
    
            for(int j = 0;j<n;j++)
            {
    
    
                res = max(res,dfs(matrix,m,n,i,j,memo));
            }
        }
        return res;
    }
};