动态规划(二)：线性DP、区间DP

线性DP

例题1：数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

输入格式

第一行包含整数 n，表示数字三角形的层数。

接下来 n 行，每行包含若干整数，其中第 i 行表示数字三角形第 i 层包含的整数。

输出格式

输出一个整数，表示最大的路径数字和。

数据范围

1≤n≤500
−10000≤三角形中的整数≤10000

输入样例：

5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5

输出样例：

30

解题思路：

 解题代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N=510,INF=1e9;

int n;
int a[N][N],f[N][N];//a:表示点的值,f:表示点的状态

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            scanf("%d",&a[i][j]);   
     //初始化       
    for(int i =0;i<=n;i++)
        for(int j=0;j<=i+1;j++)
            f[i][j]=-INF;
            
    f[1][1]=a[1][1];
    for(int i=2;i<=n;i++)//从第二行开始
        for(int j=1;j<=i;j++)
            f[i][j]=max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
            
    int res=-INF;
    for(int i=1;i<=n;i++) res=max(res,f[n][i]);//遍历最后一行，从起点走到底层的最大值
    
    printf("%d\n",res);
    return 0;
            
}

 例题2：最长上升子序列

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N。

第二行包含 N 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤1000
−109≤数列中的数≤109

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

解题思路：

  

解题代码： 

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n;
int a[N], f[N];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);

    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1; // 只有a[i]一个数
        for (int j = 1; j < i; 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]);

    printf("%d\n", res);

    return 0;
}

 例题3：最长公共子序列

给定两个长度分别为 N 和 M 的字符串 A 和 B，求既是 A的子序列又是 B 的子序列的字符串长度最长是多少。

输入格式

第一行包含两个整数 N 和 M。

第二行包含一个长度为 N 的字符串，表示字符串 A。

第三行包含一个长度为 M 的字符串，表示字符串 B。

字符串均由小写字母构成。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N,M≤1000

输入样例：

4 5
acbd
abedc

输出样例：

3

解题思路：

 

解题代码： 

#include <iostream>
#include <algorithm>

using namespace std;

const int N=1010;

int n,m;
char a[N],b[N];//a，b：俩个字符串
int f[N][N];

int main()
{
    scanf("%d%d",&n,&m);
    scanf("%s%s",a+1,b+1);
    
    //枚举下所有状态
    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);
        }
        
        printf("%d\n",f[n][m]);
        
        return 0;
}

区间DP

题目：石子合并

设有 N 堆石子排成一排，其编号为 1，2，3，…，N

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

例如有 4 堆石子分别为 1 3 5 2， 我们可以先合并 1、2堆，代价为 4，得到 4 5 2， 又合并 1，2堆，代价为 9，得到 9 2 ，再合并得到 11，总代价为 4+9+11=24；

如果第二步是先合并 2，3堆，则代价为 7，得到 4 7，最后一次合并代价为 11，总代价为 4+7+11=22

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 N 表示石子的堆数 N。

第二行 N 个数，表示每堆石子的质量(均不超过 1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤300

输入样例：

4
1 3 5 2

输出样例：

22

解题思路：

解题代码： 

#include <iostream>
#include <algorithm>

using namespace std;

const int N=310;

int n;
int s[N];
int f[N][N];

int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&s[i]);
    
    //处理前缀
    for(int i=1;i<=n;i++) s[i]+=s[i-1];
    
    //按照长度从小到大来枚举下所有状态
    for(int len=2;len<=n;len ++)
        for(int i=1;i+len-1<=n;i++)//枚举下起点
        {
            int l=i,r=i+len-1;
            f[l][r]=1e8;//初始化
            for(int k=l;k<r;k++)//枚举下分界点
                f[l][r]=min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
        }
    printf("%d\n",f[1][n]);
    
    return 0;
}