学习动态规划和贪心算法的应用
方法一:动态规划
思路与算法
定义 d p [ i ] dp[i] dp[i] 为考虑前 i i i 个元素,以第 i i i 个数字结尾的最长上升子序列的长度,注意 nums [ i ] \textit{nums}[i] nums[i] 必须被选取。
我们从小到大计算 d p [ ] dp[] dp[] 数组的值,在计算 d p [ i ] dp[i] dp[i] 之前,我们已经计算出 d p [ 0 … i − 1 ] dp[0 \ldots i-1] dp[0…i−1] 的值,则状态转移方程为:
d p [ i ] = max ( d p [ j ] ) + 1 , 其中 0 ≤ j < i 且 num [ j ] < num [ i ] dp[i] = \text{max}(dp[j]) + 1, \text{其中} \, 0 \leq j < i \, \text{且} \, \textit{num}[j]<\textit{num}[i] dp[i]=max(dp[j])+1,其中0≤j<i且num[j]<num[i]
即考虑往 d p [ 0 … i − 1 ] dp[0 \ldots i-1] dp[0…i−1] 中最长的上升子序列后面再加一个 nums [ i ] \textit{nums}[i] nums[i]。由于 d p [ j ] dp[j] dp[j] 代表 nums [ 0 … j ] \textit{nums}[0 \ldots j] nums[0…j] 中以 nums [ j ] \textit{nums}[j] nums[j] 结尾的最长上升子序列,所以如果能从 d p [ j ] dp[j] dp[j] 这个状态转移过来,那么 nums [ i ] \textit{nums}[i] nums[i] 必然要大于 nums [ j ] \textit{nums}[j] nums[j],才能将 nums [ i ] \textit{nums}[i] nums[i] 放在 nums [ j ] \textit{nums}[j] nums[j] 后面以形成更长的上升子序列。
最后,整个数组的最长上升子序列即所有
d
p
[
i
]
dp[i]
dp[i] 中的最大值。
LIS
length
=
max
(
d
p
[
i
]
)
,
其中
0
≤
i
<
n
\text{LIS}_{\textit{length}}= \text{max}(dp[i]), \text{其中} \, 0\leq i < n
LISlength=max(dp[i]),其中0≤i<n
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
dp = [1 for i in range(len(nums))]
for i in range(len(nums)):
dpj_max = 0
for j in range(i):
if nums[j] < nums[i] and dp[j] > dpj_max:
dpj_max = dp[j]
dp[i] = dpj_max + 1
return max(dp)
复杂度分析
- 时间复杂度: O ( n 2 ) O(n^2) O(n2),其中 n n n 为数组 nums \textit{nums} nums 的长度。动态规划的状态数为 n n n,计算状态 d p [ i ] dp[i] dp[i] 时,需要 O ( n ) O(n) O(n) 的时间遍历 d p [ 0 … i − 1 ] dp[0 \ldots i-1] dp[0…i−1] 的所有状态,所以总时间复杂度为 O ( n 2 ) O(n^2) O(n2)。
- 空间复杂度: O ( n ) O(n) O(n),需要额外使用长度为 n n n 的 d p dp dp 数组。
方法二:贪心 + 二分查找
思路与算法
考虑一个简单的贪心,如果我们要使上升子序列尽可能的长,则我们需要让序列上升得尽可能慢,因此我们希望每次在上升子序列最后加上的那个数尽可能的小。
基于上面的贪心思路,我们维护一个数组 d [ i ] d[i] d[i] ,表示长度为 i i i 的最长上升子序列的末尾元素的最小值,用 len \textit{len} len 记录目前最长上升子序列的长度,起始时 l e n len len 为 1 1 1, d [ 1 ] = nums [ 0 ] d[1] = \textit{nums}[0] d[1]=nums[0]。
同时我们可以注意到 d [ i ] d[i] d[i] 是关于 i i i 单调递增的。因为如果 d [ j ] ≥ d [ i ] d[j] \geq d[i] d[j]≥d[i] 且 j < i j < i j<i,我们考虑从长度为 i i i 的最长上升子序列的末尾删除 i − j i-j i−j 个元素,那么这个序列长度变为 j j j ,且第 j j j 个元素 x x x(末尾元素)必然小于 d [ i ] d[i] d[i],也就小于 d [ j ] d[j] d[j]。那么我们就找到了一个长度为 j j j 的最长上升子序列,并且末尾元素比 d [ j ] d[j] d[j] 小,从而产生了矛盾。因此数组 d [ ] d[] d[] 的单调性得证。
我们依次遍历数组 nums [ ] \textit{nums}[] nums[] 中的每个元素,并更新数组 d [ ] d[] d[] 和 l e n len len 的值。
- 如果 nums [ i ] > d [ len ] \textit{nums}[i] > d[\textit{len}] nums[i]>d[len] 则更新 l e n = l e n + 1 len = len + 1 len=len+1,
- 否则在 d [ 1 … l e n ] d[1 \ldots len] d[1…len]中找满足 d [ i − 1 ] < nums [ j ] < d [ i ] d[i - 1] < \textit{nums}[j] < d[i] d[i−1]<nums[j]<d[i] 的下标 i i i,并更新 d [ i ] = nums [ j ] d[i] = \textit{nums}[j] d[i]=nums[j]。
根据 d d d 数组的单调性,我们可以使用二分查找寻找下标 i i i,优化时间复杂度。
最后整个算法流程为:
- 设当前已求出的最长上升子序列的长度为
len
\textit{len}
len(初始时为
1
1
1),从前往后遍历数组
nums
\textit{nums}
nums,在遍历到
nums
[
i
]
\textit{nums}[i]
nums[i] 时:
- 如果 nums [ i ] > d [ len ] \textit{nums}[i] > d[\textit{len}] nums[i]>d[len] ,则直接加入到 d d d 数组末尾,并更新 len = len + 1 \textit{len} = \textit{len} + 1 len=len+1;
- 否则,在 d d d 数组中二分查找,找到第一个比 nums [ i ] \textit{nums}[i] nums[i] 小的数 d [ k ] d[k] d[k] ,并更新 d [ k + 1 ] = nums [ i ] d[k + 1] = \textit{nums}[i] d[k+1]=nums[i]。
以输入序列 [ 0 , 8 , 4 , 12 , 2 ] [0, 8, 4, 12, 2] [0,8,4,12,2] 为例:
- 第一步插入 0 0 0, d = [ 0 ] d = [0] d=[0];
- 第二步插入 8 8 8, d = [ 0 , 8 ] d = [0, 8] d=[0,8];
- 第三步插入 4 4 4, d = [ 0 , 4 ] d = [0, 4] d=[0,4];
- 第四步插入 12 12 12, d = [ 0 , 4 , 12 ] d = [0, 4, 12] d=[0,4,12];
- 第五步插入 2 2 2, d = [ 0 , 2 , 12 ] d = [0, 2, 12] d=[0,2,12]。
最终得到最大递增子序列长度为 3 3 3。
class Solution:
def lengthOfLIS(self, nums: List[int]) -> int:
d = []
for i in range(len(nums)):
if (not d) or (nums[i] > d[-1]):
d.append(nums[i])
else:
loc = self.bisect(d, nums[i])
d[loc] = nums[i]
return len(d)
def bisect(self, nums, k):
left = 0
right = len(nums) - 1
loc = right
while left <= right:
mid = (left + right) // 2
if nums[mid] >= k:
loc = mid
right = mid - 1
else:
left = mid + 1
return loc
复杂度分析
- 时间复杂度: O ( n log n ) O(n\log n) O(nlogn)。数组 nums \textit{nums} nums 的长度为 n n n,我们依次用数组中的元素去更新 d d d 数组,而更新 d d d 数组时需要进行 O ( log n ) O(\log n) O(logn) 的二分搜索,所以总时间复杂度为 O ( n log n ) O(n\log n) O(nlogn)。
- 空间复杂度: O ( n ) O(n) O(n),需要额外使用长度为 n n n 的 d d d 数组。