最长递增子序列(LIS)

问题 - Longest Increasing Subsequence

• 例题：Given an unsorted array of integers, find the length of longest increasing subsequence.

  • Input: [6，3，4，5，7，1，2]
  • Output: 4

• complexity

  • $O(n^2)$（常见的有：LCS最长公共子序列、等值长优先、等长小优先）
  • $O(n\ast \log n)$（常见的有：等值长优先优化、等长小优先优化）

分析

子结构分析

• 如果考虑搬寝室的分析方法，根据问题规模，可以设计如下子问题：
  • 最简单的问题：【6】的最长递增子序列的长度是多少？
    • 提示：共有多少子序列？
    • 答案：1个
    • 【6】
  • 次简单的问题：【6，3】的最长递增子序列的长度是多少？
    • 提示：共有多少子序列？
    • 答案：2个，
    • 【6】
    • 【3】
  • 稍复杂的问题：【6，3， 4】的最长递增子序列的长度是多少？
    • 提示：共有多少子序列？
    • 答案：2个，
    • 【6】
    • 【3】
    • 【4】
    • 【3，4】
  • 更复杂的问题：【6，3，4，5】呢？
    • 【6】
    • 【3】
    • 【4】
    • 【3，4】
    • 【5】
    • 【3，5】
    • 【4，5】
    • 【3，4，5】

贪心策略

• 分类、分阶段、贪心

• 从尾元素看，可以舍弃哪些？

  • 【6，3，4，5】
    • 【6】
    • 【3】
    • $\cancel{【4】}$
    • 【3，4】
    • $\cancel{【5】}$
    • $\cancel{【3，5】}$
    • $\cancel{【4，5】}$
    • 【3，4，5】
    • 长度优先策略：尾元素的值相同，则保留当前长度较大的序列，因为发展潜力是一样的

  ---

  • 【6，3，4，5】
    • $\cancel{【6】}$
    • $\cancel{【5】}$
    • $\cancel{【4】}$
    • 【3】
    • $\cancel{【3，5】}$
    • $\cancel{【4，5】}$
    • 【3，4】
    • 【3，4，5】
    • 等长小优先策略：当前长度相同的序列，则保留尾元素较小的序列，因为发展潜力更大

算法

长度优先 — 同值长优先

• 元素数组 a = [$\xcancel{0}$，6，3，4，5，7，1，2]
• 值的特征：1，2，3，4，5，6，7
• dp[i]定义：值为 $i$ 的元素结尾的序列的最大长度
• 注意：$i$ 即是dp的下标，也是元素值
• dp初始值：[$\xcancel{0}$，0，0，0，0，0，0，0]
• 递推过程
  $$d{p}_{0}d{p}_{1}d{p}_{2}d{p}_{3}d{p}_{4}d{p}_{5}d{p}_{6}d{p}_7$$$$初始值：[\xcancel{0},0,0,0,0,0,0,0]$$ $$a_1=6：[\xcancel{0},0,0,0,0,0,1,0]$$ $$a_2=3：[\xcancel{0},0,0,1,0,0,1,0]$$ $$a_3=4：[\xcancel{0},0,0,1,2,0,1,0]$$ $$a_4=5：[\xcancel{0},0,0,1,2,3,1,0]$$ $$a_5=7：[\xcancel{0},0,0,1,2,3,1,4]$$ $$a_6=1：[\xcancel{0},1,0,1,2,3,1,4]$$ $$a_7=2：[\xcancel{0},1,2,1,2,3,1,4]$$

• 状态转移方程
  • $dp[i]=max(dp[i]，1+max(dp[1]，dp[2]，\dots ，dp[i-1]))$
  • 复杂度：O(n^2)

• 优化
  * 可优化环节：$max(dp[1]，dp[2]，\dots ，dp[i-1])$，$O(n)$
  * 优化策略：线段树，$O(\log n)$
  * 总体复杂度：$O(n\ast \log n)$

• 如何求最长序列的长度?

  • 先完成比较
  • 然后$dp[1]，\dots ，dp[n]$中的最大值

• 如何求最长序列？

  • 从比较过程可以看出，最长序列中的元素的前驱是稳定的
  • 可以增加一个前驱数组pre，pre[k]存储a[k]的前驱
  • pre[1]=0（无前驱）
  • pre[2]=0（无前驱）
  • pre[3]=2
  • pre[4]=3
  • pre[5]=4
  • pre[6]=0（无前驱）
  • pre[7]=6

• 有重复元素如何处理？

  • 答案：处理逻辑完全相同，但该元素的值对应的最大长度可能发生变化
  • 例如，增加一个元素：$a_8=6$
    $$d{p}_{0}d{p}_{1}d{p}_{2}d{p}_{3}d{p}_{4}d{p}_{5}d{p}_{6}d{p}_7$$$$初始值：[\xcancel{0},0,0,0,0,0,0,0]$$ $$a_7=2：[\xcancel{0},1,2,1,2,3,1,4]$$$$a_8=6：[\xcancel{0},1,2,1,2,3,4,4]$$
  • pre[8] = 5

