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

给定一个整数矩阵，找出最长递增路径的长度。

对于每个单元格，你可以往上，下，左，右四个方向移动。 你不能在对角线方向上移动或移动到边界外（即不允许环绕）。

 

题解：

1.一个整数矩阵

2.找一个最长的递增路径

3.每次往上，下，左，右移动

4.返回这个路径的长度

 

示例 1:

输入: nums = [[9,9,4],[6,6,8], [2,1,1]] 

输出: 4 

解释: 最长递增路径为 [1, 2, 6, 9]。

示例 2:

输入: nums = [[3,4,5],[3,2,6],[2,2,1]] 

输出: 4 

解释: 最长递增路径是 [3, 4, 5, 6]。注意不允许在对角线方向上移动。

 

解题思路：

• 遍历数组中的每一个元素，这每一个元素都是一个递归种子入口

• 设置一个visited数组初始化为0，控制递归搜索的位置，同时记录可扩展的路径长度，这样为0为未访问过，不为0则记录的是路径长度不必再重复计算以该位置为种子的路径长度，直接返回它的值即可

• 这样每次计算路径长度时都会产生一个路径长度结果，设置一个结果变量记录比较记录较大值，即为最大值。

C/C++题解：

class Solution {

public:

    int res = INT_MIN;

    vector<vector<int>> visited; //设visited数组控制访问

    int longestIncreasingPath(vector<vector<int>>& matrix) {

        if(matrix.size() == 0) return 0;

        int m=matrix.size(), n = matrix[0].size();

        vector<int> temp(n);

        visited.resize(m,temp);

        for (int i = 0;i<m;i++){

            for (int j = 0;j<n;j++){

                longestSearch(matrix,i,j);

             }}//每个元素位置都是一个种子

        return res; }

    int longestSearch(vector<vector<int>>& matrix, int i,int j){

        if (visited[i][j] > 0)  return visited[i][j];

        visited[i][j] = 1; //位置访问过置1

        int pathlen = 0;//计算长度

        if (i-1>=0 && matrix[i-1][j] >matrix[i][j])//上一行判断下界

            pathlen = max(pathlen,longestSearch(matrix,i-1,j));

        if (i+1 <matrix.size() && matrix[i+1][j] >matrix[i][j])//下一行判断上界

            pathlen = max(pathlen,longestSearch(matrix,i+1,j));

        if (j-1 >= 0 && matrix[i][j-1] >matrix[i][j])//左一列判断下界

            pathlen = max(pathlen,longestSearch(matrix,i,j-1));

        if(j+1< matrix[i].size() && matrix[i][j+1] >matrix[i][j])//右一列判断上界

            pathlen = max(pathlen,longestSearch(matrix,i,j+1));

        res = max(res,pathlen + 1);//保留最大长度

        visited[i][j] = pathlen+1;

        return pathlen + 1; }};//元素自身长度为1

Debug结果：

Java题解：

class Solution {

    public int res = Integer.MIN_VALUE;

    public int[][] visited; //设visited数组控制访问

    public int longestIncreasingPath(int[][] matrix) {

        if (matrix.length == 0) return 0;

        int m = matrix.length,n = matrix[0].length;

        visited = new int[m][n];

        for (int i = 0;i<matrix.length;i++){

            for (int j = 0;j<matrix[0].length;j++){

                longestSearch(matrix,i,j);}}//每个元素位置都是一个种子

        return res;}

    public int longestSearch(int[][] matrix, int i,int j){

        if (visited[i][j] > 0)  return visited[i][j];

        visited[i][j] = 1; //位置访问过置1

        int pathlen = 0;//计算长度

        if (i-1>=0 && matrix[i-1][j] >matrix[i][j])//上一行判断下界

            pathlen = Math.max(pathlen,longestSearch(matrix,i-1,j));

        if (i+1 <matrix.length && matrix[i+1][j] >matrix[i][j])//下一行判断上界

            pathlen = Math.max(pathlen,longestSearch(matrix,i+1,j));

        if (j-1 >= 0 && matrix[i][j-1] >matrix[i][j])//左一列判断下界

            pathlen = Math.max(pathlen,longestSearch(matrix,i,j-1));

        if(j+1< matrix[i].length && matrix[i][j+1] >matrix[i][j])//右一列判断上界

            pathlen = Math.max(pathlen,longestSearch(matrix,i,j+1));

        res = Math.max(res,pathlen + 1);//保留最大长度

        visited[i][j] = pathlen+1;

        return pathlen + 1;}}//元素自身长度为1

Debug结果：

Python题解：

class Solution(object):

    def longestIncreasingPath(self, matrix):

        """:type matrix: List[List[int]]:rtype: int"""

        if not matrix: return 0

        self.res = -sys.maxint

        m, n = len(matrix), len(matrix[0])

        visited = [[0 for _ in range(n)] for _ in range(m)]

        def longestSearch(matrix, i, j):

            if visited[i][j] > 0:  return visited[i][j]

            visited[i][j] = 1 #位置访问过置1

            pathlen = 0 #计算长度

            if (i-1>=0 and matrix[i-1][j] > matrix[i][j]): #上一行判断下界

                pathlen = max(pathlen,longestSearch(matrix,i-1,j))

            if (i+1 < len(matrix) and matrix[i+1][j] >matrix[i][j]):#下一行判断上界

                pathlen = max(pathlen,longestSearch(matrix,i+1,j))

            if (j-1 >= 0 and matrix[i][j-1] >matrix[i][j]): #左一列判断下界

                pathlen = max(pathlen,longestSearch(matrix,i,j-1))

            if(j+1< len(matrix[i]) and matrix[i][j+1] >matrix[i][j]): #右一列判断上界

                pathlen = max(pathlen,longestSearch(matrix,i,j+1))

            self.res = max(self.res,pathlen + 1) #保留最大长度

            visited[i][j] = pathlen+1

            return pathlen + 1 #元素自身长度为1

        for i in range(m):

            for j in range(n):

                longestSearch(matrix,i,j)

            #每个元素位置都是一个种子

        return self.res

Debug结果：

更多题解移步公众号免费获取