拦截导弹（九度教程第 95 题）

拦截导弹（九度教程第 95 题）

时间限制：1 秒 内存限制：32 兆 特殊判题：否

1.题目描述：

某国为了防御敌国的导弹袭击，开发出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，并观测到导
弹依次飞来的高度，请计算这套系统最多能拦截多少导弹。拦截来袭导弹时，必须按来袭导弹袭击的时间顺序，不允许先拦截后面的导弹，再拦截前面的导弹。

输入：
每组输入有两行，第一行，输入雷达捕捉到的敌国导弹的数量 k（k<=25），第二行，输入 k 个正整数，表示 k 枚导弹的高度，按来袭导弹的袭击时间顺序给出，以空格分隔。
输出：
每组输出只有一行，包含一个整数，表示最多能拦截多少枚导弹。

样例输入：
8
300 207 155 300 299 170 158 65
样例输出：
6
来源：
2007 年北京大学计算机研究生机试真题

2.基本思路

该问题属于求解最长递增子序列问题(LIS)的变种即最长递减子序列，首先对于带求解的集合为 A = { a 1 , a 2 , . . . , a n } A=\{a_1,a_2,...,a_n\} A={a1​,a2​,...,an​}，这里我们可以利用动态规划的思想进行求解，首先定义F[i]，其表示以元素$a_i$作为结束时最长递增子序列长度。那么如果有$a_i>a_j$那么F[i]=F[j]+1，其中 j ∈ { 1 , 2 , . . , i − 1 } j∈\{1,2,..,i-1\} j∈{1,2,..,i−1}.于是可以得到如下递推方程:
F [ i ] = m a x { 1 , F [ j ] + 1 } 其 中 j &lt; i 且 a j ≥ a i F[i]=max\{1,F[j]+1\}其中j&lt;i且a_j≥a_i F[i]=max{1,F[j]+1}其中j<i且aj​≥ai​
最后将数组F[1,…,n]遍历一遍取其中最大的元素最为最终过的答案，该问题的时间复杂度为$O(n^2)$

3.代码实现

#include <iostream>
# define N 26

using namespace std;

int num[N];//存储序列
int F[N]={0};//F[i]表示，从1...i的最长递增子序列长度
int main()
{
    int n;//序列的长度
    int curlength;//当期所求的的长度
    int curmax;
    int ans;

    while(scanf("%d",&n)!=EOF){
        F[1]=1;
        ans = 0;
        for(int i=1;i<=n;i++){
            scanf("%d",&num[i]);
        }
        for(int i=2;i<=n;i++){//求F[2]->F[n]
            curmax=0;
            curlength=0;
            for(int j=1;j<i;j++){
                if(num[j]>=num[i])
                    curlength = F[j]+1;
                if(curlength>curmax){
                    curmax = curlength;
                }
                if(curmax==0){//和1取max
                    curmax=1;
                }
            }
            F[i]=curmax;//得到F[i]的值
        }
        for(int i=1;i<=n;i++){
            if(ans<F[i])
                ans=F[i];
        }
        printf("%d\n",ans);
    }

    return 0;
}
/*
样例输入;
8
300 207 155 300 299 170 158 65
样例输出;
6
*/

二刷代码(比较精简：推荐)

#include <iostream>
#define N 25
using namespace std;

int num[N];
int F[N];
int main()
{
    int k;
    while(~scanf("%d",&k)){
        for(int i=1;i<=k;i++)
            scanf("%d",&num[i]);
        F[1]=1;
        for(int i=2;i<=k;i++){
            int max=INT_MIN;
            int cur=0;
            for(int j=1;j<i;j++){
                if(num[i]<=num[j])
                    cur=F[j]+1;
                if(cur>max)
                    max=cur;
            }
            F[i]=max;
        }
        int ans=0;
        for(int i=1;i<=k;i++){
            if(ans<F[i])
                ans=F[i];
        }
        printf("%d\n",ans);
    }
    return 0;
}
/*
8
300 207 155 300 299 170 158 65
*/

下面讲讲关于怎么打印目标子序列的问题，其实我们只需要再额外定义一个数组，用于存储其来时的路即可，然后通过该数组递归地往回调用，便可以得到整整条完整的路径了。
实现代码如下所示：

#include <iostream>
#include <climits>
#define N 25
using namespace std;

int num[N];
int F[N];
int src[N];

void backtrack(int x){
    if(x==src[x]){
        printf("%d ",num[x]);
    }
    else{
        backtrack(src[x]);
        printf("%d ",num[x]);
    }
}
int main()
{
    int k;
    while(~scanf("%d",&k)){
        for(int i=1;i<=k;i++)
            scanf("%d",&num[i]);

        F[1]=1;
        src[1]=1;
        for(int i=2;i<=k;i++){
            int Max=INT_MIN;
            int cur=0;
            int idx=0;
            for(int j=1;j<i;j++){
                if(num[i]<=num[j]){
                    cur=F[j]+1;
                    if(cur>Max){
                        Max=cur;
                        idx=j;
                    }
                }

            }
            if(Max>1){
                F[i]=Max;
            }
            else{
                F[i]=1;
                idx=i;
            }
            src[i]=idx;//记录来时的路
        }
        int max=0,ans;
        for(int i=1;i<=k;i++){
            if(F[i]>max){
                max=F[i];
                ans=i;
            }
        }
        backtrack(ans);
        printf("\n");
    }
    return 0;
}
/*
8
300 207 155 300 299 170 158 65
*/