算法竞赛备赛进阶之最大上升子序列训练

回顾前文的最大上升子序列问题

我们是采用了闫氏DP分析法

动态规划：

1. 状态表示f[i]

   1. 集合：所有以a[i]结尾的严格单调上升子序列

   2. 属性：Max/Min/数量

2. 状态计算

   1. 划分依据：最后一个不同的点

#include<iostream>
#include<algorithm>
​
using namespace std;
​
const int N = 1010;
​
int n;
int a[N], f[N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 1;i <= n; i++)
        scanf("%d", &a[i]);
    
    for(int i = 1;i <= n; i++)
    {
        f[i] = 1;
        for(int j = 1;j < i; j++)
            if(a[j] > a[i])
                f[i] = max(f[i], f[j] - 1);
    }
    
    int res = 0;
    for(int i = 1;i <= n; i++)
        res = max(res, f[i]);
    
    printf("%d\n", res);
    
    return 0;
}

贪心算法章节也有相应的解法

1.怪盗基德的滑翔翼

怪盗基德是一个充满传奇色彩的怪盗，专门以珠宝为目标的超级盗窃犯。

而他最为突出的地方，就是他每次都能逃脱中村警部的重重围堵，而这也很大程度上是多亏了他随身携带的便于操作的滑翔翼。

有一天，怪盗基德像往常一样偷走了一颗珍贵的钻石，不料却被柯南小朋友识破了伪装，而他的滑翔翼的动力装置也被柯南踢出的足球破坏了。

不得已，怪盗基德只能操作受损的滑翔翼逃脱。

假设城市中一共有N幢建筑排成一条线，每幢建筑的高度各不相同。

初始时，怪盗基德可以在任何一幢建筑的顶端。

他可以选择一个方向逃跑，但是不能中途改变方向（因为中森警部会在后面追击）。

因为滑翔翼动力装置受损，他只能往下滑行（即：只能从较高的建筑滑翔到较低的建筑）。

他希望尽可能多地经过不同建筑的顶部，这样可以减缓下降时的冲击力，减少受伤的可能性。

请问，他最多可以经过多少幢不同建筑的顶部(包含初始时的建筑)？

