LeetCode每日一题

题目来源：力扣（LeetCode）

2713. 矩阵中严格递增的单元格数（困难）

动态规划 矩阵

题目描述

给你一个下标从 1 开始、大小为 m x n 的整数矩阵 mat，你可以选择任一单元格作为 起始单元格 。

从起始单元格出发，你可以移动到 同一行或同一列 中的任何其他单元格，但前提是目标单元格的值 严格大于 当前单元格的值。

你可以多次重复这一过程，从一个单元格移动到另一个单元格，直到无法再进行任何移动。

请你找出从某个单元开始访问矩阵所能访问的 单元格的最大数量 。

返回一个表示可访问单元格最大数量的整数。

示例 1：

示例1

输入：mat = [[3,1],[3,4]]
输出：2
解释：上图展示了从第 1 行、第 2 列的单元格开始，可以访问 2 个单元格。可以证明，无论从哪个单元格开始，最多只能访问 2 个单元格，因此答案是 2 。

示例 2：

示例2

输入：mat = [[1,1],[1,1]]
输出：1
解释：由于目标单元格必须严格大于当前单元格，在本示例中只能访问 1 个单元格。

示例 3：

示例3

输入：mat = [[3,1,6],[-9,5,7]]
输出：4
解释：上图展示了从第 2 行、第 1 列的单元格开始，可以访问 4 个单元格。可以证明，无论从哪个单元格开始，最多只能访问 4 个单元格，因此答案是 4 。

提示：

  • $m == mat.length$
  • $n == mat[i].length $
  • $1 <= m, n <= 10^5$
  • $1 <= m * n <= 10^5$
  • $-10^5 <= mat[i][j] <= 10^5$

题解

动态规划

设 $d[i][j]$ 为移动到单元格 $(i,j)$ 的最大步数，其中 $(i,j)$ 可以作为起始单元格，也可以是从其他单元格移动而来。考虑从第 $i$ 行以及第 $j$ 列上矩阵单元格数值小于 $mat[i][j]$ 的位置进行转移，即 $d[i][j]$ 取以下数值中的最大值：

  • 第 $i$ 行：$max(d[i][j’]+1)$ ，其中 $mat[i][j’] < mat[i][j]$
  • 第 $j$ 列：$max(d[i’][j]+1)$ ，其中 $mat[i’][j] < mat[i][j]$

整个状态空间在进行转移时是有序的，可以对 $mat$ 进行排序，从小到大进行转移。但在转移时，每个状态都要扫描一遍对应的行和列，时间复杂度为 $O(n+m)$；因此对整体 $nm$ 个状态求解的时间复杂度为 $O(nm(n+m))$ 。时间复杂度过大，需要优化。

由于所有 $d[i][j]$ 在更新时，值只会增大，而在转移的过程中只考虑对应行和对应列上 $d$ 的最大值（由于大于 $mat[i][j]$ 的位置还未遍历到，状态还未更新，将其设置为0）。因此可以设置长度为 $m$ 的数组 $row$ 来维护每一行 $d$ 的最大值，设置长度为 $n$ 的数组 $col$ 来维护每一列 $d$ 的最大值。即 $d[i][j]$的最大值如下：

  • $d[i][j]=max(row[i],col[j])+1$

在每次更新 $d[i][j]$ 之后，需要重新更新 $row[i]$ 和 $col[j]$。此外由于 $mat$ 中可能包含相同的数字，需要同时更新它们的 $d$ 值，再同时更新它们对应的 $row$ 和 $col$。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution:
    def maxIncreasingCells(self, mat: List[List[int]]) -> int:
        m, n = len(mat), len(mat[0])
        mp = defaultdict(list)  # 创建默认值为空列表的字典
        row = [0] * m  # 每一行中最大步数值
        col = [0] * n  # 每一列中最大步数值
		
        # 使用字典mp存储矩阵mat中的每个值对应的位置有哪些
        for i in range(m):
            for j in range(n):
                mp[mat[i][j]].append((i, j))  
        
        # 整个状态空间在进行转移时是有序的，即移动时都是从小到大转移
        # 按照字典mp中的键（矩阵mat中的元素值）进行排序，并遍历排序后的项
        for _, pos in sorted(mp.items(), key=lambda k:k[0]):  
            # 由于mat中可能包含相同的数字，需要同时更新它们的d值
            # d[i][j]=max(row[i],col[j])+1
            res = [max(row[i], col[j]) + 1 for i, j in pos]
            # 再同时更新它们对应的row和col
            for (i, j), d in zip(pos, res):
                row[i] = max(row[i], d)
                col[j] = max(col[j], d)
        return max(row)

复杂度分析

  • 时间复杂度：$O(mnlog(mn))$ ，其中 $m$ 是 $mat$ 的行数，$n$ 是 $mat$ 的列数。从小到大进行状态转移之前，需要对 $mat$ 进行排序，这部分时间复杂度为 $O(mnlog(mn))$（列表的 $.sort()$ 方法时间复杂度为 $O(nlogn)$ ）。每个状态转移的时间复杂度为 $O(1)$ ，所有状态转移的时间复杂度为 $O(mn)$。因此总体时间复杂度为 $O(mnlog(mn))$ 。

  • 空间复杂度：$O(mn)$。