笔记---dp---最长上升子序列模型

模型原始题目：AcWing.895.最长上升子序列

题目关系如下：

转化一

AcWing.1017.怪盗基德的滑翔翼

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

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

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

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

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

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

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

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

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

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

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

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

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

数据范围
$1\le K\le 100,$
$1\le N\le 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

也就是说，挑一个楼和一个方向，一旦开始就要沿着这个方向从高的楼向低的楼去，比如说开始的楼的高度为$a[i]$，那么这就是一个求以$a[i]$结尾的最长上升子序列的问题，也就是说要找到所有选法中的最长上升子序列

代码：

#include<iostream>
using namespace std;
const int N = 110;

int f[N];
int a[N];

int main(){
    int t;cin >> t;
    while(t--){
        int n;cin >> n;
        for(int i = 1;i <= n;i++)cin >> a[i];
        
        int res = 0;
        
        //左右分别求最长上升子序列就可以
        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);
                    //如果res在这里取最大值会导致n=1的情况出错
                }
            }
            res = max(res,f[i]);			//每一步res取一下最大值
        }
        
        for(int i = n;i >= 1;i--){
            f[i] = 1;
            for(int j = n;j > i;j--){
                if(a[j] < a[i]){
                    f[i] = max(f[i],f[j]+1);
                }
            }
            res = max(res,f[i]);
        }
        
        cout << res << endl;
    }
    return 0;
}

AcWing.1014.登山

五一到了，ACM队组织大家去登山观光，队员们发现山上一共有$N$个景点，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。

同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。

队员们希望在满足上面条件的同时，尽可能多的浏览景点，你能帮他们找出最多可能浏览的景点数么？

输入格式
第一行包含整数$N$，表示景点数量。
第二行包含$N$个整数，表示每个景点的海拔。

输出格式
输出一个整数，表示最多能浏览的景点数。

数据范围
$2\le N\le 1000$

输入样例：

8
186 186 150 200 160 130 197 220

输出样例：

4

这道题提出了以下几个条件：
1.必须按照从前往后的顺序来
2.不能去任何与当前海拔相同的景点
3.当选择了海拔比当前低的景点时，之后就不能再选择海拔上升的景点

其中第1个条件说明了：要求的一定是个子序列
第3个条件说明了：一定是一个单调上升后单调下降的子序列

则我们要求的就是先单调上升后单调下降的最长子序列
以拐点来划分，划分为以下情况：$a[1]$为拐点，$a[2]$为拐点，…$a[n]$为拐点

则讨论拐点为$a[k]$时，那么这时候的最大长度为左边最长上升子序列的长度加上右边最长下降子序列的长度-1
则可以先正着求一次最长上升子序列，再倒着求一次，然后枚举中间的点来计算答案最大值。

代码：

#include<iostream>
using namespace std;

const int N = 1010;

int f[N];	//f[]存最长上升子序列
int g[N];	//g[]存最长下降子序列
int a[N];

int main(){
    int n;cin >>n;
    for(int i = 1;i <= n;i++)cin >>a[i];
    
    int res = 0;	//答案
    
    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);
        }
    }
    
    for(int i = n;i >= 1;i--){			//然后倒着枚举求最长下降子序列
        g[i] = 1;
        for(int j = n;j > i;j--){
            if(a[j] <a[i])g[i] = max(g[i],g[j]+1);
        }
    }
    
    for(int i = 1;i <= n;i++)res = max(res,f[i] + g[i] - 1);
    
    cout <<res;
    
    return 0;
}

AcWing.482.合唱队形

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

合唱队形是指这样的一种队形：设 $K$ 位同学从左到右依次编号为 $1，2\dots ，K，$他们的身高分别为 $T_1，T_2，\dots ，T_K$，则他们的身高满足 $T_1<\dots <T_i>T_{i+1}>\dots >T_K(1\le i\le K)$。

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

输入格式
输入的第一行是一个整数 $N$，表示同学的总数。
第二行有 $N$ 个整数，用空格分隔，第 $i$ 个整数 $T_i$ 是第 $i$ 位同学的身高(厘米)。

输出格式
输出包括一行，这一行只包含一个整数，就是最少需要几位同学出列。

数据范围
$2\le N\le 100,$
$130\le T_i\le 230$

输入样例：

8
186 186 150 200 160 130 197 220

输出样例：

4

此题要求求最少需要几位同学出列，意思便是要求最多能留下多少同学，而能留下的最多的同学即满足先上升后下降的序列的最长长度，如此来看，此题和登山十分相似，只需要求出最长的先上升后下降的子序列之后，用全部人数减去子序列长度就可以得到答案了

转化二

AcWing,1012.友好城市

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

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

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

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

