最长上升子序列模型（2）

拦截导弹

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

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

解法：反链定理，即 求所需最少个非上升子序列的数目 == 求最长上升子序列

#include <iostream>

using namespace std;

const int N=1010;

int n,a[N],f[N];

int main()
{
    while(cin>>a[n]) n++;  //此题读入较为特殊 可用 stringstream
    int res=0;
    for(int i=0;i<n;i++)  //先输出最多能拦截的导弹数（最长非上升子序列）
    {
        f[i]=1;
        for(int j=0;j<i;j++)
            if(a[i]<=a[j])
                f[i]=max(f[i],f[j]+1);
        res=max(res,f[i]);
    }
    cout<<res<<endl;	
    res=0;
    for(int i=0;i<n;i++){  //使用最长上升子序列的贪心求法（可用二分优化）
        int k=0;
        while(k<res&&a[k]<a[i]) k++;  //此处做法等同于另开一个数组存储最长上升子序列
        a[k]=a[i];
        if(k==res) res++;
    }
    cout<<res<<endl;
    return 0;
}

---

导弹防御系统

数据范围
1≤n≤50
输入样例：
5
3 5 2 4 1
0
输出样例：
2
样例解释
对于给出样例，最少需要两套防御系统。

一套击落高度为 3,4 的导弹，另一套击落高度为 5,2,1 的导弹。

解法：此题为拦截导弹的升级版，可用 dfs 分别将每个导弹的高度放入非上升/非下降子序列进行判断

#include <iostream>

using namespace std;

const int N=55;

int n,a[N],up[N],down[N],ans;  // up 和 down 数组不表示上升/下降序列，而是指炮台的种类

void dfs(int u,int su,int sd)  // u 表示存导弹高度的数组下标，su 表示所需上升炮台的数目，sd表示所需下降炮台的数目
{
    if(su+sd>=ans) return;
    //此处优化极为重要，因为 dfs 会很快搜到一组解，从而缩小 ans 的值，实现大量剪枝
    if(u==n){
        ans=su+sd;  //一旦搜到一组解就更新 ans
        return;
    }
    int k=0;						//放入非上升子序列
    while(k<su&&up[k]>=a[u]) k++;
    int t=up[k];
    up[k]=a[u];
    if(k<su) dfs(u+1,su,sd);//如果不需要添加炮台
    else dfs(u+1,su+1,sd);//如果需要添加炮台
    up[k]=t;//记得要还原
    
    k=0;							//放入非下降子序列
    while(k<sd&&down[k]<=a[u]) k++;
    t=down[k];
    down[k]=a[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)
    {
        ans=n;  //ans要初始化为 n
        for(int i=0;i<n;i++) cin>>a[i];
        dfs(0,0,0);
        cout<<ans<<endl;
    }
    return 0;
    
}

---

最长公共上升子序列

数据范围
1≤N≤3000,序列中的数字均不超过 231−1。

输入样例：
4
2 2 1 3
2 1 2 3
输出样例：
2

解法：此题为 最长上升子序列 与 最长公共子序列 的结合

优化版（O(n^2)）：

#include <iostream>

using namespace std;

const int N=3010;

int a[N],b[N],n,f[N][N];  // f[i, j] 表示 a 数组考虑到第 i 个，且以 b[j] 结尾的最长公共上升子序列

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) cin>>b[i];
    for(int i=1;i<=n;i++){
        int maxv=1;	 // maxv 用来存储 f[i][k](0<=k<=j-1)在 b[k]<b[j] 时的最大值
        for(int j=1;j<=n;j++)
        {
        	//不考虑 a[i] 的情况
            f[i][j]=f[i-1][j];	// f[i, j] 的状态转移分为 考虑 a[i] 和 不考虑 a[i] 
            
            //考虑 a[i] 的情况
            if(a[i]==b[j]) f[i][j]=max(f[i][j],maxv);
            else if(a[i]>b[j]) maxv=max(maxv,f[i][j]+1);
            //因为是公共上升序列，所以 maxv 用来存储 a[i]>b[j] 时候的 f[i][j] 来更新相等时的 f[i][j]
        }
    }
    int res=0;
    for(int i=1;i<=n;i++) res=max(res,f[n][i]);
    cout<<res<<endl;
    return 0;
}

*非优化代码（O(n^3)）：

#include <iostream>

using namespace std;

const int N=3010;

int a[N],b[N];
int n,f[N][N];

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++) cin>>b[i];
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            f[i][j]=f[i-1][j];
            if(a[i]==b[j])
            {
                f[i][j]=max(f[i][j],1);
                for(int k=1;k<j;k++)
                {
                    if(b[k]<b[j])
                        f[i][j]=max(f[i][k]+1,f[i][j]);
                }
            }
        }
    int res=0;
    for(int i=1;i<=n;i++) res=max(res,f[n][i]);
    cout<<res<<endl;
    return 0;
}