子序列模型
最长上升子序列
d p [ i ] dp[i] dp[i]表示以 i i i结尾的最长上子序列的长度
void solve(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
for(int i=1;i<=n;i++){
dp[i]=1;
for(int j=1;j<i;j++) //在i位置之前寻找比a[i]小的元素a[j]
if(a[j]<a[i])
dp[i]=max(dp[i],dp[j]+1); //判断能否接到a[j]后 使得序列长度增大
}
for(int i=1;i<=n;i++)
res=max(dp[i],res);
printf("%d",res);
}
二分优化 lower_bound()
求严格最长上升子序列，虽然lower_bound()查找的是序列中第一个大于等于num的数，由此f[]中存的并不是最终的最长上升子序列，而是上升子序列长度为i的最小末尾数值，但f[]的长度（即now）一定是最长上升子序列的长度。
我们当前的上升子序列长度如果已经确定，那么如果这种长度的子序列的结尾元素越小，后面的元素就可以更方便地加入到这条我们臆测的、可作为结果的上升子序列中。
复杂度越高的算法越万能，因此二分优化之后（就别想着输出序列啦）
void solve(){
scanf("%d",&n);
f[0]=-2e9; now=0; //有负数的话注意初始化 now从0开始
for(int i=1;i<=n;i++)
scanf("%d",&a[i]); //读入
for(int i=1;i<=n;i++)
if(a[i]>f[now]) //若a[i]比现有序列结尾最大的那个数还大
f[++now]=a[i]; //就把它加进来
else //否则就看它能否与前面的数进行替换
*lower_bound(f+1,f+now+1,a[i])=a[i];//查找序列中第一个大于等于a[i]的数并替换
printf("%d",now);
}
例题：P1020 [NOIP1999 普及组] 导弹拦截
例题：P2782 友好城市
输出路径
#include<iostream>
#include<cstdio>
using namespace std;
int n,a[1010],dp[1010],res;
int pos,g[1100],cnt,tmp;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
for(int i=1;i<=n;i++){
dp[i]=1;
for(int j=1;j<i;j++){
if(a[j]<a[i]){
dp[i]=max(dp[i],dp[j]+1);//ai接到aj后面
if(dp[i]>=res){
pos=i;//最后一个最靠后的最长上升子序列位置
res=dp[i];//记录最长上升子序列的长度
}
}
}
}
printf("%d\n",res); //输出长度
tmp=res-1;cnt=1; //tmp用于对应寻找子序列的元素
g[1]=a[pos]; //为子序列中最大元素
for(int i=pos-1;i>=1;i--){//从pos-1开始寻找
if(dp[i]==tmp){ //若dp值对应相等 则该位置为序列中的一个元素
g[++cnt]=a[i];
tmp--; //长度--
}
}
for(int i=cnt;i>=1;i--){ //倒序输出
printf("%d ",g[i]);
}
}
dilworth定理
不下降子序列最小个数等于最长上升子序列的长度。
例题：P1233 木棍加工
例题：P1020 [NOIP1999 普及组] 导弹拦截
字符串版最长上升子序列
例题：P1481 魔族密码
strstr(s1,s2)
作用：
判断s2是否为s1的子串。
如果没找到，返回NULL;
如果找到了，返回这个子串第一个字符的地址。
如：
char s1[]="habch",s2[]="abc"
strstr(s1,s2)就返回s1中'a'的地址
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=2100;
int n,ans,dp[N];
char s[N][80];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
cin>>s[i];
dp[i]=1;
for(int j=i-1;j>=1;j--){
if(strstr(s[i],s[j])==s[i]){
dp[i]=max(dp[i],dp[j]+1);
}
}
ans=max(dp[i],ans);
}
printf("%d",ans);
}
最长公共子序列
void solve(){
cin>>a+1>>b+1;
n=strlen(a+1);
m=strlen(b+1);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
dp[i][j]=max(dp[i-1][j],dp[i][j-1]); //继承
if(a[i]==b[j]) dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1); //新元素新状态
}
}
printf("%d",dp[n][m]);
}
二分优化
其实是将最长公共子序列问题转化为了最长上升子序列，从而利用最长上升子序列二分优化的办法解决问题。
关于为什么可以转化成LIS问题，这里提供一个解释。
A:3 2 1 4 5
B:1 2 3 4 5
我们不妨给它们重新标个号：把3标成a,把2标成b，把1标成c……于是变成：
A: a b c d e
B: c b a d e
这样标号之后，LCS长度显然不会改变。但是出现了一个性质：
两个序列的子序列，一定是A的子序列。而A本身就是单调递增的。
因此这个子序列是单调递增的。
换句话说，只要这个子序列在B中单调递增，它就是A的子序列。
#include<iostream>
#include<cstdio>
#include<cstring>
#define inf 0x3f3f3f3f
using namespace std;
const int N=101000;
int n,a[N],b[N],f[N];
int mp[N];
int main(){
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i]; mp[a[i]]=i;
}
for(int i=1;i<=n;i++){
cin>>b[i];
}
memset(f,inf,sizeof f);
f[0]=0;
int len=0;
for(int i=1;i<=n;i++){
int l=0,r=len,mid;
if(mp[b[i]]>f[len])
f[++len]=mp[b[i]];
else{
while(l<r){
mid=(l+r)/2;
if(f[mid]>mp[b[i]]) r=mid;
else l=mid+1;
}
f[l]=min(mp[b[i]],f[l]);
}
}
cout<<len;
}
一个比较简洁的版本
int main(){
cin>>n;
memset(f,0x3f,sizeof f);
for(int i=1;i<=n;i++) {
int x; cin>>x;
mp[x]=i; //存地址i
}
for(int i=1;i<=n;i++){
int x; cin>>x;
x=mp[x]; //取x的地址
*lower_bound(f+1,f+n+1,x)=x;
}
printf("%d",lower_bound(f+1,f+1+n,f[0])-f-1);
}
输出路径
void getlcs(int la,int lb){
if(!la||!lb) return ;
if(g[la][lb]==1){
getlcs(la-1,lb-1);
printf("%c",a[la]);
}
else if(g[la][lb]==-1) getlcs(la-1,lb);
else getlcs(la,lb-1);
}
int main(){
cin>>a+1>>b+1;
n=strlen(a+1);
m=strlen(b+1);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(dp[i-1][j]>dp[i][j-1])
dp[i][j]=dp[i-1][j],g[i][j]=-1;
else
dp[i][j]=dp[i][j-1],g[i][j]=0;
if(a[i]==b[j])
if(dp[i-1][j-1]+1>dp[i][j])
dp[i][j]=dp[i-1][j-1]+1,g[i][j]=1;
}
}
if(!dp[n][m]) printf("0");
else{
printf("%d\n",dp[n][m]);
getlcs(n,m);
}
}
最长公共上升子序列
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&m);
for(int i=1;i<=m;i++)
scanf("%d",&b[i]);
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
dp[i][j]=dp[i-1][j];
if(a[i]==b[j]){
dp[i][j]=max(dp[i][j],1);
for(int k=1;k<j;k++){
if(b[k]<b[j])
dp[i][j]=max(dp[i][j],dp[i][k]+1);
}
}
}
}
// 优化
// for(int i=1;i<=n;i++){
// int maxx=1;
// for(int j=1;j<=m;j++){
// dp[i][j]=dp[i-1][j];
// if(b[j]<a[i]) maxx=max(maxx,dp[i][j]+1);
// if(a[i]==b[j]) dp[i][j]=max(dp[i][j],maxx);
// }
// }
for(int i=1;i<=n;i++)
res=max(res,dp[n][i]);
printf("%d",res);
}
输出路径
void getlcis(int p){
if(!p) return ;
getlcis(g[n][p]);
printf("%d ",a[p]);
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
scanf("%d",&m);
for(int i=1;i<=m;i++)
scanf("%d",&b[i]);
for(int i=1;i<=n;i++){
for(int j=1,t=0;j<=m;j++){
// dp[i][j]=dp[i-1][j];
if(a[i]==b[j]){
dp[i][j]=dp[i-1][t]+1;
for(int k=1;k<=dp[i-1][t];k++){
g[j][k]=g[t][k];
}
g[j][dp[i][j]]=a[i];
}
else dp[i][j]=dp[i-1][j];
if(b[j]<a[i] && dp[i][j]>dp[i][t])
t=j;
}
}
for(int i=1;i<=m;i++)
if(dp[n][i]>dp[n][p])
p=i;
printf("%d\n",dp[n][p]);
for(int i=1;i<=dp[n][p];i++)
printf("%d ",g[p][i]);
return 0;
}
输出字典序最小路径
void getlcis(int x){
if(pre[x]==0) printf("%d",a[x/501]);
else{
getlcis(pre[x]);
printf(" %d",a[x/501]);
}
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
}
scanf("%d",&m);
for(int i=1;i<=m;i++){
scanf("%d",&b[i]);
}
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(a[i]==b[j]){
for(int f=dp[i][j]=1;f<i;f++)
for(int k=1;k<j;k++){
if(a[i]==b[j]&&a[f]<a[i])
if(dp[f][k]+1>dp[i][j]){
dp[i][j]=dp[f][k]+1;
pre[i*501+j]=f*501+k;
}
}
}
if(dp[i][j]>dp[lx][ly])
lx=i,ly=j;
}
}
printf("%d\n",dp[lx][ly]);
getlcis(lx*501+ly);
}
附：子序列经典题：P1020 [NOIP1999 普及组] 导弹拦截
某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
输入导弹依次飞来的高度（雷达给出的高度数据是\le 50000≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
本套系统最多拦截多少导弹—>最长不下降子序列长度 —>upper_bound()+greater<int>
最少配备多少个系统—>不下降子序列的最小个数—>最长上升子序列长度—>lower_bound()
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=110000;
int n,len1,len2;
int a[N],dp1[N],dp2[N];
int main(){
while(cin>>a[++n]);
n--; len1=1,len2=1;
dp1[1]=dp2[1]=a[1];
for(int i=2;i<=n;i++){
if(dp1[len1]>=a[i]) dp1[++len1]=a[i]; //最长不上升
else *upper_bound(dp1+1,dp1+1+len1,a[i],greater<int>())=a[i];
if(dp2[len2]< a[i]) dp2[++len2]=a[i]; //最长上升
else *lower_bound(dp2+1,dp2+1+len2,a[i])=a[i];
}
printf("%d %d",len1,len2);
return 0;
}
扫一扫
1395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