#include<iosream>
#include<algorithm>
​
using namespace std;
​
const int N = 1010;
​
int n;
int a[N], f[N];
​
int main()
{
    int T;
    scanf("%d", &T);
    
    while(T--)
    {
        scanf("%d", &n);
        for(int i = 1;i <= n; i++)
            scanf("%d", &a[i]);
        
        //正向求解LIS问题
        int res = 0;
        for(int i = 1;i <= n; i++)
            if(a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
        res = max(res, f[i]);
        
        //反向求解LIS问题
        for(int i = n; i; i--)
        {
            f[i] = 1;
            for(int j = n;j > i; j--)
                if(a[i] > a[j])
                    f[i] = max(f[i], f[j] + 1);
            
            res = max(res, f[i]);
        }
        
        printf("%d\n", res);
    }
    
    return 0;
}

2.登山

五一到了，ACM队组织大家去登山观光，队员们发现山上一个有N NN个景点，并给定各个景点的海拔，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。队员们希望在满足上面条件的同时，尽可能多的浏览景点，求最多可能浏览的景点数。

条件1：按照编号递增的顺序来浏览 => 必须是子序列

条件2：相邻两个经典不相等

条件3：一旦开始下降，就不能上升了

目标：求最多能浏览多少景点

目标：所有形状是上面这种的子序列长度的最大值

目标求出第k类最大的长度

#include<iostream>
#include<algorithm>
​
using namespace std;
​
const int N = 1010;
​
int n;
int a[N];
int f[N], g[N];
​
int main()
{
    scanf("%d", &n);
    
    for(int i = i;i <= n; i++)
        scanf("%d", &a[i]);
    
    for(int i = 1;i <= n; i++)
    {
        f[i] = 1;
        for(int j = 1;j <= i; j++)
            if(a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
    }
    
    for(int i = n; i; i--)
    {
        g[i] = 1;
        for(int j = n;j > i; j--)
            if(a[i] > a[j])
                g[i] = max(g[i], g[j] + 1);
    }
    
    int res = 0;
    for(int i = 1;i <= n; i++)
        res = max(res, f[i] + g[i] - 1);
    
    printf("%d\n", res);
    
    return 0;
}

3.合唱队形

N 位同学站成一排，音乐老师要请其中的 (N−K) 位同学出列，使得剩下的 K 位同学排成合唱队形。     

合唱队形是指这样的一种队形：设 KK 位同学从左到右依次编号为 1，2…，K，他们的身高分别为 T1，T2，…，TK，则他们的身高满足 T1<…< Ti >Ti+1>…>TK(1≤i≤K)。  

你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

#include<iostream>
#include<algorithm>
​
using namespace std;
​
const int N = 110;
​
int n;
int a[N];
int f[N], g[N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 1;i <= n; i++)
        scanf("%d", &a[i]);
    
    for(int i = 1;i <= n; i++)
    {
        f[i] = 1;
        for(int j = 1;j <= i; j++)
            if(a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
    }
    
    for(int i = n; i; i--)
    {
        g[i] = 1;
        for(int j = n;j > i; j--)
            if(a[i] > a[j])
                g[i] = max(g[i], g[j] + 1);
    }
    
    int res = 0;
    for(int i = 1;i <= n; i++)
        res = max(res, f[i] + g[i] - 1);
    
    printf("%d\n", n - res);
    return 0;
}

4.友好城市

Pmia国有一条横贯东西的大河，河有笔直的南北两岸，岸上各有位置各不相同的N个城市。

北岸的每个城市有且仅有一个友好城市在南岸，而目不同城市的友好城市不相同。

每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市，但是由于河上雾太大，政府决定避免任意两条航道交叉，以避免事故。

编程帮助政府做出一些批准和拒绝申请的决定，使得在保证任意两条航线不相交的情况下，被批准的申请尽量多。

条件1：每个城市上只能建立一座桥

条件2：所有的桥与桥之间不能相交

#include<iostream>
#include<algorithm>
​
using namespace std;
​
typedef pair<int, int> PII;
​
const int N = 5010;
​
int n;
PII q[N];
int f[N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 0;i < n; i++)
        scanf("%d%d", &q[i].first, &q[i].second);
    
    sort(q, q + n);
    
    int res = 0;
    for(int i = 0;i < n; i++)
    {
        f[i] = 1;
        for(int j = 0;j < i; j++)
            if(q[i].second > q[j].second)
                f[i] = max(f[i], f[j] + 1);
        
        res = max(res, f[i] + 1);
    }
    
    printf("%d\n", res);
    
    return 0;
}

5.最大上升子序列和

一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ...,aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中序列和最大为18，为子序列(1, 3, 5, 9)的和. 你的任务，就是对于给定的序列，求出最大上升子序列和。注意，最长的上升子序列的和不一定是最大的，比如序列(100, 1, 2, 3)的最大上升子序列和为100，而最长上升子序列为(1, 2, 3)

#include<ioatream>
#include<algorithm>
​
using namespace std;
​
const int N = 1010;
​
int n;
int a[N], f[N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 1;i <= n; i++) scanf("%d", &a[i]);
    
    for(int i = 1;i <= n; i++)
    {
        f[i] = 1;
        for(int j = 1;j < i; j++)
            if(a[i] > a[j])
                f[i] = max(f[i], f[j] + a[i]);
    }
    
    int res = 0;
    for(int i = 1;i <= n; i++) res = max(res, f[i]);
    
    printf("%d\n", &res);
    return 0;
}

6.拦截导弹

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

选择1：接在现有的某个子序列之后

选择2：创建一个新系统

贪心流程：从前往后扫描每个数，对于每个数

情况1：如果现有的子序列的结尾都小于当前的数，则创建新子序列

情况2：将当前数放到结尾大于等于它的最小子序列后面

