poj 1836 Alignment（dp,LIS）

链接:poj 1836

题意：士兵站成一行，求最少要多少的士兵出列，

使得每个士兵都能至少看到一个最边上的士兵

中间某个人能看到最边上的士兵的条件是:

该士兵的身高一定强大于他某一边（左边或右边）所有人的身高，

身高序列可以是：

1  2  3   4   5   4   3   2   1  或者 

1   2   3   4   5   5   4   3   2   1

分析：要求最少出列数，就是留队士兵人数最大，

即左边的递增序列人数和右边的递减序列人数之和最大

因而可转化为求“最长升序子序列”和“最长降序子序列”问题

LIS之 n*n算法 (32MS)

#include<stdio.h>
#define max(a,b) a>b?a:b
int main()
{
    double a[1010];
    int dp1[1010],dp2[1010];
    int i,j,n,ans,max1,max2;
    while(scanf("%d",&n)!=EOF){
        for(i=1;i<=n;i++)
            scanf("%lf",&a[i]);
        ans=max1=max2=0;
        for(i=1;i<=n;i++){    //最长升序
            dp1[i]=1;
            for(j=1;j<=i;j++)
                if(a[j]<a[i]&&dp1[j]+1>dp1[i])
                    dp1[i]=dp1[j]+1;
        }
        for(i=n;i>=1;i--){      //最长降序
            dp2[i]=1;
            for(j=n;j>i;j--)
                if(a[j]<a[i]&&dp2[j]+1>dp2[i])
                    dp2[i]=dp2[j]+1;
        }
        for(i=1;i<=n;i++)       //最长升降序之和
            for(j=i+1;j<=n;j++)
                ans=max(ans,dp1[i]+dp2[j]);
        printf("%d\n",n-ans);  //最少出列数
    }
    return 0;
}<span style="font-family:KaiTi_GB2312;font-size:18px;">
</span>

LIS之 n*log n 算法 （235MS）

#include<stdio.h>
#define INF 3.0
double c[1010];
int bin_find1(int l,int r,double x)
{
    int mid=(l+r)/2;
    while(l!=r){
        if(x<c[mid])
            r=mid;
        else if(x>c[mid])
            l=mid+1;
        else
            return mid;
        mid=(l+r)/2;
    }
    return l;
}
int bin_find2(int l,int r,double x)
{
    int mid=(l+r)/2;
    while(l!=r){
        if(x>c[mid])
            r=mid;
        else if(x<c[mid])
            l=mid+1;
        else
            return mid;
        mid=(l+r)/2;
    }
    return l;
}
int main()
{
    double a[1010];
    int i,j,k,n,len_l,len_r,max;
    while(scanf("%d",&n)!=EOF){
        for(i=1;i<=n;i++)
            scanf("%lf",&a[i]);
        max=0;
        for(k=1;k<=n;k++){
            c[0]=-1;           //最长升序
            len_l=1;
            for(i=1;i<=k;i++){
                c[len_l]=INF;
                j=bin_find1(0,len_l,a[i]);
                c[j]=a[i];
                if(j==len_l)
                    len_l++;
            }
            len_l--;  
            c[k]=INF;         //最长降序
            len_r=1;
            for(i=k+1;i<=n;i++){
                c[k+len_r]=-1;
                j=bin_find2(k,k+len_r,a[i]);
                c[j]=a[i];
                if(j==k+len_r)
                    len_r++;
            }
            len_r--;
            if(max<len_l+len_r)  //最长升降序的和
                max=len_l+len_r;
        }
        printf("%d\n",n-max);
    }
    return 0;
}