算法题：矩阵中的最长递增路径（题目+思路+代码+注释）（简单易懂的记忆法）

题目

329. 矩阵中的最长递增路径
     给定一个 m x n 整数矩阵 matrix ，找出其中 最长递增路径 的长度。

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

输入：matrix = [[9,9,4],[6,6,8],[2,1,1]]
输出：4
解释：最长递增路径为 [1, 2, 6, 9]。

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

输入：matrix = [[1]]
输出：1

提示：

m == matrix.length
n == matrix[i].length
1 <= m, n <= 200
0 <= matrix[i][j] <= 231 - 1

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

思路

我们从下面这个图来分析，最长的递增路径，终点必定是图里面某个点，假设点4作为终点那么最长递增路径必定等于点3的最长路径+1，这样点5=点4+1，就把之前已经算过的利用起来了，减少了运算
因此我们从最小的数开始算，不断的往更大的数去算，就能依次得出每个数作为终点时最大的递增路径长度，我们找出哪个点作为终点的递增路径长度最长则可以找出最长的递增路径长度。
设P为最长递增路径符号
P6=P5+1
P5=P4+1
P4=P3+1
而每个点我们并不知道该取上下左右的哪个点，我们有如下条件：

1. 上下左右找的这个点必须比我自己要小
2. 上下左右里找的这个点符合第一点条件的如果有多个，取最长的那个点
3. 如果一个符合的都找不到，那当前点的最长递增路径长度就等于1
   一方面我们需要从小往大找，那就需要一个从小到大排序后的列表
   另一方面我们需要找上下左右，如果直接把二维数组压成一个一位数组，要找回原来位置就没办法了，因此我们采用一种保留对象矩阵，和一个有序对象列表。类似于LRU算法。这样又能进行找上下左右，又能顺序性的计算。基于对象来完成。
   

代码

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
class Solution {
	//每个格子（把二维矩阵中的每个数字看做一个格子/元素）
    static class Grid{
        int value;//元素matrix[0][1]上数字的值
        int x;//元素matrix[0][1]的0
        int y;//元素matrix[0][1]的1
        int longest=1;//这个点作为终点，最长的递增路线长度
    }
    public int longestIncreasingPath(int[][] matrix) {
        //题目要求找递增，我们可以去算每个点上面最长的路径有多长，那么最少的肯定是从最小的开始，才能利用上之前算过的小的数所能找到的最长递增链
        int m=matrix.length,n=matrix[0].length;
        //建立数据结构
        Grid[][] gridMatrix= new Grid[m][n];
        //顺序的列表
        List<Grid>  gridList = new ArrayList<>(m*n);
        //数据填充
        for (int i =0;i<m;i++){
            for (int j=0;j<n;j++){
                Grid grid = new Grid();
                grid.value = matrix[i][j];
                grid.x = i;
                grid.y = j;
                gridMatrix[i][j] = grid;
                gridList.add(grid);
            }
        }
        //从小到大排序
        gridList.sort(new Comparator<Grid>() {
            @Override
            public int compare(Grid o1, Grid o2) {
                return o1.value - o2.value;
            }
        });
        //记录下最长的
        int max = 0;
        for (int i =0,len = gridList.size();i<len;i++){
            Grid grid = gridList.get(i);
            int tmp = calculateGridMaxIncreaseLength(grid,gridMatrix);
            if (tmp>max){
                max = tmp;
            }
        }
        return max;
    }
	
    public int calculateGridMaxIncreaseLength(Grid grid,Grid[][] gridMatrix){
        //查上下左右的格子，如果符合规则当前数字能找到的最长的就是附近那个比自己小的数字的最长的+1，且必须比已经找到了的长度还长
        int longest = grid.longest;
        //上边的
        if (grid.x>0){
            Grid up = gridMatrix[grid.x-1][grid.y];
            //可以延长
            if (up.value < grid.value){
                int tmp = up.longest+1;
                if (tmp>longest){
                    longest = tmp;
                }
            }
        }
        //下边的
        if (grid.x<gridMatrix.length-1){
            Grid down = gridMatrix[grid.x+1][grid.y];
            if (down.value < grid.value){
                int tmp = down.longest+1;
                if (tmp>longest){
                    longest = tmp;
                }
            }
        }
        //左边的
        if (grid.y>0){
            Grid left = gridMatrix[grid.x][grid.y-1];
            if (left.value < grid.value){
                int tmp = left.longest+1;
                if (tmp>longest){
                    longest = tmp;
                }
            }
        }
        //右边的
        if (grid.y < gridMatrix[0].length-1){
            Grid right = gridMatrix[grid.x][grid.y+1];
            if (right.value < grid.value){
                int tmp = right.longest+1;
                if (tmp>longest){
                    longest = tmp;
                }
            }
        }
        //当前的等于最长的路径长度
        grid.longest = longest;
        return longest;
    }
}