输入格式
第1行，一个整数$N$，表示城市数。
第2行到第$n+1$行，每行两个整数，中间用1个空格隔开，分别表示南岸和北岸的一对友好城市的坐标。

输出格式
仅一行，输出一个整数，表示政府所能批准的最多申请数。

数据范围
$1\le N\le 5000,$
$0\le x_i\le 10000$

输入样例：

7
22 4
2 6
10 3
15 12
9 8
17 17
4 2

输出样例：

4

详细讲解：AcWing算法提高课最长上升子序列模型（一) 01:20:00

要求每两个友好城市之间建桥，所有的桥和桥之间不能相交。

那么每两个友好城市就对应了一条线，我们需要选择尽可能多的线并且不让他们相交
如果所有的桥是不相交的，也就是合法的进行建桥，那么建桥的点，比如南岸对应连接的北岸一定是递增的

只要满足南岸的点大于前一个建桥点，南岸的点对应的北岸的点大于前一个建桥点，就可以在这里建桥。
那么只需要先把南岸的点和北岸的点绑定，然后将北岸的点进行排序，之后再求南岸的点的最长上升子序列就可以了。
这样我们就能够求出两边同时上升的子序列。

当然排序南岸或者北岸都可以。

代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 5010;

#define pii pair<int,int>

int n;
pii q[N];
int f[N];

int main() {
	cin >> n;
	for (int i = 0; i < n; i++)cin >> q[i].first >> q[i].second;

	//sort对pair类型默认对first元素升序排序，当first相同时对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]);
	}
	
	cout << res;
	return 0;
}

转化三

AcWing.1016.最大上升子序列和

一个数的序列 $b_i$，当 $b_1<b_2<\dots <b_S$ 的时候，我们称这个序列是上升的。

对于给定的一个序列$(a_1,a_2,\dots ,a_N)$，我们可以得到一些上升的子序列$(a_{i1},a_{i2},\dots ,a_{iK})$，这里$1\le i_1<i_2<\dots <i_K\le 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\le N\le 1000$

输入样例：

7
1 7 3 5 9 4 8

输出样例：

18

这题求的是和最大的上升子序列，那么就用$f[i]$来表示以$a[i]$结尾的数值最大的上升子序列。

每次状态转移为$f[i]=max(f[i]，f[j]+a[i])$ ，因为是算数值，就要加上每个$a[i]$值，然后每次判断$a[j]$是否小于$a[i]$。

代码：

#include<iostream>
using namespace std;
const int N = 1010;

int f[N];
int a[N];

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

转化四

AcWing.1010.拦截导弹

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

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

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

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

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

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

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

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

输入样例：

389 207 155 300 299 170 158 65

输出样例：

6
2

此题的第一问就是一道裸的最长上升子序列问题，而第二问则是一道贪心题目。

对于第二问可以先枚举每个数，对于每个数，如果所有的子序列的结尾的数字都小于当前这个数的时候，就创建一个新的子序列，如果有子序列的结尾的数字大于当前这个数，就把这个数放到大于等于它的结尾最小的子序列后面

#include<iostream>
using namespace std;

const int N = 1010;

int n;
int a[N];
int f[N], g[N];	//g[i]表示当前现有的第i个子序列的结尾高度

int main() {
	while (cin >> a[n])n++;

	int res = 0;
	for (int i = 0; i < n; i++) {			//第一问
		f[i] = 1;
		for (int j = 0; j < i; j++) {
			if (a[j] >= a[i]) {
				f[i] = max(f[i], f[j] + 1);
			}
		}
		res = max(res, f[i]);
	}
	cout << res << endl;

	int cnt = 0;		//cnt表示子序列个数
	for (int i = 0; i < n; i++) {	
		int k = 0;
		while (k < cnt && g[k] < a[i])k++; //找到第一个结尾比a[i]大的子序列
		g[k] = a[i];			//把当前这个子序列的结尾更新成当前这个最小的数
		if (k >= cnt)cnt++;		//如果k>=cnt，也就是说找到的子序列比当前的子序列多，那么cnt就要++
	}
	cout << cnt;

	return 0;
}

AcWing.187.导弹防御系统

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

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

例如，一套系统先后拦截了高度为 $3$ 和高度为 $4$ 的两发导弹，那么接下来该系统就只能拦截高度大于 $4$ 的导弹。
给定即将袭来的一系列导弹的高度，请你求出至少需要多少套防御系统，就可以将它们全部击落。

输入格式
输入包含多组测试用例。

对于每个测试用例，第一行包含整数 $n$，表示来袭导弹数量。

第二行包含 $n$ 个不同的整数，表示每个导弹的高度。