• 元素的值范围比较大如何处理？

  • 离散化
  • 例如$a=[10^6，10^3，10^4，10^5，10^9，1，10^2]$
  • 按 a = [6，3，4，5，7，1，2]，因为相对大小关系一致

• 示例代码

for(int i = 1; i <= n; ++i){
	for(int j = 0; j < a[i]; ++j){ // j从0开始，表示所有元素都大于0
		if(dp[a[i]] < dp[j]+1){
			dp[a[i]] = dp[j]+1;
			pre[i] = j;
		}
	}
}

另一类“长度优先”

• dp[i]定义：以下标为 $i$ 的元素结尾的序列的最大长度
• 比较过程
  $$d{p}_{0}d{p}_{1}d{p}_{2}d{p}_{3}d{p}_{4}d{p}_{5}d{p}_{6}d{p}_7$$$$初始值：[\xcancel{0},0,0,0,0,0,0,0]$$ $$a_1=6：[\xcancel{0},1,0,0,0,0,0,0]$$ $$a_2=3：[\xcancel{0},1,1,0,0,0,0,0]$$ $$a_3=4：[\xcancel{0},1,1,2,0,0,0,0]$$ $$a_4=5：[\xcancel{0},1,1,2,3,0,0,0]$$ $$a_5=7：[\xcancel{0},1,1,2,3,4,0,0]$$ $$a_6=1：[\xcancel{0},1,1,2,3,4,1,2]$$ $$a_7=2：[\xcancel{0},1,1,2,3,4,1,2]$$

• 状态转移方程
  • $dp[i]=max(dp[i]，1+max(dp[1]，dp[2]，\dots ，dp[i-1]))$
  • 复杂度：O(n^2)
  • 无需离散化

• 示例代码

for(int i = 1; i <= n; ++i){
	for(int j = 0; j < i; ++j){ // j从0开始，表示所有元素都大于0
		if(a[i] > a[j]){
			dp[i] = max(dp[i], dp[j]+1);
			pre[i] = j;
		}
	}
}

值优先 — 等长小优先

• 元素数组$a=[\xcancel{0}，10^6，10^3，10^4，10^5，10^9，1，10^2]$

• dp[i]定义：长度为 $i$ 的递增序列最小尾元素

• dp初始值：[$\xcancel{0}$，0，0，0，0，0，0，0]

• 递推过程
  $$d{p}_{0}d{p}_{1}d{p}_{2}d{p}_{3}d{p}_{4}d{p}_{5}d{p}_{6}d{p}_7$$$$初始值：[\xcancel{0},0,0,0,0,0,0,0]$$ $$a_1=6：[\xcancel{0},10^6,0,0,0,0,0,0]$$ $$a_2=3：[\xcancel{0},10^3,0,0,0,0,0,0]$$ $$a_3=4：[\xcancel{0},10^3,10^4,0,0,0,0,0]$$ $$a_4=5：[\xcancel{0},10^3,10^4,10^5,0,0,0,0]$$ $$a_5=7：[\xcancel{0},10^3,10^4,10^5,10^9,0,0,0]$$ $$a_6=1：[\xcancel{0},1,10^4,10^5,10^9,0,0,0]$$ $$a_7=2：[\xcancel{0},1,10^2,10^5,10^9,0,0,0]$$

• 新元素的作用

  • 要么新增一个长度为len+1的序列（len是此前的最大长度）
  • 要么可以更新某个长度的最后一个元素的值（使之更小）
  • 要么和现有的某个长度尾元素等值（更新与否对结果无影响）

• dp数组的特征

  • 递增
  • 在递推过程中，记录在dp数组中的各元素能否构成一个上升子序列？答：不一定能。因为出现的先后次序是不确定的。

• 状态转移方程

  • 设dp[j] < a[i] 且j是最大的，则if( j < len ) dp[j+1] =a[i]; else dp[++len] = a[i];
  • 即：寻找第1个比a[i]小的数的下标
  • 复杂度：O(n^2)

• 优化

  • 可优化环节：寻找最小的大于等于a[i]的dp数组下标
  • 优化策略：dp有序，故可二分查找，$O(\log n)$
  • 总体复杂度：$O(n\ast \log n)$

• 如何求最长序列的长度?

  • 先完成递推
  • len就是最大长度

• 如何求最长序列？

  • 从递推过程可以看出，最长序列中的元素的前驱是稳定的
  • 可以增加一个前驱数组pre，pre[k]存储a[k]的前驱的在a中的下标
  • pre[1]=0（无前驱）
  • pre[2]=0（无前驱）
  • pre[3]=2
  • pre[4]=3
  • pre[5]=4
  • pre[6]=0（无前驱）
  • pre[7]=6

• 示例代码

dp[1] = a[1], len = 1;
for(int i = 2; i <= n; ++i){
	if(a[i]>dp[len]) dp[++len] = a[i];
	else *lower_bound(dp+1, dp+len+1, a[i]) = a[i];
}