【动态规划】线性dp

数组三角形

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

        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]表示所有从起点，走到点ij的路径的最大值

状态计算也很简单，就两种情况，一种是经过左上角过来，一种是经过右上角过来

于是状态计算方程为 f[i][j] = max(f[i -1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);

import java.io.*;
import java.util.*;
public class Main {
    static final int N = 510;
    static final int MIN_NUM = -2147483647 / 2;
    static int[][] a = new int[N][N];
    static int[][] f = new int[N][N];
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //读入所有数据
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= i; j++) {
                a[i][j] = sc.nextInt();
            }
        }
        //初始化所有f为负无穷
        for(int i = 0; i <= n; i++) {
            for(int j = 0; j <= n + 1; j++) {
                f[i][j] = MIN_NUM;
            }
        }
        //第一个点的距离确定
        f[1][1] = a[1][1];
        //从三角形顶点到该点的最长距离
        for(int i = 2; i <= n; i++) {
            for(int j = 1; j <= i; j++) {
                f[i][j] = Math.max(f[i -1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);
            }
        }
        //最后遍历最后一层，找到最大值
        int res = MIN_NUM;
        for(int i = 1; i <= n; i++) {
            res = Math.max(res, f[n][i]);
        }
        System.out.println(res);
        sc.close();
    }
}

值得注意的是，对f数组进行初始化的时候，因为状态计算要用到边界值，所以边界值也要进行初始化

最长上升子序列

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

输入格式

第一行包含整数 N。

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

输出格式

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

数据范围

1≤N≤1000，
$-10^9$≤数列中的数≤$10^9$

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

【思路解析】

状态表示： f[i]表示从起点到i点最长上升子序列的值

状态计算：

通过两层循环计算f数组的值。外层循环遍历序列的每个位置i，初始时将f[i]设为 1（每个点自身至少构成长度为 1 的递增子序列）。内层循环遍历j从 1 到i-1的位置，如果a[j] < a[i]，则更新f[i]为f[j] + 1和f[i]中的较大值。

import java.util.*;
public class Main {
    static final int N = 1010;
    static int[] f = new int[N];
    static int[] a = new int[N];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        //读入数据
        for(int i = 1; i <= n; i++) {
            a[i] = sc.nextInt();
        }
        //状态计算
        for(int i = 1; i <= n; i++) {
            //每个点至少是1
            f[i] = 1;
            for(int j = 1; j < i; j++) {
                if(a[j] < a[i]) {
                    f[i] = Math.max(f[i], f[j] + 1);
                }
            }
        }
        int res = 0;
        for(int i = 1; i <= n; i++) {
            res = Math.max(res, f[i]);
        }
        System.out.println(res);
        sc.close();
    }
}

最长公共子序列

给定两个长度分别为 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个字母中出现的子序列

状态计算

根据a[i] b[j]是否是子序列中的一员对f[i][j]进行状态计算，一共有四种情况

• 不选a[i] 不选b[i]
• 选a[i] 不选b[i]
• 不选a[i] 选b[i]
• 选a[i] 选b[i]

其中不选a[i] 不选b[i]可以表示为f[i - 1][j - 1]

选a[i] 选b[i]可以表示为f[i - 1][j - 1] + 1

这两种很容易表示，但是中间两种情况就没办法这样进行划分

f[i - 1][j]表示的是在第一个序列前i - 1 个字母中出现，且在第二个序列的前j个字母中出现的子序列的最大值

仅仅是出现，并不能等价为b[j]是子序列中的一员

比如求a[5]b[5] a序列是abdfc， b序列是ababa，a[i]和b[j]都不在子序列中但却在f[i-1][j]中，同时说明f[i - 1][j]和f[i][j - 1]包含了f[i - 1][j - 1]

即使重复，但因为是取最大值，不会对结果产生影响

import java.util.*;
import java.io.*;
public class Main {
    static final int N =1010;
    static int[][] f = new int[N][N];
    static char[] a = new char[N];
    static char[] b = new char[N];
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] strSize = br.readLine().split(" ");
        int n = Integer.parseInt(strSize[0]);
        int m = Integer.parseInt(strSize[1]);
        a = (" " + br.readLine()).toCharArray();
        b = (" " + br.readLine()).toCharArray();
        for(int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                if (a[i] == b[j]) {
                    f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
                }
            }
        }
        System.out.println(f[n][m]);
        br.close();
    }
}