AcWing 1010. 拦截导弹（线性dp 最长上升子序列模型贪心二分）

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。

但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。

某天，雷达捕捉到敌国的导弹来袭。

由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数，导弹数不超过1000），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入格式
共一行，输入导弹依次飞来的高度。

输出格式
第一行包含一个整数，表示最多能拦截的导弹数。

第二行包含一个整数，表示要拦截所有导弹最少要配备的系统数。

数据范围
雷达给出的高度数据是不大于 30000 的正整数，导弹数不超过 1000。

输入样例：
389 207 155 300 299 170 158 65

输出样例：
6
2

题目描述

本题给定一个数组 a[N]，让我们求解两个量

第一问：该数组的最长不上升子序列（注意是不上升即可哦）

第二问：该数组最少能被几个最长不上升子序列全部覆盖（注意是不上升即可哦）

样例分析：

输入:
389 207 155 300 299 170 158 65
输出：
6
2
解释：
最少可以配2个系统，其中最长的序列长度是6
389 300 299 170 158 65
207 155

思路：

对于第一问不再过多赘述，关于如何求解，可以看之前的最长上升子序列

主要说一下第二问的贪心方案

贪心方案：

对于每一个新的导弹想要拦截它就会有两种情况：（注意指导思想是构造不上升序列）

1.如果它比所有系统的结尾值都要大,那么它接不到任何当前已经有的系统后面,只能新开一个系统。
2.如果它能接到某个已有系统的后面（即某个已有系统结尾大于等于它）,那么直觉上来说，它的贪心策略是：接在所有能接的系统中结尾最小的后面（拦截导弹【附贪心证明】）。
结尾一定是单调增的，因为如果不是单调增，那么递减的那个点一定可以接在前面某个位置。

贪心的编码具体步骤：

开一个g[]记录所有不上升子序列末尾元素，g[]一开始是空集，长度为0
遍历每个数，对于当前这个数：
- 情况1：在g[]中若所有的数都比这个数小，扩大g[]长度并记录这个数
- 情况2：在g[]中可以找到大于等于这个数的最小的数, 则将它替换所找到位置的数
可以证明g[]必定是一个单调上升的数组：
- 一开始g[]是空集，空集也是单调的一种
- 对于每个数x要记录到现有的g[]时，存在一个不等式c < x <= a <= b，其中a是将要被x替换的数（a 是 >= x 的最小的数）
- 替换之后就会变成c < x <= b，g[]的单调性没有发生改变，因此g[]是稳定单调上升的数组。

于是我们就可以在数组g中二分查找 所有能接的系统中结尾元素值最小的(g数组中元素>=a[i]就能接)，即二分模板中的寻找数的范围的左边界。

做法一：贪心+二分（O(n^2 + nlogn)）

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;
int a[N];
int dp[N];
int n;

int main()
{
    while(cin>>a[n]) ++n;
    
    for(int i=0;i<n;++i)
    {
        dp[i] = 1;
        for(int j=0;j<i;++j)
        {
            if(a[j]>=a[i])
                dp[i] = max(dp[i], dp[j] + 1);
        }
    }
    
    int res = 0;
    for(int i=0;i<n;++i) res = max(res, dp[i]);
    
    cout<<res<<endl;
    
    int g[N];
    int cnt=0;
    g[cnt++]=a[0];

    for(int i=0;i<n;++i)
    {
        
        if(a[i]>g[cnt-1]) g[cnt++]=a[i];//1.比所有系统的结尾的最大值(g[cnt])还要大,就要新开一个系统(等于不必新开系统)
        
        else//2.可以接在某个已有系统后面,要找到所有能接的系统(>=a[i]就能接)中结尾最小的
        {
            int l=0,r=cnt-1;
            while(l<r)
            {
                int mid=(l+r)/2;
                if(g[mid]>=a[i]) r=mid;
                else l=mid+1;
            }
            g[l]=a[i];//找到目标，替换
        }
    }
    cout<<cnt<<endl;
    
    return 0;
}

上面的二分+贪心做法可以应对数据范围达到1e5的情况，不过本题数据范围较小，第二问可以直接暴力求解，代码如下：

做法二：贪心+暴力（O(n^2 + n^2)）

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;
int a[N];
int dp[N];
int n;

int main()
{
    while(cin>>a[n]) ++n;
    
    for(int i=0;i<n;++i)
    {
        dp[i] = 1;
        for(int j=0;j<i;++j)
        {
            if(a[j]>=a[i])
                dp[i] = max(dp[i], dp[j] + 1);
        }
    }
    
    int res = 0;
    for(int i=0;i<n;++i) res = max(res, dp[i]);
    
    cout<<res<<endl;
    
    int g[N];
    int cnt=0;//当前系统的个数
    
    for(int i=0;i<n;++i)
    {
        int k = 0;//下方遍历所有系统，k是从0开始的系统下标
        while(k<cnt && g[k]<a[i]) ++k;//当未遍历完所有系统，且当前系统结尾元素小于当前数则执行循环
        g[k] = a[i];//替换
        if(k>=cnt) ++cnt;//没有任何一个系统结尾大于等于当前数，则开辟一个新的系统
    }
    
    cout<<cnt<<endl;
    
    return 0;
}