我们这篇文章是写给那些没有dp基础的同学的。
这篇文章主要讲的是最长上升子序列的模型。
1.子序列的概念
首先呢我们要行明确一个概念就是什么是子序列。
子序列：子序列就是在原来序列中找出一部分组成的序列；
递增子序列:首先它是子序列,其次它们的元素是递增的；
最长上升子序列：就是子序列中元素单调递增并且元素个数最多的那个.
2.最长上升子序列母题
首先我们是用闫氏dp分析法，从状态表示和状态计算两个方面进行考虑；状态表示的话我们分成两个方面，一个是集合另一个数属性。
状态表示
集合f[i]可以表示为以a[i]结尾的严格单调上升的子序列；
属性为：Max；
状态计算
表示的是以a[i]结尾的上升子序列。
整体上可以分成两种情况，第一种是为空的时候说明此时只有a[i]一个元素这样的话为1；
第二种情况就是前面的i-1种情况，在这种情况的时候不是所有的条件都是满足的，因此我们要先判断是否成立判断条件就是a[i]>a[j]，只有满足是单调的情况下才能更新状态。
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
long long a[N];
long long f[N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
long long ans = 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);//更新状态
}
}
ans = max(ans, f[i]);//取最大值
}
cout << ans << endl;
return 0;
}
在确认上面那个题理解的比较透彻的话请往下看，下面是母题的一些扩展
3.最长上升子序列模型的扩展题
1.怪盗基德的滑翔翼
题意：给你n栋楼的高度，怪盗基德可以选择在任意的一栋楼开始，在楼间跳跃，但是每次他只能跳跃比当前楼高度低的楼，他可以选择任意的一个方向跳，但是一旦选择就不能改变方向。
思路：和上面的母题差不多，就是正着反着都求一遍，然后，求最大值即可
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int a[N];
int f[N];
void solve()
{
int n;
cin>>n;
int ans=0;
for(int i=0;i<n;i++) cin>>a[i];
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);
}
}
ans=max(ans,f[i]);
}
memset(f,0,sizeof f);
for(int i=n-1;i>=0;i--)
{
f[i]=1;
for(int j=n-1;j>i;j--)
{
if(a[i]>a[j])
{
f[i]=max(f[i],f[j]+1);
}
}
ans=max(ans,f[i]);
}
cout<<ans<<endl;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
cin>>T;
while(T--)
{
solve();
}
return 0;
}
2.合唱队形
题意：给我们n个点，这个题要求我们满足一个单增到单减的一个图，去掉其中的点，求去掉的最少的点的个数
思路：思路话很简答，就是预处理一遍，然后求每一个点的最大值，然后减去1
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int a[N];
int f[N];
int g[N];
void solve()
{
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++)
cin >> a[i];
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);
}
}
ans = max(ans, f[i]);
}
for (int i = n - 1; i >= 0; i--)
{
g[i] = 1;
for (int j = n - 1; j > i; j--)
{
if (a[i] > a[j])
{
g[i] = max(g[i], g[j] + 1);
}
}
ans = max(ans, g[i]);
}
for (int i = 0; i < n; i++)
{
ans = max(ans, f[i] + g[i] - 1);
}
cout << ans << endl;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--)
{
solve();
}
return 0;
}
3.友好城市
题意:这个题的话给我们n对友好的城市，然后我们在友好城市之间进行建造桥的任务，只能在友好城市之间建桥，并且要求桥不能相交。求最大的建桥数量。
思路：这个题的思路不是很好想，首先我们可以进行一次按上方的进行排序，然后按顺序遍历上方的点，如果上方的点较大的话，并且，它对应的下方的点较小的话，那么这就一定会相交。所以我么只需要按上方进行排序，然后下方求出最长上升子序列的值就是最后的答案。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 5010;
struct node
{
int x;
int y;
}dp[N];
int f[N];
bool cmp(node a,node b)
{
return a.x<b.x;
}
void solve()
{
int n;
cin>>n;
for(int i=0;i<n;i++) cin>>dp[i].x>>dp[i].y;
sort(dp,dp+n,cmp);
int ans=0;
for(int i=0;i<n;i++)
{
f[i]=1;
for(int j=0;j<i;j++)
{
if(dp[i].y>dp[j].y)
{
f[i]=max(f[i],f[j]+1);
}
}
ans=max(ans,f[i]);
}
cout<<ans<<endl;
}
int main()
{
int T;
T=1;
while(T--)
{
solve();
}
return 0;
}
4.最大上升子序列和
题意：给我们一个序列，让我们求最大的上升子序列的和。
思路：这个题的话还是用闫氏dp分析法，首先我们先确定状态表示，状态表示的话，我们的集合定义的是以a[i]结尾的上升子序列，属性是和的最大值。状态计算的话
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1010;
int a[N];
int f[N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
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]=a[i];
for(int j=1;j<i;j++)
{
if(a[j]<a[i])
{
f[i]=max(f[i],f[j]+a[i]);
}
}
}
for(int i=1;i<=n;i++) res=max(res,f[i]);
cout<<res<<endl;
return 0;
}
5.导弹防御系统
题意：这个题的意思是每次你可以选择一个导弹系统，它只能是单增或者单减的，问你最少需要多少防御系统可以将导弹全部击落。
思路；这个题的话我们可以采用dp的思想，我们先可以，然后就是枚举每一种情况就行，然后从每种情况里面找出最小的那一个。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 55;
int a[N];
int up[N], down[N];
int ans;
int n;
void dfs(int u, int su, int sd) //u表示现在到哪一个导弹了，su表示上升的系统数量，sd表示下降的系统数量。
{
int t;
if (ans <= su + sd) //如果一旦当前的系统数量已经大于我们的ans了，那么直接退出就可以了
{
return;
}
if (u == n)
{
ans = su + sd;
return;
}
int k = 0;
while (k < su && up[k] >= a[u])//这样一定可以保证是比up[k]大的里面最小的那一个
k++;
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()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
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;
}
在我们学习最后一个问题之前我们必须在了解一个问题，就是最长公共子序列问题。
6.最长公共子序列
题意：给我们两个序列，然后让我们求公共子序列最长的长度是多少
思路：我们继续用闫氏dp分析法，首先我们考虑状态表示，集合：集合的话表示的是在A[1…i]中和B[1…j]中的公共子序列的集合。那么它的属性就是Max。然后我们再来看状态计算。
第一个和最后一个很好表示，但是中间的就不是很表示，第二种和第三种有重复的部分，举个例，第二种情况的话不止表示的是含有b[j]的，也表示不含有b[j]的。第三种一样，但是我们需要求的是Max所以重复的话不会对我们的结果造成影响
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1110;
char a[N], b[N];
int f[N][N];
int n, m;
int main()
{
cin >> n >> m >> a + 1 >> b + 1;
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
if (a[i] == b[j])
f[i][j] = f[i - 1][j - 1] + 1;
else
f[i][j] = max(f[i][j - 1], f[i - 1][j]);
}
}
cout << f[n][m] << endl;
return 0;
}
我们最后再来说一个题。
7.最长公共上升子序列
思路：
我们可以看到分成了两个大的部分一个是没有a[i]的这样的话我们的集合定义就可以直接妈祖情况，但是如果是另一种的话就不满足了，我们可能包含a[i]也可能不包含a[i]这样的话我们不能直接求出结果所以我们就要分情况求。求前一步的然后加上a[i]即可，然后我们前一个的话也没法直接求，就需要再分分成1…k每次都求然后算一个最大值就好。
暴力版
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 3010;
int a[N];
int b[N];
int f[N][N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
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])
{
int maxv=1;
for(int k=1;k<j;k++)
{
if(b[j]>b[k])
{
maxv=max(maxv,f[i-1][k]+1);
}
}
f[i][j]=max(maxv,f[i][j]);
}
}
}
int res=0;
for(int i=1;i<=n;i++) res=max(res,f[n][i]);
cout<<res<<endl;
return 0;
}
优化版
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 3010;
int a[N];
int b[N];
int f[N][N];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
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;
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(a[i]>b[j]) maxv=max(maxv,f[i-1][j]+1);
}
}
int res=0;
for(int i=1;i<=n;i++) res = max(res,f[n][i]);
cout<<res<<endl;
return 0;
}
1636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