当输入测试用例 $n=0$ 时，表示输入终止，且该用例无需处理。

输出格式
对于每个测试用例，输出一个占据一行的整数，表示所需的防御系统数量。

数据范围
$1\le n\le 50$

输入样例：

5
3 5 2 4 1
0 

输出样例：

2

样例解释
对于给出样例，最少需要两套防御系统。

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

因为有两种情况，直接暴搜
代码：

#include<iostream>
using namespace std;
const int N = 55;

int n;
int ans;
int q[N];
int up[N], down[N];

void dfs(int u, int su, int sd) {	//第一个参数表示当前枚举到第几个数，第二个表示当前上升子序列个数，第三个当前下降子序列的个数
	if (su + sd >= ans)return;	//剪枝：如果两种子序列加起来已经超过了ans,就直接不用管了（因为要求最小值)

	if (u == n) {		//找到了一个方案
		ans = su + sd;	//更新答案为上升＋下降
		return;
	}

	//枚举放到上升子序列中的情况
	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);	//如果k没有超过su，就不用多一个子序列
	else dfs(u + 1, su + 1, sd);	//如果超过了，就要开一个新的子序列
	up[k] = t;		//回溯

	//枚举放到下降子序列中的情况
	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;
}

转化五

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

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

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

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

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

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

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

输入格式
第一行包含一个整数 $N$，表示数列 $A，B$ 的长度。

第二行包含 $N$ 个整数，表示数列 $A$。

第三行包含 $N$ 个整数，表示数列 $B$。

输出格式
输出一个整数，表示最长公共上升子序列的长度。

数据范围
$1\le N\le 3000$,序列中的数字均不超过 $2^{31}-1$。

输入样例：

4
2 2 1 3
2 1 2 3

输出样例：

2

最长公共子序列

这道题用$f[i][j]$表示：以第一个序列的前$i$个数字，第二个序列的前$j$个数字组成，并且以$b[j]$结尾的最长公共上升子序列

将集合划分为包含$a[i]$的最长公共上升子序列和不包含$a[i]$的最长公共上升子序列

然后再进一步把包含a[i]的最长公共上升子序列划分：
为倒数第二个数为$空$，倒数第二个数为$b[1]$，倒数第二个数为$b[2]$，…倒数第二个数为$b[j-1]$

然后就可以分析状态：假如我们现在选的是倒数第二个数为$b[1]$，那么在b序列中选择的就是$b[1]$，$b[j]$两个数，所以状态就是$f[i-1][1]+1$，意思是先是到了$b[1]$然后再加上$b[j]$这一个数，对于$b[k]$，就是$f[i-1][k]+1$，对于$空$的情况，就是$1$

而对于不包含a[i]的最长公共上升子序列的情况，状态转移只为$f[i][j]=f[i-1][j]$。

然后，要满足包含$a[i]$，意思就是要满足$a[i]==b[j]$。

暴力写法：

#include<iostream>
using namespace std;
const int N = 3010;

int n;
int a[N], b[N];
int 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]) {					//如果满足第一个情况的条件
				
				if (!f[i][j])f[i][j] = 1;		//如果是空的情况，就赋值为1

				for (int k = 1; k < j; k++) {	//细分第一种情况
					if (b[k] < b[j]) {	
						f[i][j] = max(f[i][j], f[i - 1][k] + 1);//状态转移
					}
				}
			}
		}
	}
	int res = 0;
	for (int i = 1; i <= n; i++)res = max(res, f[n][i]);//取最大值

	cout << res;
	return 0;
}

优化：

首先，在a[i] == b[j]的过程中，a[i]和b[j]都是相等的，所以可以直接把

for (int k = 1; k < j; k++) {	//细分第一种情况
					if (b[k] < b[j]) {	
						f[i][j] = max(f[i][j], f[i - 1][k] + 1);//状态转移
					}
}

中的$b[j]$换成$a[i]$，那么现在这一循环所求的值就变为了，在$1$到$j-1$之间找到一个满足$b[k]$小于$a[i]$的$f[i-1][k]$的最大值，那么我们就可以直接删掉这一层循环，然后用一个变量来求$1j-1$之间的$f[i-1][k]$的最大值

#include<iostream>
using namespace std;
const int N = 3010;

int n;
int a[N], b[N];
int 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++) {				//枚举第一个序列

		int Max = 1;	//Max表示1到j-1中的满足b[k] < a[i]的f[i-1][k]的最大值

		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], Max);

			if (b[j] < a[i])Max = max(Max, f[i - 1][j] + 1);
		}
	}
	int res = 0;
	for (int i = 1; i <= n; i++)res = max(res, f[n][i]);//取最大值

	cout << res;
	return 0;
}