LeetCode每日一题 329. 矩阵中的最长递增路径

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

Tag DFS Topological Sort Memorixation

Difficulty Hard

Link https://leetcode-cn.com/problems/longest-increasing-path-in-a-matrix/

分析

1. 首先想到的是深度优先搜索，即遍历每一个点，找寻其最长递增路径，但是结果超时。

2. 注意到1方法会存在许多重复的计算（一条路径上每一个点都会被作为起始点计算一次），所以可以使用visited[]来记录访问状态，避免重复访问

3. 还有一种更高效的方法，记忆化

   在计算中，记忆化是一种优化技术，它通过存储“昂贵”的函数调用的结果，在相同的输入再次出现时返回缓存的结果，以此加快程序的速度。

4. 在本题中，如果知道相邻四个单元格的结果（即最长路径），那么在搜索过程中，未计算过的单元格缓存它的结果，计算过的直接取出结果。

---

题解

class Solution {
    
  	// 计算该点上下左右移动
    private static int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    private int m, n;
    
    public int longestIncreasingPath(int[][] matrix) {
        if (matrix.length == 0) return 0;
        
        m = matrix.length;
        n = matrix[0].length;
        
      	// 存储每个点的最长路径结果
        int[][] cache = new int[m][n];
        int ans = 0;
        
        for (int i=0; i<m; i++) {
            for (int j=0; j<n; j++) {
                ans = Math.max(ans, dfs(matrix, i, j, cache));
            }
        }
        return ans;
    }
    
    private int dfs(int[][] matrix, int i, int j, int[][] cache) {
      	// 如果已经计算过，可以直接返回结果
        if (cache[i][j] != 0) return cache[i][j];
        
      	// 对于上下左右四个点进行判断
        for (int []d : dirs) {
            int x = i + d[0];
            int y = j + d[1];
          	// 如果符合递增的要求，就递归继续寻找下一个递增点是否存在
            if (x>=0 && x<m && y>=0 && y<n && matrix[x][y] > matrix[i][j]) {
                cache[i][j] = Math.max(cache[i][j], dfs(matrix, x, y, cache));
            }
        }
        
      	// 得到最长路径，返回长度，(初始是0，所以长度是结果+1)
        return ++cache[i][j];
    }
}

---

复杂度分析

• 时间复杂度: $O(mn)$

  每个点V遍历一次，每条边E被遍历一次，总复杂度是$O(V+E)$

  其中$O(V)=O(mn)$而每个点有上下左右四条边，
  所以$O(E)=O(4V)=O(4mn)$

  综合得到时间复杂度$O(mn)$

• 空间复杂度: $O(mn)$

  缓存cache的大小