wikioi--1044 拦截导弹

题目链接：http://www.wikioi.com/problem/1044/

题目其实就是最长上升子序列的变形。

下面是两个重要定理：

定理1 令（X,≤）是一个有限偏序集，并令r是其最大链的大小。则X可以被划分成r个但不能再少的反链。 其对偶定理称为Dilworth定理：

定理2 令（X,≤）是一个有限偏序集，并令m是反链的最大的大小。则X可以被划分成m个但不能再少的链。

这样问题的第一问是问一套系统最多能拦截多少个导弹，题目意思是每次不能超过上一次的高度，那么也就是求序列中最长不上升的子序列，代码中用的是O(n^2)的经典算法。

第二问呢，最少得要多少套系统才能拦截所有导弹，根据定理，最长上升子序列的长度对应的就是反链的最少个数，也就是最少的系统数。

代码实现采用的是O(nlogn)的算法，http://www.slyar.com/blog/longest-ordered-subsequence.html

#include <iostream>
#include <queue>
#include <climits>
#include <algorithm>
#include <memory.h>
#include <stdio.h>
#include <ostream>
#include <vector>
#include <list>
using namespace std;

vector<int> data;
int dp1[10000];
int dp2[10000];
int main()
{
    int tmp;
    while(scanf("%d",&tmp)!=EOF)
    {
        data.push_back(tmp);
    }
    int n = data.size();
    dp1[0] = 1;
    int ans = 1;
    int i;
    for(i = 1; i < n ; ++i)
    {
        int _max;
        _max = 0;
        for(int j = 0 ; j < i ; ++j)
        {
            if(data[j] > data[i])
            {
                _max = max(_max,dp1[j]);
            }
        }
        dp1[i] = _max+1;
        ans = max(ans,dp1[i]);
    }
    cout<<ans<<endl;

    //O(nlogn)的算法求最长上升子序列
    ans = 0;
    dp2[0] = -1;
    for(i = 0 ; i < n ; ++i)
    {
        if(data[i] > dp2[ans])
        {
            dp2[++ans] = data[i];
        }
        else
        {
            int low = 1;
            int high = ans;
            int mid;
            while(low <= high)
            {
                mid = (low + high)/2;
                if(data[i] > dp2[mid])
                {
                    low = mid+1;
                }
                else
                {
                    high = mid-1;
                }
            }
            dp2[low] = data[i];
        }
    }
    cout<<ans<<endl;
    return 0;
}