二维动态规划&&二分查找的动态规划&&最长递增子序列&&最长连续递增子序列
题目描述与背景介绍
背景题目：
[674. 最长连续递增序列]https://leetcode-cn.com/problems/longest-continuous-increasing-subsequence/
[300. 最长递增子序列]https://leetcode-cn.com/problems/longest-increasing-subsequence/
这两个都是DP的经典题目，674比较简单。
代码：
class Solution {
public int findLengthOfLCIS(int[] nums) {
if(nums.length == 0){//边界判断
return 0;
}else if(nums.length == 1){
return 1;
}
int[] dp = new int[nums.length];
dp[0] = 1;//dp[i]是以nums[i]结尾的最长连续递增子序列的长度
int maxLen = 1;
for(int i = 1;i < nums.length;i++){
if(nums[i] > nums[i - 1]){
dp[i] = dp[i - 1] + 1;
}else{
dp[i] = 1;
}
maxLen = Math.max(dp[i],maxLen);
}
return maxLen;
}
}
300题相对来说暴力解法也相对简单。
求解dp[i] 时，要遍历 dp[0] ~ dp[i-1],寻找满足nums[j] < nums[i] 的j(首先j<i),那么dp[i] = dp[j] + 1,若找不到这样的j，则dp[i] = 1,因为每个数字单独都能成为一个子序列。
代码：
class Solution {
public int lengthOfLIS(int[] nums) {
if(nums.length == 1){
return 1;
}
int[] dp = new int[nums.length];
dp[0] = 1;//初始化
int maxLen = 1;
for(int i = 1;i < nums.length;i++){
dp[i] = 1;//每个数字首先单独成为一个序列
for(int j = 0;j < i;j++){
if(nums[i] > nums[j]){
dp[i] = Math.max(dp[i], dp[j] + 1);//更新dp[i]
}
}
maxLen = Math.max(maxLen, dp[i]);//更新最大长度。
}
return maxLen;
}
}
300题的优化
仔细分析发现，在求解dp[i]时，要遍历nums[0]~nums[i - 1]。总的来说，上述暴力解法的时间复杂度是O(n^2) 。
O(n^2) 的复杂度还是有些太大，而 O(n^2) 下稍微优化有 O(nlogn) 的算法。
寻找满足条件的j时，其实可以利用二分查找。
用f[i]表示递增子序列长度为i的末尾最小元素。比如有2个不同的长度为3的递增子序列，一个末尾元素为9，一个末尾元素为12，那么，此时f[i]=12。
一旦这样规定，f[]就是单调递增的，长度为i(假设i>j)的子序列的末尾最小元素一定大于长度为j的子序列的末尾最小元素。
为什么？
取所有长度为i的子序列构成的集合为A和所有长度为j的子序列构成的集合为B(假设i>j)。
长度为i的子序列集合中一定存在包含某个长度为j的子序列，及存在a∈A，使得b∈B满足b是a的子序列。
f[i]是A中子序列末尾数的最小值，f[j]是B中子序列末尾数的最小值。则f[i]>=a(末尾)>b(末尾)>=f[j]，因此f[]严格单调递增。
二分查找时要找到使得f[j]< nums[i] <= f[j+1] 成立的最大的j，返回j。
class Solution {
public int lengthOfLIS(int[] nums) {
if(nums.length == 1){
return 1;
}
int[] dp = new int[nums.length];
dp[0] = 1;//初始化
int[] f = new int[nums.length + 1];
f[1] = nums[0];
int maxLen = 1;
for(int i = 1;i < nums.length;i++){
dp[i] = binarySearch(f,1,maxLen,nums[i]) + 1;
if(f[dp[i]] == 0||nums[i] < f[dp[i]]){//更新f[],如果原来是0，直接更新，如果不是，比较大小。
f[dp[i]] = nums[i];
}
maxLen = Math.max(maxLen, dp[i]);//更新最大长度。
}
return maxLen;
}
private int binarySearch(int[] f,int first,int end,int curNumber){
if(end < first){
return 0;
}
if(curNumber <= f[first]){
return first - 1;
}
if(curNumber > f[end]){
return end;
}else if(curNumber == f[end]){
return end - 1;
}
if(curNumber > f[(first+end)/2]){
return binarySearch(f,(first+end)/2 + 1,end,curNumber);
}else{
return binarySearch(f,first,(first+end)/2 - 1,curNumber);
}
}
}
本题
[354. 俄罗斯套娃信封问题]https://leetcode-cn.com/problems/russian-doll-envelopes/
在本题中，要找到二维的最长递增子序列的长度，同时满足
Wi<Wj<...<Wk
Hi<Hj<...<Hk
但本题并不是一维递增子序列问题的简单扩展，原因是信封不按照数组中的先后顺序。
如何获取套娃时这些信封的先后顺序呢？
简单来说有以下三种方法：
- 按某一维度升序排列
- 按某一维度升序排列，出现相等时另一位维度在此基础上降序排列
- 按面积升序排列
按某一维度升序排列，出现相等时另一位维度在此基础上降序排列：
第一维度相等时，无论第二维度如何都不能满足题意，因此，第二维降序可以保证任意子序列只选择第一维度相等的其中一个。
暴力搜索代码：
class Solution {
public int maxEnvelopes(int[][] envelopes) {
Arrays.sort(envelopes,new Comparator<int[]>(){
public int compare(int[] ob1,int[] ob2){
if(ob1[0]>ob2[0]){
return 1;
}else if(ob1[0]<ob2[0]){
return -1;
}else{
if(ob1[1]<ob2[1]){
return 1;
}else if(ob1[1]>ob2[1]){
return -1;
}else{
return 0;
}
}
}
});
int[] dp = new int[envelopes.length];
dp[0] = 1;
if(envelopes.length>1){
int maxEnvelopes = 1;
for(int i = 1;i<envelopes.length;i++){
dp[i] = 1;
for(int j = 0;j < i;j++){
if(envelopes[i][1] > envelopes[j][1]){
dp[i] = Math.max(dp[i],dp[j] + 1);
}
}
maxEnvelopes = Math.max(maxEnvelopes,dp[i]);
}
return maxEnvelopes;
}else{
return 1;
}
}
}
二分查找代码：
class Solution {
public int maxEnvelopes(int[][] envelopes) {
Arrays.sort(envelopes,new Comparator<int[]>(){
public int compare(int[] ob1,int[] ob2){
if(ob1[0]>ob2[0]){
return 1;
}else if(ob1[0]<ob2[0]){
return -1;
}else{
if(ob1[1]<ob2[1]){
return 1;
}else if(ob1[1]>ob2[1]){
return -1;
}else{
return 0;
}
}
}
});
int[] dp = new int[envelopes.length];
dp[0] = 1;
int[] f = new int[envelopes.length + 1];
f[1] = envelopes[0][1];
if(envelopes.length>1){
int maxEnvelopes = 1;
for(int i = 1;i<envelopes.length;i++){
dp[i] = binarySearch(f,1,maxEnvelopes,envelopes[i][1]) + 1;
if(f[dp[i]]==0||envelopes[i][1]<f[dp[i]]){//更新f[]数组
f[dp[i]] = envelopes[i][1];
}
maxEnvelopes = Math.max(maxEnvelopes,dp[i]);
}
return maxEnvelopes;
}else{
return 1;
}
}
private int binarySearch(int[] f,int first,int end,int curNumber){
if(curNumber > f[end]){
return end;
}else if(curNumber == f[end]){
return end - 1;
}
if(curNumber <= f[first]){
return first - 1;
}
if(curNumber > f[(first + end)/2]){
return binarySearch(f,(first + end)/2+1,end,curNumber);
}else{
return binarySearch(f,first,(first + end)/2-1,curNumber);
}
}
}
排序时只考虑第一维度：
class Solution {
public int maxEnvelopes(int[][] envelopes) {
Arrays.sort(envelopes,new Comparator<int[]>(){
public int compare(int[] ob1,int[] ob2){//排序时只考虑第一维度
if(ob1[0]>ob2[0]){
return 1;
}else if(ob1[0]<ob2[0]){
return -1;
}else{
return 0;
}
}
});
int[] dp = new int[envelopes.length];
dp[0] = 1;
if(envelopes.length>1){
int maxEnvelopes = 1;
for(int i = 1;i<envelopes.length;i++){
dp[i] = 1;
for(int j = 0;j < i;j++){
if(envelopes[i][1] > envelopes[j][1]&&envelopes[i][0] > envelopes[j][0]){//由于第一维度可能存在相等的数，加一个第一维度的比较
dp[i] = Math.max(dp[i],dp[j] + 1);
}
}
maxEnvelopes = Math.max(maxEnvelopes,dp[i]);
}
return maxEnvelopes;
}else{
return 1;
}
}
}
浙公网安备 33010602011771号