1010.拦截导弹 187.导弹防御系统

#include<bits/stdc++.h>
using namespace std;
const int N=1010;
int n;
int q[N];
int f[N],g[N];
int main()
{
    while(cin>>q[n]) n++; //n为总共的导弹数量
    int res=0;
    for(int i=0;i<n;i++) //第一问就是求最长上升子序列
    {
        f[i]=1;
        for(int j=0;j<i;j++)
        {
            if(q[j]>=q[i]) //为什么是q[j]>=q[i]呢，因为导弹是单调下降的，所以前面的q[j]要高于q[i]
            {
                f[i]=max(f[i],f[j]+1);
            }
            
        }
        res=max(res,f[i]);
    }
    cout<<res<<endl; //为第一问答案
    //第二问要用到贪心
    int cnt=0;     //记录用的序列数
    for(int i=0;i<n;i++)
    {
        int k=0; //k为遍历起点，每次循环设为1
        while(k<cnt&&g[k]<q[i]) k++; //如果以k结尾的序列的值小于q[i]，说明q[i]不能放在该序列尾后，所以k++
        g[k]=q[i]; //此时找到q[i]可以放到的g数组的合适位置
        if(k>=cnt) cnt++;//cnt是从0开始，所以判断条件是k>=cnt，如果k>=cnt，说明原有序列尾后都不能放q[i]，故开辟新序列
    }
    cout<<cnt<<endl; //为第二问答案
    return 0;
}

 

 

 

 

#include<bits/stdc++.h>
using namespace std;
//导弹防御系统的题， 主要是LIS的暴搜 dfs做法
const int N=55;
int n;
int q[N];
int up[N],down[N];
int ans;
void dfs(int u,int su,int sd) //u为当前枚举到了第几个数，su为上升子序列的个数，sd为下降子序列的个数
{
    if(su+sd>=ans) return ;
    if(u==n) //如果数已经枚举完，将ans更新为su+sd并返回
    {
        ans=su+sd;
        return ;
    }
    int k=0; 
    while(k<su&&up[k]>=q[u]) k++; //还是那种贪心思路 先是上升子序列
    int t=up[k];//记录下当前up[k]，为了恢复现场
    up[k]=q[u];
    if(k<su) dfs(u+1,su,sd);//说明没有开辟新的上升子序列，dfs
    else dfs(u+1,su+1,sd);// 说明开辟了新的上升子序列
    up[k]=t;//恢复现场
    //情况2，将当前数放入下降子序列中
    k=0;
    while(k<sd&&down[k]<=q[u]) k++;
    t=down[k];
    down[k]=q[u];
    if(k<sd) dfs(u+1,su,sd);
    else dfs(u+1,su,sd+1);
    down[k]=t;
}
int main()
{
    while(cin>>n,n)
    {
        for(int i=0;i<n;i++)
        {
            cin>>q[i];
        }
        ans=n;
        dfs(0,0,0);
        cout<<ans<<endl;
    }

    
    return 0;
}