HDU1257 最少拦截系统 （最长上升子序列Dilworth定理/贪心）

某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统.但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能超过前一发的高度.某天,雷达捕捉到敌国的导弹来袭.由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹. 
怎么办呢?多搞几套系统呗!你说说倒蛮容易,成本呢?成本是个大问题啊.所以俺就到这里来求救了,请帮助计算一下最少需要多少套拦截系统. 

Input

输入若干组数据.每组数据包括:导弹总个数(正整数),导弹依此飞来的高度(雷达给出的高度数据是不大于30000的正整数,用空格分隔) 

Output

对应每组数据输出拦截所有导弹最少要配备多少套这种导弹拦截系统. 

Sample Input

8 389 207 155 300 299 170 158 65

Sample Output

2

注意：：下面所说的数组没有解释的话就默认下标从1开始

这道题一开始我以为是贪心，如果用贪心来解决的话，就是每次都找最接近将要来的导弹高度的上一个导弹，有点绕，举个栗子：n=5   300 301 300 30 298 ，一开始需要开一个数组存放导弹系统的状态，这里就用a数组，开始a[1]=300，然后开始将a数组从大到小排列，寻找有没有大于301的拦截导弹，结果没有，那只能从新建立一个数组a[2]=301，然后排序，再次遍历a数组，有没有比300大的拦截导弹，那就将a[2]=300，此时a[1]=300,a[2]=300，然后排列，接着寻找有没有比30大的数组，这里我们需要将a[2]赋值为30；

为什么是不a[1]呢，因为如果a[1]=305的话，然后将其改成30,此时a[1]=300,a[2]=30，如果下一个导弹是301,那就要再加一个防御系统，那就增加成本了，因此，遍历a数组的时候尽量找小一些的改变它 的值

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define ms(a,b) memset(a,b,sizeof a)
const int N=30010;
const int maxn = 1e6 + 10;
int n;
int a[30010];
int mis[30010];
int main() {
    while(scanf("%d",&n)!=EOF){
            ms(a,0);ms(mis,0);
    rep(i,1,n)
    scanf("%d",&mis[i]);
    a[1]=mis[1];
    int sum=1;
    rep(i,2,n)
    {
        sort(a+1,a+1+sum,greater<int>());
        int j;
        for(j=1;j<=sum;j++)
        if(a[j]<=mis[i]){break;}
        if(j==1)
            a[++sum]=mis[i];
        else
        a[j-1]=mis[i];
    }
    printf("%d\n",sum);
    }
    return 0;
}

下面就是用dp来解决，看其他的思路是说这道题是最长上升子序列问题，为什么？？这里有一个很不好理解的定理偏序集-Dilworth定理

那么这道题就可以改成dp了

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define ms(a,b) memset(a,b,sizeof a)
const int N=30010;
const int maxn = 1e6 + 10;
int n;
int dp[30010];
int mis[30010];
int main() {
    while(scanf("%d",&n)!=EOF){
            ms(dp,0);ms(mis,0);
            int sum=-1;
    rep(i,1,n)
    scanf("%d",&mis[i]);
    rep(i,1,n)
    {
        dp[i]=1;
        rep(j,1,i-1)
       if(mis[j]<mis[i])
            dp[i]=max(dp[j]+1,dp[i]);
        sum=max(sum,dp[i]);
    }
    printf("%d\n",sum);
    }
    return 0;
}

以上的两种方法都是接近O（n^2），下面是O（nlogn）的

#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define ms(a,b) memset(a,b,sizeof a)
const int N=30010;
const int INF=0x3f3f3f3f;
int n;
int dp[30010];
int mis[30010];
int main() {
    while(scanf("%d",&n)!=EOF){
            ms(dp,INF);ms(mis,0);
            int sum=-1;
    rep(i,1,n)
    scanf("%d",&mis[i]);
    rep(i,1,n)
    {
        *lower_bound(dp,dp+n,mis[i])=mis[i];
    }
    printf("%d\n",lower_bound(dp,dp+n,INF)-dp);
    }
    return 0;
}