[HNU 10054] 拦截导弹

拦截导弹

Time Limit: 1000ms, Special Time Limit:2500ms, Memory Limit:32768KB

Total submit users: 1177, Accepted users: 599

Problem 10054 : No special judgement

Problem description

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

Input

输入数据为导弹依次飞来的高度，所有高度值均为不大于30000的正整数。

Output

输出只有一行是这套系统最多能拦截的导弹数和要拦截所有导弹最少要配备这种导弹拦截系统的套数。两个数据之间用一个空格隔开.

Sample Input

389 207 155 300 299 170 158 65

Sample Output

6 2

Problem Source

NOI 99

AC:

#define _CRT_SECURE_NO_WARNINGS
#include <cstdio>
#include <vector>
#include <algorithm>

const int inf = 0x3f3f3f3f;

std::vector<int> v;
std::vector<int> dp;

int read(int& n)
{
    int ch = getchar();  n = 0;
    while (ch < '0' || ch > '9') { if (ch == EOF) return EOF; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { n = (n << 1) + (n << 3) + ch - '0'; ch = getchar(); }
    return n;
}

// 求最长非上升子序列的时候 dp 的内容为下降的  5 4 3 2 1 这种
int upper_bound(const std::vector<int>& a, int left, int right, int target)
{
    int l = left, r = right, m;
    while (l < r)
    {
        m = (l + r) >> 1;
        if (a[m] <= target)
        {
            if (m == left || a[m-1] > target) return m;
            r = m - 1;
        }
        else l = m + 1;
    }
    return a[l] <= target ? l : -1;
}

// 求最长非下降子序列的时候 dp 的内容为上升的 1 2 3 4 5 这种
int lower_bound(const std::vector<int>& a, int left, int right, int target)
{
    int l = left, r = right, m;
    while (l < r)
    {
        m = (l + r) >> 1;
        if (a[m] >= target)
        {
            if (m == left || a[m-1] < target) return m;
            r = m - 1;
        }
        else l = m + 1;
    }
    return a[l] >= target ? l : -1;
}

int main()
{

    //freopen("c:/users/kiko/desktop/test.txt", "r", stdin);
    int n;
    //while (read(n) != EOF)  // TLE
    while (~read(n))  // AC
    {
        v.push_back(n);
        dp.push_back(-inf);
    }
  
    for (int i = 0; i < v.size(); ++i)
    {
        int idx = upper_bound(dp, 0, dp.size()-1, v[i]);
        if (idx != -1) dp[idx] = v[i];    
    }
    
    int max_len = 0;
    for (int i = 0; i < dp.size() && dp[i] != -inf; ++i) max_len = i + 1;
    printf("%d ", max_len);

    for (int i = 0; i < dp.size(); ++i) dp[i] = inf;

    for (int i = 0; i < v.size(); ++i)
    {
        int idx = lower_bound(dp, 0, dp.size()-1, v[i]);
        if (idx != -1) dp[idx] = v[i];
    }

    for (int i = 0; i < dp.size() && dp[i] != inf; ++i) max_len = i + 1;
    printf("%d", max_len);

    return 0;
}

第一问就是求最长不上升子序列。

这个题第二问是挺奇怪的，开始准备用暴力法，即每次求出当前的最长不上升子序列，然后排除这些元素，重复操作，直到所有元素都被排除。

但是感觉应该不是这么麻烦，后来看到了有人说只需要求最长不下降子序列即可得到第二问的解，画了个图：

题目数据里面第二问的答案是2，这里最长不下降子序列长度也为2（比如其中一个：155.00 - 300.00 ），很巧，又构思了下面这种情况，也是对的：

或者是极限情况，所有的数值都一样，此时得到的就是N，也是对的。但为什么是这样，暂时还不知道。