[dp]最长单调递增子序列

https://www.51nod.com/tutorial/course.html#!courseId=12

解题关键:

如果将子序列按照长度由短到长排列,将他们的最大元素放在一起,形成新序列B{b1,b2,……bj},则序列B满足b1 < b2 < …… <bj。这个关系比较容易说明,假设bxy表示序列A中长度为x的递增序列中的第y个元素,显然,如果在序列B中存在元素bmm > bnn,且m < n则说明子序列Bn的最大元素小于Bm的最大元素,因为序列是严格递增的,所以在递增序列Bn中存在元素bnm < bnn,且从bn0到bnm形成了一个新的长度为m的递增序列,因为bmm > bnn,所以bmm > bnm,这就说明在序列B中还存在一个长度为m,最大元素为bnm < bmm的递增子序列,这与序列的定义,bmm是所有长度为m的递增序列中第m个元素最小的序列不符,所以序列B中的各元素严格递增。

注意liss存的是下标,主要是为了求pre用,若只求max,你当然可以设成值。

1、只求数量模板

(1)liss为索引模板

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<algorithm>
 4 #include<cstdlib>
 5 #include<iostream>
 6 using namespace std;
 7 typedef long long ll;
 8 int arr[50002],liss[50002];
 9 int find1(int i,int l,int r){
10     int mid;
11     while(l<r){
12         mid=(l+r)>>1;
13         if(arr[liss[mid]]>arr[i]) r=mid;
14         else l=mid+1;
15     }
16     return r;
17 }
18 int lis(int len){
19     int max=1;
20     liss[0]=0;
21     for(int i=0;i<len;i++){
22         int index=find1(i,0, max-1);
23         if(index==max-1&&arr[liss[index]]<arr[i]){
24             liss[max++]=i;
25             continue;
26         }
27         liss[index]=i;
28     }
29     return max;
30 }
31 int main(){
32     int n;
33     cin>>n;
34     for(int i=0;i<n;i++){
35         cin>>arr[i];
36     }
37     ll ans=lis(n);
38     printf("%lld\n",ans);
39     return 0;
40 }

(2)liss为值模板

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<algorithm>
 4 #include<cstdlib>
 5 #include<iostream>
 6 using namespace std;
 7 typedef long long ll;
 8 int arr[50002],liss[50002];
 9 int find1(int i,int l,int r){
10     int mid;
11     while(l<r){
12         mid=(l+r)>>1;
13         if(liss[mid]>arr[i]) r=mid;
14         else l=mid+1;
15     }
16     return r;
17 }
18 int lis(int len){
19     int max=1;
20     liss[0]=0;
21     for(int i=0;i<len;i++){
22         int index=find1(i,0, max-1);
23         if(index==max-1&&liss[index]<arr[i]){
24             liss[max++]=arr[i];
25             continue;
26         }
27         liss[index]=arr[i];
28     }
29     return max;
30 }
31 int main(){
32     int n;
33     cin>>n;
34     for(int i=0;i<n;i++){
35         cin>>arr[i];
36     }
37     ll ans=lis(n);
38     printf("%lld\n",ans);
39     return 0;
40 }

2、带路径模板

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<algorithm>
 4 #include<cstdlib>
 5 #include<iostream>
 6 using namespace std;
 7 typedef long long ll;
 8 int arr[50002],liss[50002],pre[50002],res[50002];
 9 int find1(int i,int l,int r){
10     int mid;
11     while(l<r){
12         mid=(l+r)>>1;
13         if(arr[liss[mid]]>arr[i]) r=mid;
14         else l=mid+1;
15     }
16     return r;
17 }
18 int lis(int len){
19     int max=1;
20     liss[0]=0;
21     for(int i=0;i<len;i++){
22         int index=find1(i,0, max-1);
23         if(index==0&&arr[liss[index]]>=arr[i]){
24             liss[index]=i;
25             continue;
26         }//增加这条语句主要是pre的影响,不需要路径的话,完全可以去掉。
27         if(index==max-1&&arr[liss[index]]<arr[i]){
28             liss[max++]=i;
29             pre[i]=liss[index];
30             continue;
31         }
32         liss[index]=i;
33         pre[i]=liss[index-1];
34     }
35
36     int k=liss[max-1],t=max-1;
37     while(pre[k]!=k){
38         res[t--]=arr[k];
39         k=pre[k];
40     }
41     res[t]=arr[k];
42     return max;
43 }
44 int main(){
45     int n;
46     cin>>n;
47     for(int i=0;i<n+2;i++){
48         pre[i]=i;
49     }
50     for(int i=0;i<n;i++){
51         cin>>arr[i];
52     }
53     ll ans=lis(n);
54     printf("%lld\n",ans);
55     for(int i=0;i<ans;i++){
56         printf("%d ",res[i]);
57     }
58     printf("\n");
59 }
时间: 2024-08-05 19:33:34

