POJ 1836 Alignment

有一排人，身高可能不同，现在有一个理想状态是这排的每个人向左或向右看没有被挡住视野(当遇到等高或更高的人时会被挡住)，现在问最少让几人出列可以达到这个理想状态。

最少人出列，其实就是一个人数最多的理想状态。求一个人数最多的类似"山峰"的高度排列。那就可以从左到右、从右到左各求一遍LIS

开始用 O(n²)的写法WA了，错在搞错dp[i] 的含义，dp[i]代表以i为尾的LIS，最后输出答案时应该枚举 dp[i]+dp[j]

#include <cstdio>
#include <algorithm>
using namespace std;

int height[1024];
int dp1[1024];//up
int dp2[1024];//down

int main(){
    int N;
    scanf("%d",&N);
    for(int i=0;i<N;++i){
        double tmp;
        scanf("%lf",&tmp);
        height[i]=tmp*100000+0.1;
    }
    for(int i=0;i<N;++i){
        dp1[i]=1;
        for(int j=0;j<i;++j){
            if(height[j]<height[i]) dp1[i]=max(dp1[i],dp1[j]+1);
        }
    }
    for(int i=N-1;i>=0;i--){
        dp2[i]=1;
        for(int j=N-1;j>i;--j){
            if(height[j]<height[i]) dp2[i]=max(dp2[i],dp2[j]+1);
        }
    }
    //for(int i=0;i<N;++i) printf("i : %d	up: %d , down: %d
",i,dp1[i],dp2[i]);
    int ans=-1;
    //ans=max(ans,dp2[0]);
    //for(int i=0;i<N-1;++i)ans=max(ans,dp1[i]+dp2[i+1]);
    //ans=max(ans,dp1[N-1]);
    for(int i=0;i<N;++i)
        for(int j=i+1;j<N;++j)
            ans=max(ans,dp1[i]+dp2[j]);
    printf("%d
",N-ans);
}

用O(nlogn)的写法

#include <cstdio>
#include <algorithm>
using namespace std;

const int INF=0x3f3f3f3f;
int height[1024];
int dp1[1024];//up
int dp2[1024];//down
int S[1024];
int tot;

int B_S(int l,int r,int ob){
    int mid;
    r--;
    while(l<=r){
        mid=(l+r)>>1;
        if(S[mid]>ob) r=mid-1;
        else l=mid+1;
    }
    return l;
}

int main(){
    int N;
    scanf("%d",&N);
    for(int i=0;i<N;++i){
        double tmp;
        scanf("%lf",&tmp);
        height[i]=tmp*100000+0.1;
    }
    
    fill(S,S+N,INF);
    for(int i=0;i<N;++i){
        int pos=lower_bound(S,S+N,height[i])-S;
        dp1[i]=pos+1;
        S[pos]=height[i];
    }
    fill(S,S+N,INF);
    for(int i=N-1;i>=0;i--){
        int pos=lower_bound(S,S+N,height[i])-S;
        dp2[i]=pos+1;
        S[pos]=height[i];
    }
    //for(int i=0;i<N;++i) printf("i : %d	up: %d , down: %d
",i,dp1[i],dp2[i]);
    int ans=-1;
    //ans=max(ans,dp2[0]);
    //for(int i=0;i<N-1;++i)ans=max(ans,dp1[i]+dp2[i+1]);
    //ans=max(ans,dp1[N-1]);
    for(int i=0;i<N;++i)
        for(int j=i+1;j<N;++j)
            ans=max(ans,dp1[i]+dp2[j]);
    printf("%d
",N-ans);
}

#include <cstdio>
#include <algorithm>
using namespace std;

int height[1024];
int dp1[1024];//up
int dp2[1024];//down
int S[1024];
int tot;

int B_S(int l,int r,int ob){
    int mid;
    r--;
    while(l<=r){
        mid=(l+r)>>1;
        if(S[mid]>ob) r=mid-1;
        else l=mid+1;
    }
    return l;
}

int main(){
    int N;
    scanf("%d",&N);
    for(int i=0;i<N;++i){
        double tmp;
        scanf("%lf",&tmp);
        height[i]=tmp*100000+0.1;
    }
    tot=0;
    for(int i=0;i<N;++i){
        if(tot==0||S[tot-1]<height[i]) S[tot++]=height[i];
        else{
            //int pos=B_S(0,tot,height[i]);
            int pos=lower_bound(S,S+tot,height[i])-S;
            S[pos]=height[i];
        }
        dp1[i]=tot;
    }
    tot=0;
    for(int i=N-1;i>=0;i--){
        if(tot==0||S[tot-1]<height[i]) S[tot++]=height[i];
        else{
            //int pos=B_S(0,tot,height[i]);
            int pos=lower_bound(S,S+tot,height[i])-S;
            S[pos]=height[i];
        }
        dp2[i]=tot;
    }
    //for(int i=0;i<N;++i) printf("i : %d	up: %d , down: %d
",i,dp1[i],dp2[i]);
    int ans=-1;
    //ans=max(ans,dp2[0]);
    //for(int i=0;i<N-1;++i)ans=max(ans,dp1[i]+dp2[i+1]);
    //ans=max(ans,dp1[N-1]);
    for(int i=0;i<N;++i)
        for(int j=i+1;j<N;++j)
            ans=max(ans,dp1[i]+dp2[j]);
    printf("%d
",N-ans);
}

一种单调栈，一种从修改预设数组，都是二分

开始一直在用upper_bound，后来脑补跑数据才发现，upper_bound只能用来找不下降子序列，lower_bound是用来找严格上升子序列。