dp之最长上升子序列


我们这篇文章是写给那些没有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;   
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值