问题 - 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 ) O(n^2) O(n2)(常见的有:LCS最长公共子序列、等值长优先、等长小优先)
- O ( n ∗ log n ) O(n*\log{n}) O(n∗logn)(常见的有:等值长优先优化、等长小优先优化)
分析
子结构分析
- 如果考虑搬寝室的分析方法,根据问题规模,可以设计如下子问题:
- 最简单的问题:【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】的最长递增子序列的长度是多少?
贪心策略
-
分类、分阶段、贪心
-
从尾元素看,可以舍弃哪些?
- 【6,3,4,5】
- 【6】
- 【3】
- 【 4 】 \cancel{【4】} 【4】
- 【3,4】
- 【 5 】 \cancel{【5】} 【5】
- 【 3 , 5 】 \cancel{【3,5】} 【3,5】
- 【 4 , 5 】 \cancel{【4,5】} 【4,5】
- 【3,4,5】
- 长度优先策略:尾元素的值相同,则保留当前长度较大的序列,因为发展潜力是一样的
- 【6,3,4,5】
- 【 6 】 \cancel{【6】} 【6】
- 【 5 】 \cancel{【5】} 【5】
- 【 4 】 \cancel{【4】} 【4】
- 【3】
- 【 3 , 5 】 \cancel{【3,5】} 【3,5】
- 【 4 , 5 】 \cancel{【4,5】} 【4,5】
- 【3,4】
- 【3,4,5】
- 等长小优先策略:当前长度相同的序列,则保留尾元素较小的序列,因为发展潜力更大
- 【6,3,4,5】
算法
长度优先 — 同值长优先
- 元素数组 a = [ 0 \xcancel0 0 ,6,3,4,5,7,1,2]
- 值的特征:1,2,3,4,5,6,7
- dp[i]定义:值为 i i i 的元素结尾的序列的最大长度
- 注意: i i i 即是dp的下标,也是元素值
- dp初始值:[ 0 \xcancel0 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 \quad \quad\quad \quad dp_0\;\;dp_1\;\;dp_2\;\;dp_3\;\;dp_4\;\;dp_5\;\;dp_6\;\;dp_7 dp0dp1dp2dp3dp4dp5dp6dp7 初 始 值 : [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] 初始值:[\;\xcancel0,\quad0,\quad0,\quad0,\quad0,\quad0 ,\quad0 ,\quad0\; ] 初始值:[0 ,0,0,0,0,0,0,0] a 1 = 6 : [ 0 , 0 , 0 , 0 , 0 , 0 , 1 , 0 ] \;a_1=6:[\;\xcancel0,\quad0,\quad0,\quad0,\quad0,\quad0 ,\quad\color{red}1,\quad\color{black}0\; ] a1=6:[0 ,0,0,0,0,0,1,0] a 2 = 3 : [ 0 , 0 , 0 , 1 , 0 , 0 , 1 , 0 ] \;a_2=3: [\;\xcancel0,\quad0,\quad0,\quad\color{red}1,\quad\color{black}0,\quad0 ,\quad1 ,\quad0\; ] a2=3:[0 ,0,0,1,0,0,1,0] a 3 = 4 : [ 0 , 0 , 0 , 1 , 2 , 0 , 1 , 0 ] \;a_3=4:[\;\xcancel0,\quad0,\quad0,\quad1,\quad\color{red}2,\quad\color{black}0 ,\quad1 ,\quad0\; ] a3=4:[0 ,0,0,1,2,0,1,0] a 4 = 5 : [ 0 , 0 , 0 , 1 , 2 , 3 , 1 , 0 ] \;a_4=5:[\;\xcancel0,\quad0,\quad0,\quad1,\quad2,\quad\color{red}3 ,\quad\color{black}1 ,\quad0\; ] a4=5:[0 ,0,0,1,2,3,1,0] a 5 = 7 : [ 0 , 0 , 0 , 1 , 2 , 3 , 1 , 4 ] \;a_5=7: [\;\xcancel0,\quad0,\quad0,\quad1,\quad2,\quad3 ,\quad1 ,\quad\color{red}4\; ] a5=7:[0 ,0,0,1,2,3,1,4] a 6 = 1 : [ 0 , 1 , 0 , 1 , 2 , 3 , 1 , 4 ] \;a_6=1:[\;\xcancel0,\quad\color{red}1,\quad\color{black}0,\quad1,\quad2,\quad3 ,\quad1 ,\quad4\; ] a6=1:[0 ,1,0,1,2,3,1,4] a 7 = 2 : [ 0 , 1 , 2 , 1 , 2 , 3 , 1 , 4 ] \;a_7=2:[\;\xcancel0,\quad1,\quad\color{red}2,\quad\color{black}1,\quad2,\quad3 ,\quad1 ,\quad4\; ] a7=2:[0 ,1,2,1,2,3,1,4]
- 状态转移方程
- d p [ i ] = m a x ( d p [ i ] , 1 + m a x ( d p [ 1 ] , d p [ 2 ] , … , d p [ i − 1 ] ) ) dp[i] = max(dp[i],1+max(dp[1], dp[2], …, dp[i-1] ) ) dp[i]=max(dp[i],1+max(dp[1],dp[2],…,dp[i−1]))
- 复杂度:O(n^2)
-
优化
* 可优化环节: m a x ( d p [ 1 ] , d p [ 2 ] , … , d p [ i − 1 ] ) max(dp[1], dp[2], …, dp[i-1] ) max(dp[1],dp[2],…,dp[i−1]), O ( n ) O(n) O(n)
* 优化策略:线段树, O ( log n ) O(\log{n}) O(logn)
* 总体复杂度: O ( n ∗ log n ) O(n*\log{n}) O(n∗logn) -
如何求最长序列的长度?
- 先完成比较
- 然后 d p [ 1 ] , … , d p [ n ] dp[1],…,dp[n] dp[1],…,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
a_8=6
a8=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 \quad \quad\quad \quad dp_0\;\;dp_1\;\;dp_2\;\;dp_3\;\;dp_4\;\;dp_5\;\;dp_6\;\;dp_7 dp0dp1dp2dp3dp4dp5dp6dp7 初 始 值 : [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] 初始值:[\;\xcancel0,\quad0,\quad0,\quad0,\quad0,\quad0 ,\quad0 ,\quad0\; ] 初始值:[0 ,0,0,0,0,0,0,0] a 7 = 2 : [ 0 , 1 , 2 , 1 , 2 , 3 , 1 , 4 ] \;a_7=2:[\;\xcancel0,\quad1,\quad\color{red}2,\quad\color{black}1,\quad2,\quad3 ,\quad1 ,\quad4\; ] a7=2:[0 ,1,2,1,2,3,1,4] a 8 = 6 : [ 0 , 1 , 2 , 1 , 2 , 3 , 4 , 4 ] \;a_8=6:[\;\xcancel0,\quad1,\quad2,\quad1,\quad2,\quad3 ,\quad\color{red}4 ,\quad\color{black}4\; ] a8=6:[0 ,1,2,1,2,3,4,4] - pre[8] = 5
-
元素的值范围比较大如何处理?
- 离散化
- 例如 a = [ 1 0 6 , 1 0 3 , 1 0 4 , 1 0 5 , 1 0 9 , 1 , 1 0 2 ] a=[10^6,10^3,10^4,10^5,10^9,1,10^2] a=[106,103,104,105,109,1,102]
- 按 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 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 \quad \quad\quad \quad dp_0\;\;dp_1\;\;dp_2\;\;dp_3\;\;dp_4\;\;dp_5\;\;dp_6\;\;dp_7 dp0dp1dp2dp3dp4dp5dp6dp7 初 始 值 : [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] 初始值:[\;\xcancel0,\quad0,\quad0,\quad0,\quad0,\quad0 ,\quad0 ,\quad0\; ] 初始值:[0 ,0,0,0,0,0,0,0] a 1 = 6 : [ 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 ] \;a_1=6:[\;\xcancel0,\quad1,\quad0,\quad0,\quad0,\quad0 ,\quad0,\quad0\; ] a1=6:[0 ,1,0,0,0,0,0,0] a 2 = 3 : [ 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 ] \;a_2=3:[\;\xcancel0,\quad1,\quad1,\quad0,\quad0,\quad0 ,\quad0 ,\quad0\; ] a2=3:[0 ,1,1,0,0,0,0,0] a 3 = 4 : [ 0 , 1 , 1 , 2 , 0 , 0 , 0 , 0 ] \;a_3=4:[\;\xcancel0,\quad1,\quad1,\quad2,\quad0,\quad0 ,\quad0 ,\quad0\; ] a3=4:[0 ,1,1,2,0,0,0,0] a 4 = 5 : [ 0 , 1 , 1 , 2 , 3 , 0 , 0 , 0 ] \;a_4=5:[\;\xcancel0,\quad1,\quad1,\quad2,\quad3,\quad0 ,\quad0 ,\quad0\; ] a4=5:[0 ,1,1,2,3,0,0,0] a 5 = 7 : [ 0 , 1 , 1 , 2 , 3 , 4 , 0 , 0 ] \;a_5=7:[\;\xcancel0,\quad1,\quad1,\quad2,\quad3,\quad4 ,\quad0 ,\quad0\; ] a5=7:[0 ,1,1,2,3,4,0,0] a 6 = 1 : [ 0 , 1 , 1 , 2 , 3 , 4 , 1 , 2 ] \;a_6=1:[\;\xcancel0,\quad1,\quad1,\quad2,\quad3,\quad4 ,\quad1 ,\quad2\; ] a6=1:[0 ,1,1,2,3,4,1,2] a 7 = 2 : [ 0 , 1 , 1 , 2 , 3 , 4 , 1 , 2 ] \;a_7=2:[\;\xcancel0,\quad1,\quad1,\quad2,\quad3,\quad4 ,\quad1 ,\quad2\; ] a7=2:[0 ,1,1,2,3,4,1,2]
- 状态转移方程
- d p [ i ] = m a x ( d p [ i ] , 1 + m a x ( d p [ 1 ] , d p [ 2 ] , … , d p [ i − 1 ] ) ) dp[i] = max(dp[i],1+max(dp[1], dp[2], …, dp[i-1] ) ) dp[i]=max(dp[i],1+max(dp[1],dp[2],…,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 = [ 0 , 1 0 6 , 1 0 3 , 1 0 4 , 1 0 5 , 1 0 9 , 1 , 1 0 2 ] a = [\xcancel0,10^6,10^3,10^4,10^5,10^9,1,10^2] a=[0 ,106,103,104,105,109,1,102]
-
dp[i]定义:长度为 i i i 的递增序列最小尾元素
-
dp初始值:[ 0 \xcancel0 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 \quad \quad\quad \quad dp_0\;\;\;dp_1\;\;\;dp_2\;\;\;dp_3\;\;\;dp_4\;\;\;dp_5\;\;\;dp_6\;\;\;dp_7 dp0dp1dp2dp3dp4dp5dp6dp7 初 始 值 : [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ] 初始值:[\;\xcancel0,\quad0,\;\quad0,\;\quad0,\;\quad0,\;\quad0 ,\;\quad0 ,\;\quad0\; ] 初始值:[0 ,0,0,0,0,0,0,0] a 1 = 6 : [ 0 , 1 0 6 , 0 , 0 , 0 , 0 , 0 , 0 ] \;a_1=6:[\;\xcancel0,\;\color{red}10^6,\;\quad\color{black}0,\;\quad0,\;\quad0,\;\quad0 ,\;\quad0,\;\quad0\; ] a1=6:[0 ,106,0,0,0,0,0,0] a 2 = 3 : [ 0 , 1 0 3 , 0 , 0 , 0 , 0 , 0 , 0 ] \;a_2=3:[\;\xcancel0,\;\color{red}10^3,\;\quad\color{black}0,\;\quad0,\;\quad0,\;\quad0 ,\;\quad0 ,\;\quad0\; ] a2=3:[0 ,103,0,0,0,0,0,0] a 3 = 4 : [ 0 , 1 0 3 , 1 0 4 , 0 , 0 , 0 , 0 , 0 ] \;a_3=4:[\;\xcancel0,\;10^3,\;\color{red}10^4,\;\quad \color{black}0,\;\quad0,\;\quad0 ,\;\quad0 ,\;\quad0\; ] a3=4:[0 ,103,104,0,0,0,0,0] a 4 = 5 : [ 0 , 1 0 3 , 1 0 4 , 1 0 5 , 0 , 0 , 0 , 0 ] \;a_4=5:[\;\xcancel0,\;10^3,\;10^4,\;\;\color{red}10^5,\;\quad\color{black}0,\;\quad0 ,\;\quad0 ,\;\quad0\; ] a4=5:[0 ,103,104,105,0,0,0,0] a 5 = 7 : [ 0 , 1 0 3 , 1 0 4 , 1 0 5 , 1 0 9 , 0 , 0 , 0 ] \;a_5=7:[\;\xcancel0,\;10^3,\;10^4,\;\;10^5,\;\;\color{red}10^9 ,\;\quad\color{black}0 ,\;\quad0,\; \quad0] a5=7:[0 ,103,104,105,109,0,0,0] a 6 = 1 : [ 0 , 1 , 1 0 4 , 1 0 5 , 1 0 9 , 0 , 0 , 0 ] \;a_6=1:[\;\xcancel0,\;\;\;\color{red}1,\;\;\color{black}10^4,\;\;10^5,\;\;10^9 ,\;\quad0 ,\;\quad0,\;\quad0 ] a6=1:[0 ,1,104,105,109,0,0,0] a 7 = 2 : [ 0 , 1 , 1 0 2 , 1 0 5 , 1 0 9 , 0 , 0 , 0 ] \;a_7=2:[\;\xcancel0,\;\;\;1,\;\;\color{red}10^2,\;\;\color{black}10^5,\;\;10^9 ,\;\quad0 ,\;\quad0,\; \quad0] a7=2:[0 ,1,102,105,109,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)
- 设dp[j] < a[i] 且j是最大的,则
-
优化
- 可优化环节:寻找最小的大于等于a[i]的dp数组下标
- 优化策略:dp有序,故可二分查找, O ( log n ) O(\log{n}) O(logn)
- 总体复杂度: O ( n ∗ log n ) O(n*\log{n}) O(n∗logn)
-
如何求最长序列的长度?
- 先完成递推
- 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];
}