leetcode_329_矩阵中的最长递增路径

题目：

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

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

示例 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]。注意不允许在对角线方向上移动。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路：

这个题目标注为：困难级别。

确实，这个题目很难，不过想到了就比较容易过。。。

首先，这个题属于“查找类”，最简单的方法莫过于DFS与BFS两大搜索算法。

在这个题目中，不推荐使用BFS，用DFS是最好的选择：最长路径。

选定了方法，就写策略：

从左上角一直遍历到右下角，遍历完所有矩阵格，之后就可以得到一个最大值，即要求的最大路径长度。

但是这种方法缺陷很明显：复杂度过高（可能是O(n^n)阶，很高的复杂度了），必定超时。

分析复杂度高的原因：重复查找了。

所以，需要用空间换时间的做法，记忆化搜索过的节点所属的最长递增路径长度值。

这样就能将复杂度降低至：O(row*column*(e+v))。

其中row与column是矩阵的维度，e是边（因为可以上下左右移动），v是节点。

记忆化剪枝策略：

使用一个dp矩阵，定义：

dp[i][j]：节点[i,j]可以走的路径中最长的那一条路径的长度。

这个操作通过：

dp[nr][nc] = Math.max(dp[nr][nc], solve(matrix, nextr, nextc, dp)+1);

可以实现。解释一下：

 max中，第一个不需要解释，懂得都懂；
//      第二个需要解释一下，即为从[nr，nc]出发到达其他可以达到节点的路径长度。
//      也是利用记忆化，来达到叠加最优、剪枝的效果。

最后，需要注意：

在上面的操作过后，dp[nr][nc]可能还是0（初始值），因为：

如果当前的节点四周的值都比它小（如题目中的示例1中的节点值为8的节点处），则无法向外走，即它自身为一条路径，只是这条路径只有它自己一个节点而已.

此时，需要：

当前节点的dp只能也必须赋值为1。（这个理由很好理解）

---

实现：

JAVA版：

package leetcode;

import java.util.Arrays;

/*
USER：LQY
DATE：2020/7/26
TIME：8:25
*/
public class leetcode_329 {

    public static void main(String []args){
        int [][]matrix = {
                {9, 9, 4},
                {6, 6, 8},
                {2, 1, 1}
//                {3, 4, 5},
//                {3, 2, 6},
//                {2, 2, 1}
        };
        System.out.println(new leetcode_329().longestIncreasingPath(matrix));
    }
    public int longestIncreasingPath(int[][] matrix) {

        int row = matrix.length;
        if(row == 0) return 0;
        int column = matrix[0].length;
        if(row==column && row==1){
            return 1;
        }
//        int [][]book = new int[row][column];
        int [][]dp = new int[row][column];
//        for(int i = 0;i < row;i++)
//            for(int j = 0;j < column;j++)
//                dp[i][j] = 1;
//        solve(matrix, 1, 0, 0, book, 1, dp);
        int max = 0;
        for(int i = 0;i < row;i++){
            for(int j = 0;j < column;j++){
                solve(matrix, i, j, dp);


                max = Math.max(max, dp[i][j]);

            }
        }


        return max;

    }
    int [][]dir = {{-1, 0},{0, 1},{1, 0},{0, -1}};  //上、右、下、左

    public int solve(int [][]matrix, int nr, int nc, int [][]dp){
        if(dp[nr][nc] != 0){
            return dp[nr][nc];
        }
        int r = matrix.length;
        int c = matrix[0].length;

//        dp[nr][nc] = count;  //记录
        for(int i = 0;i < 4;i++){
            int nextr = nr + dir[i][0];
            int nextc = nc + dir[i][1];
            if(nextc<0 || nextc>=c || nextr<0 || nextr>=r) continue;
//            if(book[nextr][nextc] == 1) continue;  //走过了
            int nextv = matrix[nextr][nextc];
            int nv = matrix[nr][nc];
            if(nextv <= nv) continue;  //递增情况下。不符合

//            book[nextr][nextc] = 1;
//        关键语句：使得dp[nr][nc]更新为：从[nr,nc]出发能够到达的、递增排列的最长序列长度。
//       max中，第一个不需要解释，懂得都懂；
//      第二个需要解释一下，即为从[nr，nc]出发到达其他可以达到节点的路径长度。
//      也是利用记忆化，来达到叠加最优、剪枝的效果。
            dp[nr][nc] = Math.max(dp[nr][nc], solve(matrix, nextr, nextc, dp)+1);
//            dp[nr][nc] = Math.max(dp[nr][nc], dp[nextr][nextc]);

//            book[nextr][nextc] = 0;
        }
//        if(dp[nr][nc] == 0) dp[nr][nc] = 1;   //这个判断很重要：如果当前的节点四周的值都比它小，则当前节点的dp只能也必须赋值为1.
        return dp[nr][nc]==0?1:dp[nr][nc];
    }
}

C语言版：（二维数组的分配还是有点麻烦555）

int dir[][2] = {{-1, 0},{0, 1},{1, 0},{0, -1}};  //上、右、下、左

int solve(int **matrix, int matrixSize, int matrixColSize,int nr, int nc, int **dp){
    if(dp[nr][nc] != 0) return dp[nr][nc];

    for(int i = 0;i < 4;i++){
        int nextr = nr + dir[i][0];
        int nextc = nc + dir[i][1];
        if(nextc<0 || nextc>=matrixColSize || nextr<0 || nextr>=matrixSize) continue;

        int nextv = matrix[nextr][nextc];
        int nv = matrix[nr][nc];
        if(nextv <= nv) continue;  //递增情况下。不符合
        // dp[nr][nc] = max(dp[nr][nc], solve(matrix, matrixSize, matrixColSize, nextr, nextc, dp)+1);
        int nccc = solve(matrix, matrixSize, matrixColSize, nextr, nextc, dp)+1;
        dp[nr][nc] = dp[nr][nc]>nccc? dp[nr][nc] : nccc;

    }
    if(dp[nr][nc] == 0) dp[nr][nc] = 1;
    return dp[nr][nc];
}
int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize){
    if(matrixSize == 0)
        return 0;
    
    int **dp = (int **)malloc(matrixSize * sizeof(int *));

    for(int i = 0;i < matrixSize;i++){
        dp[i] = (int*)malloc((*matrixColSize) * sizeof(int));
        for(int j = 0;j < *matrixColSize;j++)
            dp[i][j] = 0;
    }
    
    int max = 0;
    for(int i = 0;i < matrixSize;i++){
        for(int j = 0;j < *matrixColSize;j++){
            solve(matrix, matrixSize, *matrixColSize, i, j, dp);
            max = max > dp[i][j]? max : dp[i][j];
        }
    }

    return max;
}