文章目录

• • （1）线性DP
  • • 898. 数字三角形
    • 895. 最长上升子序列
    • 897. 最长公共子序列
  • （2) 区间DP
  • • 282. 石子合并
    • • 区间 DP 常用模版

（1）线性DP

898. 数字三角形

题目链接

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

        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

---

解题思路一：

题意为从顶部出发一直走到最底层，要求找到路径上的数字之和最大，且每次只能往左下方或者右下方的节点移动。
可以使用f[i][j]来表示从顶部走到节点a[i][j]的路径上的数字和的最大值。
在状态计算时，可将状态集合进行划分，划分为从左上方移动到该点的路径上的数字和最大值f[i - 1][j - 1] + a[i][j]和从右上方移动到该点的路径上的数字和最大值f[i - 1][j] + a[i][j]，最后将两者进行比较取最大值，即可求得最终的f[i][j]。

C++代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, INF = 1e9;

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

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;
}

---

解题思路二：

把该题看作从最底层的每一个结点出发向上移动，从倒数第二层开始，每个结点均是由其左下方或者右下方的结点移动而来。
可以使用f[i][j]来表示从最底层走到结点a[i][j]的路径上的数字和的最大值。
在状态计算时，可将状态集合进行划分，划分为从左下方移动到该点的路径上的数字和最大值f[i + 1][j] + a[i][j]和从右下方移动到该点的路径上的数字和最大值f[i + 1][j + 1] + a[i][j]，最后将两者进行比较取最大值，即可求得最终的f[i][j]。

C++代码：

#include <iostream>

using namespace std;

const int N = 510;

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

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            cin >> a[i][j];
    
    for (int j = 1; j <= n; j++) f[n][j] = a[n][j]; // 初始化最底层的f[n][j]
    
    for (int i = n - 1; i >= 1; i--)
        for (int j = 1; j <= i; j++)
            f[i][j] = max(f[i + 1][j], f[i + 1][j + 1]) + a[i][j];
    cout << f[1][1] << endl;
    return 0;
}

---

895. 最长上升子序列

题目链接

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

输入格式
第一行包含整数 N。
第二行包含 N 个整数，表示完整序列。

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

数据范围
1 ≤ N ≤ 1000，
−10⁹ ≤ 数列中的数 ≤ 10⁹

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

---

解题思路：

状态表示：f[i]表示以第i个数结尾的上升子序列的最大长度
状态计算：以第i个数结尾的上升子序列可通过该序列的倒数第2位取第1 ~ i-1中的任意一位，对其进行集合划分f[i] = max(f[j] + 1), 其中j = 0, 1, 2, ..., i - 1。

C++代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

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

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    
    for (int i = 1; i <= n; i++) {
        f[i] = 1; // 设f[i]默认为1，即前面的数均大于第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]);
    
    cout << res << endl;
    return 0;
}

---

897. 最长公共子序列

题目链接

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

输入格式
第一行包含两个整数 N 和 M。
第二行包含一个长度为 N 的字符串，表示字符串 A。
第三行包含一个长度为 M 的字符串，表示字符串 B。

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

数据范围
1 ≤ N,M ≤ 1000

输入样例：

4 5
acbd
abedc

输出样例：

3

---

解题思路：

状态表示：f[i][j]表示第一个序列的前i个字母与第二个序列的前j个字母的最长公共子序列。
状态计算：f[i][j]通过最长公共子序列是否包含第一个序列的第i位和第二个序列的第j位来进行划分。

注意⚠️：由于f[i - 1, j]包含f[i - 1][j - 1]，因此只对上图的后三种情况进行讨论。

C++代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];

int main() {
    cin >> n >> m;
    cin >> 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);
        }
    
    cout << f[n][m] << endl;
    return 0;
}

---

（2) 区间DP

282. 石子合并

题目链接

设有 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

---

解题思路：

题意：合并 N 堆石子，每次只能合并相邻的两堆石子，求最小代价
关键点：最后一次合并一定是左边连续的一部分和右边连续的一部分进行合并
状态表示：f[i][j] 表示将 i 到 j 这一段石子合并成一堆的方案的集合，属性 Min
状态计算：
（1）i < j时，f[i][j] = min(f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);，其中i <= k <= j - 1。
（2）i = j时，f[i][j] = 0（一堆石子不用合并，代价为0）。
问题答案：f[1][n]

区间 DP 常用模版

所有的区间dp问题枚举时，第一维通常是枚举区间长度，并且一般 len = 1 时用来初始化，枚举从 len = 2 开始；第二维枚举起点 i （右端点 j 自动获得，j = i + len - 1）

模板代码如下：

for (int len = 1; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 枚举起点
        int j = i + len - 1;                 // 区间终点
        if (len == 1) {
            dp[i][j] = 初始值
            continue;
        }

        for (int k = i; k < j; k++) {        // 枚举分割点，构造状态转移方程
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);
        }
    }
}

C++代码：

#include <iostream>
#include <cstring>

using namespace std;

const int N = 307;

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

int main() {
    int n;
    cin >> n;

    for (int i = 1; i <= n; i ++) {
        cin >> a[i];
        s[i] += s[i - 1] + a[i];
    }

    memset(f, 0x3f, sizeof f);
    // 区间 DP 枚举套路：长度+左端点 
    for (int len = 1; len <= n; len ++) { // len表示[i, j]的元素个数
        for (int i = 1; i + len - 1 <= n; i ++) {
            int j = i + len - 1; // 自动得到右端点
            if (len == 1) {
                f[i][j] = 0;  // 边界初始化
                continue;
            }

            for (int k = i; k <= j - 1; k ++) { // 必须满足k + 1 <= j
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
            }
        }
    }

    cout << f[1][n] << endl;


    return 0;
}

---