动态规划——最长上升子序列模型

        最长上升子序列模型类的题目，一般要求我们在一系列数中求出最长的上升或者下降（即反向的上升）子序列，一般时间复杂度为O(n^2)，进一步的可以利用二分+贪心维护最长的上升子序列，时间复杂度为O(nlogn)。

        朴素做法一般为两层循环，第一层枚举 i 从1到n，第二层枚举 j 从1到 i ，每次枚举比较当前点 i 是否比前面的某个点 j 大，如果是则根据状态转移方程f[i] = max(f[i], f[j] + 1)更新最长上升子序列的个数或者和(将+1改为+w[i])，最后得出答案

1016. 最大上升子序列和 - AcWing题库

一个数的序列 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)。

输入格式

输入的第一行是序列的长度N。

第二行给出序列中的N个整数，这些整数的取值范围都在0到10000(可能重复)。

输出格式

输出一个整数，表示最大上升子序列和。

数据范围

1≤N≤1000

输入样例：

7
1 7 3 5 9 4 8

输出样例：

18

思路：这题是最长上升子序列模型的典型题，只不过不需要我们给出子序列，只用给出他们的最大和即可，在满足条件的情况下，状态转移方程为f[i] = max(f[i], f[j] + w[i])，不断更新我们的res即可

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int w[N];
int f[N];

int main()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i ++ ) scanf("%d", &w[i]);
    int res = 0;
    
    for(int i = 0; i < n; i ++ )
    {
        f[i] = w[i];
        for(int j = 0; j < i; j ++ )
        {
            if(w[i] > w[j]) f[i] = max(f[i], f[j] + w[i]);
        }
        res = max(res, f[i]);
    }
    
    printf("%d\n", res);
    
    return 0;
}

1017. 怪盗基德的滑翔翼 - AcWing题库

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

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

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

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

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

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

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

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

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

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

输入格式

输入数据第一行是一个整数K，代表有K组测试数据。

每组测试数据包含两行：第一行是一个整数N，代表有N幢建筑。第二行包含N个不同的整数，每一个对应一幢建筑的高度h，按照建筑的排列顺序给出。

输出格式

对于每一组测试数据，输出一行，包含一个整数，代表怪盗基德最多可以经过的建筑数量。

数据范围

1≤K≤100,
1≤N≤100,
0<h<10000

输入样例：

3
8
300 207 155 299 298 170 158 65
8
65 158 170 298 299 155 207 300
10
2 1 3 4 5 6 7 8 9 10

输出样例：

6
6
9

思路：这题相当于是下降序列，改一下if条件即可，然后这题可以从某个点向另外两个方向降落，只要满足逐渐递减即可，所以我们正反枚举两轮，取最长的子序列长度即可。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 110;

int T;
int n, h[N], dp[N];

int main()
{
    scanf("%d", &T);
    while(T -- )
    {
        scanf("%d", &n);
        for(int i = 0; i < n; i ++ ) scanf("%d", &h[i]);
        int res = 0;
        //枚举正反两个方向
        for(int i = 0; i < n; i ++ )
        {
            dp[i] = 1;
            for(int j = 0; j < i; j ++ )
                if(h[i] < h[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            res = max(res, dp[i]);
        }
        memset(dp, 0, sizeof dp);
        for(int i = n - 1; i >= 0; i -- )
        {
            dp[i] = 1;
            for(int j = n - 1; j > i; j -- )
                if(h[i] < h[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            res = max(res, dp[i]);
        }
        printf("%d\n", res);
    }
    return 0; 
}

1010. 拦截导弹 - AcWing题库

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

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

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

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

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

输入格式

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

输出格式

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

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

数据范围

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

输入样例：

389 207 155 300 299 170 158 65

输出样例：

6
2

思路：这题要用到贪心的思路，我们不仅要求最长下降子序列，按常规套路计算即可，然后还要计算需要多少套系统才可以将所有的导弹拦截下，也就是要将所有值归类到尽可能少的几个子序列中，我们可以分两种情况讨论，1.如果现有子序列的结尾都小于当前数，则建立新的序列；2.将当前数放在结尾大于等于它的最小的子序列后面(保证尽可能充分使用当前子序列)。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int h[N], f[N], q[N];

int main()
{
    while (cin >> h[n]) n ++ ;
    
    int res = 0;
    for(int i = 0; i < n; i ++ )
    {
        f[i] = 1;
        for(int j = 0; j < i; j ++ )
            if(h[j] >= h[i])
                f[i] = max(f[i], f[j] + 1);
        res = max(res, f[i]);
    }
    
    int cnt = 0;
    for(int i = 0; i < n; i ++ )
    {
        int k = 0;
        while (k < cnt && h[i] > q[k]) k ++ ;
        if(k < cnt) q[k] = h[i];
        else q[cnt ++ ] = h[i];
    }
    
    cout << res << endl << cnt;
    
    return 0;
}

1014. 登山 - AcWing题库

482. 合唱队形 - AcWing题库

1012. 友好城市 - AcWing题库

187. 导弹防御系统 - AcWing题库

272. 最长公共上升子序列 - AcWing题库