题谱
题目一 最长上升子序列
给定一个长度为 N 的数列,求数值严格单调递增的子序列的长度最长是多少。
输入格式
第一行包含整数 N。
第二行包含 N 个整数,表示完整序列。
输出格式
输出一个整数,表示最大长度。
数据范围
1≤N≤1000,
−109≤数列中的数≤109
输入样例:
7
3 1 2 1 8 5 6
输出样例:
4
分析:
dp问题
所以f[i]的值应该是他们当中的最大值
当然,这些集合中可能有很多不满足条件的集合,这些我们不算做max内
需要判定一下
注意:有空的存在,所以初始值应该为1
代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1010;
int a[N],f[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]=1;//空集
for(int j=1;j<=i-1;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]);
cout<<res<<endl;
return 0;
}
题目二 怪盗基德的滑翔翼
怪盗基德是一个充满传奇色彩的怪盗,专门以珠宝为目标的超级盗窃犯。
而他最为突出的地方,就是他每次都能逃脱中村警部的重重围堵,而这也很大程度上是多亏了他随身携带的便于操作的滑翔翼。
有一天,怪盗基德像往常一样偷走了一颗珍贵的钻石,不料却被柯南小朋友识破了伪装,而他的滑翔翼的动力装置也被柯南踢出的足球破坏了。
不得已,怪盗基德只能操作受损的滑翔翼逃脱。
假设城市中一共有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
分析:
条件1:只能从高的建筑物走向低的建筑物
条件2:选择一个方向,不能折返
经过分析,我们可以选定一个顶点,分别计算此顶点向左走的最大建筑物和向右走的最大建筑物
所以需要进行两次正反的LIS
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=110;
int a[N],f[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=max(res,f[i]);
}
//memset(f, 0, sizeof f);
//相当于只看右半部分
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;
}
题目三 登山
五一到了,ACM队组织大家去登山观光,队员们发现山上一共有N个景点,并且决定按照顺序来浏览这些景点,即每次所浏览景点的编号都要大于前一个浏览景点的编号。
同时队员们还有另一个登山习惯,就是不连续浏览海拔相同的两个景点,并且一旦开始下山,就不再向上走了。
队员们希望在满足上面条件的同时,尽可能多的浏览景点,你能帮他们找出最多可能浏览的景点数么?
输入格式
第一行包含整数N,表示景点数量。
第二行包含N个整数,表示每个景点的海拔。
输出格式
输出一个整数,表示最多能浏览的景点数。
数据范围
2≤N≤1000
输入样例:
8
186 186 150 200 160 130 197 220
输出样例:
4
分析:
条件1:邻接相同海拔的建筑物不能都游览
条件2:一旦下山不能再上山
相当于我们要求一个先递增再递减的序列
我们可以选定一个顶点,先求他一一边的递增序列,在求其另一边递减序列
最终相加即是我们要求的总和
注意:最终要减1,因为我们把起点加了两遍
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1010;
int a[N];
int f[N];
int s[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]=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>=1;i--)
{
s[i]=1;
for(int j=n;j>=i;j--)
if(a[i]>a[j]) s[i]=max(s[i],s[j]+1);
}
int res=0;
for(int i=1;i<=n;i++) res=max(f[i]+s[i]-1,res);
cout<<res<<endl;
return 0;
}
题目四 合唱队形
N位同学站成一排,音乐老师要请其中的 (N−K)位同学出列,使得剩下的 K位同学排成合唱队形。
合唱队形是指这样的一种队形:设 K位同学从左到右依次编号为 1,2…,K他们的身高分别为 T1,T2,…,TK 则他们的身高满足 T1<…<Ti>Ti+1>…>TK(1≤i≤K)
你的任务是,已知所有 N 位同学的身高,计算最少需要几位同学出列,可以使得剩下的同学排成合唱队形。
输入格式
输入的第一行是一个整数 N,表示同学的总数。
第二行有 N 个整数,用空格分隔,第 i 个整数 Ti 是第 i 位同学的身高(厘米)。
输出格式
输出包括一行,这一行只包含一个整数,就是最少需要几位同学出列。
数据范围
2≤N≤100
130≤Ti≤230
输入样例:
8
186 186 150 200 160 130 197 220
输出样例:
4
分析:
和登山问题一样,但是要输出最小的
所以只需要改成n-res即可
代码:
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N=110;
int a[N];
int f[N];
int s[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]=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>=1;i--)
{
s[i]=1;
for(int j=n;j>=i;j--)
{
if(a[i]>a[j]) s[i]=max(s[i],s[j]+1);
}
}
int res=0;
for(int i=1;i<=n;i++) res=max(f[i]+s[i]-1,res);
cout<<n-res<<endl;
return 0;
}
题目五 友好城市
Palmia国有一条横贯东西的大河,河有笔直的南北两岸,岸上各有位置各不相同的N个城市。
北岸的每个城市有且仅有一个友好城市在南岸,而且不同城市的友好城市不相同。
每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市,但是由于河上雾太大,政府决定避免任意两条航道交叉,以避免事故。
编程帮助政府做出一些批准和拒绝申请的决定,使得在保证任意两条航线不相交的情况下,被批准的申请尽量多。
输入格式
第1行,一个整数N,表示城市数。
第2行到第n+1行,每行两个整数,中间用1个空格隔开,分别表示南岸和北岸的一对友好城市的坐标。
输出格式
仅一行,输出一个整数,表示政府所能批准的最多申请数。
数据范围
1≤N≤5000
0≤xi≤10000
输入样例:
7
22 4
2 6
10 3
15 12
9 8
17 17
4 2
输出样例:
4
分析:
条件1:每个城市只能建一座桥
条件2:桥之间不能交叉
本题和最长上升子序列的关系
如果我们选择了为一些递增城市序列建桥之后,只有他对应的友好城市序列也递增
才能够满足不交叉的条件
所以我们需要将城市排序后,求它的最大上升子序列即可
数据结构pair
代码:
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int,int> PII;
const int N=5010;
PII a[N];
int f[N];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i].first>>a[i].second;
sort(a+1,a+n+1);
int res=0;
for(int i=1;i<=n;i++)
{
f[i]=1;
for(int j=1;j<=i;j++)
if(a[i].second>a[j].second)
f[i]=max(f[i],f[j]+1);
res=max(f[i],res);
}
cout<<res<<endl;
return 0;
}
题目六 最大上升子序列的和
一个数的序列 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]
状态表示:以a[ i ]结尾的最大上升子序列的和
状态计算:同样以倒数第二个节点进行划分,如果最后一个节点是 f[k] ,那么f[i]=max(f[i],f[k]+a[i])
当然初始化时,要注意f[i]=a[i]
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1010;
int a[N];
int f[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=0;
for(int i=1;i<=n;i++) res=max(res,f[i]);
cout<<res<<endl;
return 0;
}
题目七 拦截导弹
某国为了防御敌国的导弹袭击,发展出一种导弹拦截系统。
但是这种导弹拦截系统有一个缺陷:虽然它的第一发炮弹能够到达任意的高度,但是以后每一发炮弹都不能高于前一发的高度。
某天,雷达捕捉到敌国的导弹来袭。
由于该系统还在试用阶段,所以只有一套系统,因此有可能不能拦截所有的导弹。
输入导弹依次飞来的高度(雷达给出的高度数据是不大于30000的正整数,导弹数不超过1000),计算这套系统最多能拦截多少导弹,如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
输入格式
共一行,输入导弹依次飞来的高度。
输出格式
第一行包含一个整数,表示最多能拦截的导弹数。
第二行包含一个整数,表示要拦截所有导弹最少要配备的系统数。
数据范围
雷达给出的高度数据是不大于 30000的正整数,导弹数不超过 1000。
输入样例:
389 207 155 300 299 170 158 65
输出样例:
6
2
分析:
第一问和上述题目都一样,是LIS问题
关键看第二问,实际上第二问是在求至少用多少个非递增的序列能够覆盖整个序列
我们可以利用贪心的思想
遍历每个元素,它有两种选择,
1.加到已有的序列中去
2.重新构建一个序列
如果有两个长度为1的数组,它的最后一个值分别是1和3
显然如果某个元素能加入最后1个值是3的序列那么它一定能加入最后一个元素是1的序列
所以我们只需要记录长度为i的序列最后一个值最小的即可
并且,很容易得到,如果一个序列长度越长,它的最后一个元素值越大
做法:开辟一个数组q[i],用来记录长度为i的数组的最后一个元素最小值
遍历每个元素,比较出大于它的最小值,把它加入序列
若没有比它大的序列,那么开辟一个新序列,cnt++
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1010;
int w[N];
int n;
int q[N];
int f[N];
int main()
{
while(cin>>w[n]) n++;
int res=0;
for(int i=0;i<n;i++)
{
f[i]=1;
for(int j=0;j<i;j++)
if(w[j]>=w[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++)
{
//二分找出>=a[i]的最小值,找到则加到那个序列上去,找不到新开辟一个数列
int l=0,r=cnt;
while(l<r)
{
int mid=l+r>>1;
if(q[mid]>=w[i]) r=mid;
else l=mid+1;
}
if(q[r]<w[i]) r++;
cnt=max(cnt,r);
q[r]=w[i];
}
cout<<cnt<<endl;
return 0;
}
题目八 导弹防御系统
为了对抗附近恶意国家的威胁,R国更新了他们的导弹防御系统。
一套防御系统的导弹拦截高度要么一直 严格单调 上升要么一直 严格单调 下降。
例如,一套系统先后拦截了高度为 3 和高度为 4 的两发导弹,那么接下来该系统就只能拦截高度大于 4 的导弹。
给定即将袭来的一系列导弹的高度,请你求出至少需要多少套防御系统,就可以将它们全部击落。
输入格式
输入包含多组测试用例。
对于每个测试用例,第一行包含整数 n,表示来袭导弹数量。
第二行包含 n 个不同的整数,表示每个导弹的高度。
当输入测试用例 n=0 时,表示输入终止,且该用例无需处理。
输出格式
对于每个测试用例,输出一个占据一行的整数,表示所需的防御系统数量。
数据范围
1≤n≤50
输入样例:
5
3 5 2 4 1
0
输出样例:
2
样例解释
对于给出样例,最少需要两套防御系统。
一套击落高度为 3,4的导弹,另一套击落高度为 5,2,1 的导弹。
分析:
本题与上述题类似,不同点是可以选择两种不同的序列进行排列
如何选更好?
只能全部遍历一遍使用dfs(一种定义全局变量,一种迭代加深(暂且不会))
定义ans=n全局变量
考虑用三个变量 u 此时的节点数,su,上升序列的长度, sd,下降序列的长度
首先考虑边界情况,如果su+sd大于ans,剪枝
如果u==n 那么得到答案
接下来分情况讨论,分别把该节点放入上升序列和下降队列
注意备份和恢复现场
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=55;
int n;
int a[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;
}
//分两种情况
//把此节点分到上升序列中
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)
{
for(int i=0;i<n;i++) cin>>a[i];
ans=n;
dfs(0,0,0);
cout<<ans<<endl;
}
return 0;
}
小tips:
不知道到底有多少数据,以0结束
可以while(cin>>n,n)
题目九 最长公共子序列
给定两个长度分别为 N 和 M 的字符串 A和 B,求既是 A 的子序列又是 B 的子序列的字符串长度最长是多少。
输入格式
第一行包含两个整数 N 和 M。
第二行包含一个长度为 N 的字符串,表示字符串 A。
第三行包含一个长度为 M 的字符串,表示字符串 B。
字符串均由小写字母构成。
输出格式
输出一个整数,表示最大长度。
数据范围
1≤N,M≤1000
输入样例:
4 5
acbd
abedc
输出样例:
3
分析:
用f[i][j]来存a[1-i]和b[1-j]公共序列的集合
f[i][j]可能不包含a[i],可能不包含b[j],可能都不包含,可能都包含
都包含显然是在相等的情况下,f[i][j]=max(f[i][j],f[i-1][j-1]+1)
不包含a[i]或不包含b[j]的情况,f[i][j]=max(f[i-1][j],f[i][j-1]);
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=1010;
int f[N][N];
char a[N];
char b[N];
int n,m;
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++) cin>>a[i];
for(int i=1;i<=m;i++) cin>>b[i];
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
f[i][j]=max(f[i-1][j],f[i][j-1]);
if(a[i]==b[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);
}
}
cout<<f[n][m]<<endl;
}
题目十 最长公共上升子序列
熊大妈的奶牛在小沐沐的熏陶下开始研究信息题目。
小沐沐先让奶牛研究了最长上升子序列,再让他们研究了最长公共子序列,现在又让他们研究最长公共上升子序列了。
小沐沐说,对于两个数列 A 和 B,如果它们都包含一段位置不一定连续的数,且数值是严格递增的,那么称这一段数是两个数列的公共上升子序列,而所有的公共上升子序列中最长的就是最长公共上升子序列了。
奶牛半懂不懂,小沐沐要你来告诉奶牛什么是最长公共上升子序列。
不过,只要告诉奶牛它的长度就可以了。
数列 A和 B的长度均不超过 3000。
输入格式
第一行包含一个整数 N,表示数列 A,B 的长度。
第二行包含 N 个整数,表示数列 A。
第三行包含 N 个整数,表示数列 B。
输出格式
输出一个整数,表示最长公共上升子序列的长度。
数据范围
1≤N≤3000,序列中的数字均不超过 231−1。
输入样例:
4
2 2 1 3
2 1 2 3
输出样例:
2
分析:
本题是LIS和LCS问题的结合
所以我们的状态表示需要修改一下
同时状态计算时要分两大部分
一部分不包含a[i] f[i][j]=f[i-1][j]
另一部分包含a[i] (即此时a[i]=b[j]) 我们已知最后一个点一定是b[j],需要枚举倒数第二个点是什么
这样看来,是三重循环
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=3010;
int a[N];
int b[N];
int f[N][N];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
for(int j=1;j<=n;j++) cin>>b[j];
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][j],f[i][k]+1);
}
}
int res=0;
for(int i=1;i<=n;i++) res=max(f[n][i],res);
cout<<res<<endl;
return 0;
}
但是本题的数据范围是3000,三重循环会TLE
那么要进行简化
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][j],f[i][k]+1);
}
在此段代码中由于a[i]==b[j]的情况下才需要进行循环,所以我们可以用a[i]替代b[j]
本段代码含义实则是求
所有满足小于a[i]条件下的b[j]对应的f[i-1,j]的最大值
我们算b[j+1]对应的f[i-1,j+1]时把前面所有的值都重新算了一遍,带来了许多冗余的操作
所以可以提到外面进行优化
使用maxv来表示所有满足小于a[i]条件下的b[j]对应的f[i-1,j]的最大值
代码:
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=3010;
int a[N],b[N];
int f[N][N];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
for(int j=1;j<=n;j++) cin>>b[j];
for(int i=1;i<=n;i++)
{
int maxv=1;
for(int j=1;j<=n;j++)
{
f[i][j]=max(f[i-1][j],maxv);
if(a[i]==b[j])
{
f[i][j]=max(f[i][j],1);
for(int k=1;k<j;k++)
if(b[k]<a[i]) f[i][j]=max(f[i][j],f[k][j]+1);
}
}
}
int res=0;
for(int i=1;i<=n;i++) res=max(res,f[n][i]);
cout<<res<<endl;
return 0;
}