如何证明两个数相等：A≤B B≤A

A表示贪心算法得到的序列个数；B表示最优解；B≤A，A≤B，调整法

假设最优解对应的方案和当前方案不同

找到第一个不同的数。贪心法和最优解

389 207 155 300 299 170 158 65

#include<iostream>
#include<algorithm>
​
using namespace std;
​
const int N = 1010;
​
int n;
int q[N];
int f[N], g[N];
​
int main()
{
    while(cin >> q[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])
                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;
        while(k < cnt && g[k] < q[i]) k++;
        g[k] = q[i];
        if(k >= cnt) cnt++;
    }
    
    cout << cnt << endl;
    
    return 0;
}

7.导弹防御系统

为了对抗附近恶意国家的威胁，RR 国更新了他们的导弹防御系统。

一套防御系统的导弹拦截高度要么一直 严格单调 上升要么一直 严格单调 下降。

例如，一套系统先后拦截了高度为 3 和高度为 4 的两发导弹，那么接下来该系统就只能拦截高度大于 4 的导弹。

给定即将袭来的一系列导弹的高度，请你求出至少需要多少套防御系统，就可以将它们全部击落。

#include<iostream>
using namespace std;
​
using namespace std;
​
const int N = 55;
​
int n;
int q[N];
int up[N], down[N];
int ans;
​
void dfs(int u, int su, int sd)
{
    if(su + sd >= ans) return;
    if(u == n)
    {
        ans = su + sd;
        return;
    }
    
    //情况1：将当前数放到上升序列中
    int k = 0;
    while(k < su && up[k] >= q[u]) k++;
    int t = up[k];
    up[k] = q[u];
    if(k < su) dfs(u + 1, su, sd);
    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;
    }
}

8.最长公共子序列

熊大妈的奶牛在小沐沐的熏陶下开始研究信息题目。

小沐沐先让奶牛研究了最长上升子序列，再让他们研究了最长公共子序列，现在又让他们研究最长公共上升子序列了。

小沐沐说，对于两个数列 A 和 B，如果它们都包含一段位置不一定连续的数，且数值是严格递增的，那么称这一段数是两个数列的公共上升子序列，而所有的公共上升子序列中最长的就是最长公共上升子序列了。

奶牛半懂不懂，小沐沐要你来告诉奶牛什么是最长公共上升子序列。

不过，只要告诉奶牛它的长度就可以了。

数列 A 和 B 的长度均不超过 3000。

#include<iostream>
#include<algorithm>
​
using namespace std;
​
const int N = 3010;
​
int n;
int a[N], b[N];
int g[N][N];
int f[N][N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 1;i <= n; i++) scanf("%d", &a[i]);
    for(int i = 1;i <= n; i++) scanf("%d", &b[i]);
    
    for(int i = 1;i <= n; i++)
    {
        g[i][0] = 1;
        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], g[i][j - 1]);
            g[i][j] = g[i][j - 1];
            if(b[j] < a[i]) g[i][j] = max(g[i][j], f[i][j] + 1);
        }
    }
    
    int res = 0;
    for(int i = 1;i <= n; i++) res = max(res, f[n][i]);
    
    printf("%d\n", res);
    
    return 0;
}

改进：

#include<iostream>
#include<algorithm>
using namespace std;
​
const int N = 3010;
​
int n;
int a[N], b[N];
int f[N][N];
​
int main()
{
    scanf("%d", &n);
    for(int i = 1;i <= n; i++)
        scanf("%d", &a[i]);
        
    for(int i = 1;i <= n; i++)
        scanf("%d", &b[i]);
        
    for(int i = 1;i <= n; i++)
    {
        int maxv = 1;
        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], maxv);
            if(b[j] < a[i]) maxv = max(maxv, f[i - 1][j] + 1);
        }
    }
        
    int res = 0;
    
    for(int j = 1;j <= n; j++)
        res = max(res, f[n][j]);
        
    printf("%d\n", res);
    return 0;
}