[dp]最长单调递增子序列的相关文章

最长单调递增子序列 POJ 3903 Stock Exchange .

题目传送门 : -------->点这里点这里<---------- 题目大意: 给出一串正整数,个数为N个.1<=N<=100000.求最长单调递增子序列长度. 样例输入: 6 5 2 1 4 5 3 3 1 1 1 4 4 3 2 1 样例输出: 3 1 1 =================================================================== 最长单调递增子序列问题的DP朴素算法复杂度为 O(n^2); 然而题目中的 N 最大有

hdoj 5087 Revenge of LIS II 【第二长单调递增子序列】

题目:hdoj 5087 Revenge of LIS II 题意:很简单,给你一个序列,让你求第二长单调递增子序列. 分析:其实很简单,不知道比赛的时候为什么那么多了判掉了. 我们用O(n^2)的时间求单调递增子序列的时候,里面在加一层循环维护sum数组,表示前面有几个可以转移当当前,求前面sum的和保存到当前. 最后求最后一个sum[n-1]是否为1就ok,为1的话在最长的基础上减一,否则就是最长的. AC代码: #include <iostream> #include <algor

最长单调递增子序列的三种解法

问题描述: 找出由n个数组成的序列的最长单调递增子序列 解法一:转化成LCS问题求解,时间复杂度为O(n*n). 思路:原序列为A,把A按升序排序得到序列B,求出A,B序列的最长公共子序列,即为A的最长单调递增子序列. #include<iostream> #include<algorithm> #include<string> #include<cstdio> using namespace std; //转化成LCS问题,时间复杂度O(n*n) int

最长单调递增子序列问题

题目:设计一个 O( n ^ 2 )复杂度的算法,找出由 n 个数组成的序列的最长单调递增子序列. import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); while (scanner.hasNext()) { int n = scanner.nextInt(); int[] nums = new

求最长单调递增子序列

//求最长单调递增子序列 #include<stdio.h> #define MAXN 20 void disp(int a[],int b[],int k){ int i; for(i=k-1;i>0;i--){ if(b[k] == b[i]+1 && a[i] <= a[k]){ disp(a,b,i); break; } } printf("%d ",a[k]); } int maxL(int b[],int n){ //求数组b中最大值

最长单调递增子序列-LIS问题

http://zju.acmclub.com/index.php?app=problem_title&id=1&problem_id=1911 最长单减子序列.最长单增子序列.相继元素之间满足某种条件(例如绝对值之差不超过d)的最长子序列等,都是一个类型的动态规划. 下面给出一个n平方级别的基本算法. 思路:定义dp[i]代表A[i:n]中,以A[i]为开头的最长单增序列的长度. 从A[i-1]开始,最长单调递增序列应该按下列方法求出: 在A[i],A[i+1],A[i+2],-,A[n]

最长单调递增子序列——动态规划

题目描述: 给定一个序列X[0···n],找出它的最长的单调递增子序列(Longest Increasing Subsequence) 解题思路: 使用动态规划方法. 对于i= 1, 2, --,n,考虑以xi作为最后项的最长递增子序列的长度C[i]. 如果在xi项前面存在xj < xi , 那么 C[i] = max{C[j]} +1:否则,C[i] = 1. 因此, C[i] = max{C[j]} + 1, 存在j,1<=j<i, xj<xi C[i] = 1, 所有j,1&

最长单调递增子序列

设辅助数组b,定义b[i]表示以a[i]为结尾的最长递增子序列的长度,则序列L的最长递增子序列的长度为maxb[l]; 显然b[i]满足最有子结构的性质,可得状态转移方程为: b[1]=1; b[i]=max(b[k]+1); 该状态转移方程表示在a[i]前面找到满足a[k]<=a[i],1<=k<i;的最大b[k],则以a[i]为结尾的最长递增子序列的长度就是b[k]+1. #include<stdio.h> #include<string.h> int a[1

NYOJ17 最长单调递增子序列 线性dp

题目链接: http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=17 分析: i=1 dp[i]=1 i!=1 dp[i]=max(dp[j]+1)  j<i&&a[j]<a[i] 代码如下: #include<bits/stdc++.h> using namespace std; int main() { int n; scanf("%d",&n); getchar(); while(