自动搬运

查看原文

来自洛谷，原作者为

	玫葵之蝶 **

搬运于2025-08-24 21:54:14，当前版本为作者最后更新于2017-10-08 01:48:05，作者可能在搬运后再次修改，您可在原文处查看最新版

自动搬运只会搬运当前题目点赞数最高的题解，您可前往洛谷题解查看更多

以下是正文

首先宣传blog：blog

###题解

这个题明显是dp，我们来考虑如何dp。

我们把四种状态：（本列）选1，选2，选3（大于等于上一个），选3（小于等于上一个）

分别称为：状态1，状态2，状态3，状态4

那么，我们可以发现，状态1可以由前面的状态1，2，3，4推过来，只要满足那一位所选的数小于等于当前的数。

类似的，状态2也可以由前面的状态1，2，3，4推过来，只要满足条件。

然而，状态3却不可以由状态4递推过来，因为必须保证方向相同。

同样的，状态4也不可以由状态3递推过来。

我们可以设计这样一个状态：

$dp(k,i)表示以第i位在第k种状态结尾的最大序列长度$

$转移如下：$

$dp(1,i)=max(dp(k,j))(1<=k<=4,1<=j<i,val_{1,j}<=val_{1,i})+1$

$dp(2,i)=max(dp(k,j))(1<=k<=4,1<=j=val_{1,i})+1$

$dp(3,i)=max(dp(k,j))(1<=k<=4,k\not =4 ,1<=j<i,val_{1,j}<=val_{1,i})+1$

$dp(4,i)=max(dp(k,j))(1<=k<=4,k\not =3,1<=j=val_{1,i})+1$

暴力转移就是$O(n^2)$

然而我们可以用数据结构来优化查询，比如线段树。

我们可以对于每一种状态建一棵线段树，然后每次转移时多查询几次，这样不容易错，然后每次计算完答案之后将值插入到线段树中。

跑得还挺快，最慢的点400ms

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#define ll long long
using namespace std;
inline int read(){
    int x=0;char ch=' ';int f=1;
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')f=-1,ch=getchar();
    while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
    return x*f;
}
int n,size;
int a[100001],b[100001],c[100001],num[300001];
int dp[5][100001],t[5][1200001];
inline void insert(int id,int rt,int l,int r,int pos,int v){
    if(l==r){t[id][rt]=max(t[id][rt],v);return;}
    int mid=(l+r)>>1;
    if(pos<=mid)insert(id,rt<<1,l,mid,pos,v);
    else insert(id,rt<<1|1,mid+1,r,pos,v);
    t[id][rt]=max(t[id][rt<<1],t[id][rt<<1|1]);
}
inline int query(int id,int rt,int l,int r,int L,int R){
    if(L<=l&&r<=R)return t[id][rt];
    int mid=(l+r)>>1;
    int ans=0;
    if(L<=mid)ans=max(ans,query(id,rt<<1,l,mid,L,R));
    if(mid+1<=R)ans=max(ans,query(id,rt<<1|1,mid+1,r,L,R));
    return ans;
}
int main(){
    n=read();
    for(int i=1;i<=n;i++)a[i]=read(),num[++size]=a[i];
    for(int i=1;i<=n;i++)b[i]=read(),num[++size]=b[i];
    for(int i=1;i<=n;i++)c[i]=read(),num[++size]=c[i];
    sort(num+1,num+size+1);
    size=unique(num+1,num+size+1)-num-1;
    for(int i=1;i<=n;i++)a[i]=lower_bound(num+1,num+size+1,a[i])-num;
    for(int i=1;i<=n;i++)b[i]=lower_bound(num+1,num+size+1,b[i])-num;
    for(int i=1;i<=n;i++)c[i]=lower_bound(num+1,num+size+1,c[i])-num;
    for(int i=1;i<=n;i++){
        dp[1][i]=max(dp[1][i],query(1,1,1,size,1,a[i]));
        dp[1][i]=max(dp[1][i],query(2,1,1,size,1,a[i]));
        dp[1][i]=max(dp[1][i],query(3,1,1,size,1,a[i]));
        dp[1][i]=max(dp[1][i],query(4,1,1,size,1,a[i]));
        dp[1][i]++;
        dp[2][i]=max(dp[2][i],query(1,1,1,size,b[i],size));
        dp[2][i]=max(dp[2][i],query(2,1,1,size,b[i],size));
        dp[2][i]=max(dp[2][i],query(3,1,1,size,b[i],size));
        dp[2][i]=max(dp[2][i],query(4,1,1,size,b[i],size));
        dp[2][i]++;
        dp[3][i]=max(dp[3][i],query(1,1,1,size,1,c[i]));
        dp[3][i]=max(dp[3][i],query(2,1,1,size,1,c[i]));
        dp[3][i]=max(dp[3][i],query(3,1,1,size,1,c[i]));
        dp[3][i]++;
        dp[4][i]=max(dp[4][i],query(1,1,1,size,c[i],size));
        dp[4][i]=max(dp[4][i],query(2,1,1,size,c[i],size));
        dp[4][i]=max(dp[4][i],query(4,1,1,size,c[i],size));
        dp[4][i]++;
        insert(1,1,1,size,a[i],dp[1][i]);
        insert(2,1,1,size,b[i],dp[2][i]);
        insert(3,1,1,size,c[i],dp[3][i]);
        insert(4,1,1,size,c[i],dp[4][i]);
    }
    int ans=0;
    for(int k=1;k<=4;k++){
        for(int i=1;i<=n;i++){
            ans=max(ans,dp[k][i]);
        }
    }
    printf("%d",ans);
    return 0;
}