329. Longest Increasing Path in a Matrix

最后更新

三刷？

找矩阵里的最长路径。
看起来是DFS，实际上也就是。但是如果从每个点都进行一次DFS然后保留最大的话，会超时。

这里需要结合DP，dp[i][j]表示以此点开始的最长路径，这样每次碰到的时候，如果已经算过，可以直接调取这个值。

用空间交换了部分时间。

写的时候我吸取教训，把边界判断放在DFS的开始。。

Time Complexity: 不会算。。 O(4mn)?因为只能单方向= =，每个点往一个方向延伸，就不可能回来。

Space : O(m*n)

public class Solution {
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix.length == 0) return 0;
        
        int row = matrix.length;
        int col = matrix[0].length;
        int[][] dp = new int[row][col];
        int res = 0;
        
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                res = Math.max(res, dfs(i, j, matrix, dp, Integer.MIN_VALUE));   
            }
        }
        
        return res;
    }
    
    public int dfs(int i, int j, int[][] matrix, int[][] dp, int prev) {
        if (i < 0 || j < 0 || i >= matrix.length || j >= matrix[0].length) return 0;
        if (matrix[i][j] <= prev) return 0;
        if (dp[i][j] != 0) return dp[i][j];
        
        
        int temp = matrix[i][j];
        int tempMax = 0;
        
        tempMax = Math.max(tempMax, dfs(i+1, j, matrix, dp, temp));
        tempMax = Math.max(tempMax, dfs(i, j+1, matrix, dp, temp));
        tempMax = Math.max(tempMax, dfs(i-1, j, matrix, dp, temp));
        tempMax = Math.max(tempMax, dfs(i, j-1, matrix, dp, temp));
        
        dp[i][j] = tempMax + 1;
        return dp[i][j];

    } 
}

---

一刷

一看是H难度的就害怕了，以为有什么特别的办法，动态规划之类的，结果是DFS。。。那就没啥难度了。。

甚至连VISIT都不用，因为一次遍历只可能越来越大。。不可能出现unvisited but goable的情况。。

DP记录下每个格的最大距离，避免重复计算就行了。

代码可以更简单，有些中间变量可以胜率，不过那样一行太长了。。

public class Solution 
{
    public int longestIncreasingPath(int[][] matrix) 
    {
        if(matrix.length == 0) return 0;
        
        int[][] dp = new int[matrix.length][matrix[0].length];
        int res = 0;
        for(int i = 0; i < dp.length;i++)
        {
            for(int j = 0; j < dp[0].length;j++)
            {
                
                if(dp[i][j] == 0)
                {
                    dp[i][j] = helper(matrix,dp,i,j)+1;
                }
                
                res = Math.max(res,dp[i][j]);
                  
            }
        }
        
        return res;
    }
    
    public int helper(int[][] matrix, int[][] dp, int m, int n)
    {
        if(dp[m][n] != 0) return dp[m][n];
        int res = 0;
        int temp = matrix[m][n];
        
        if(m > 0  && matrix[m-1][n] > temp)
        {
            if(dp[m-1][n] == 0) dp[m-1][n] = helper(matrix,dp,m-1,n) + 1;
            
            res = Math.max(res,dp[m-1][n]);
        }
        
        
        if(n > 0 && matrix[m][n-1] > temp)
        {
            if(dp[m][n-1] == 0) dp[m][n-1] = helper(matrix,dp,m,n-1) + 1;
            res = Math.max(res,dp[m][n-1]);
        }
        
        
        if(m+1 < dp.length && matrix[m+1][n] > temp)
        {
            if(dp[m+1][n] == 0) dp[m+1][n] = helper(matrix,dp,m+1,n) + 1;
            res = Math.max(res,dp[m+1][n]);
        }
        
        
        if(n+1 < dp[0].length && matrix[m][n+1] > temp)
        {
            if(dp[m][n+1] == 0) dp[m][n+1] = helper(matrix,dp,m,n+1) + 1;
            res = Math.max(res,dp[m][n+1]);
        }
        
        dp[m][n] = res;
        return dp[m][n];
    
    }
}

---

今天晕晕乎乎的，这个题做得也不好。

DFS+DPmemory

要注意什么时候更新dp[i][j]

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