动态规划：线性DP

线性DP

线性DP是动态规划问题中的一类问题，指状态之间有线性关系的动态规划问题。
线性动态规划，是较常见的一类动态规划问题，其是在线性结构上进行状态转移，这类问题不像背包问题、区间DP等有固定的模板，线性动态规划的目标函数为特定变量的线性函数，约束是这些变量的线性不等式或等式，目的是求目标函数的最大值或最小值。

数字三角形

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

=>
状态表示：f[i,j]，到点i，j的最大路径

状态计算：f[i,j] = MAX(f[i-1,j-1]+a[i,j],f[i-1,j]+a[i,j])
代码：

#include <bits/stdc++.h>
using namespace std;
const int N = 510, M = 1e9;
int arr[N][N],brr[N][N],n;
int main()
{
   cin>>n;
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            cin>>arr[i][j];
    for (int i = 0; i <= n; i ++ )
        for (int j = 0; j <= i + 1; j ++ )
            brr[i][j] = -M;
    brr[1][1] = arr[1][1];
    for (int i = 2; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            brr[i][j] = max(brr[i - 1][j - 1] + arr[i][j], brr[i - 1][j] + arr[i][j]);
    int res = -M;
    for (int i = 1; i <= n; i ++ ) res = max(res, brr[n][i]);
    cin>>res;
    return 0;
}

最长上升子序列

状态表示：f[i]表示从第一个数字开始算，以w[i]结尾的最大的上升序列。(以w[i]结尾的所有上升序列中属性为最大值的那一个)
状态计算（集合划分）：j∈(0,1,2,…,i-1), 在w[i] > w[j]时，
f[i] = max(f[i], f[j] + 1)。
有一个边界，若前面没有比i小的，f[i]为1（自己为结尾）。
最后在找f[i]的最大值。
时间复杂度：O(n2) 状态数(n) * 转移数(n)
代码：

#include <iostream>
using namespace std;
const int N = 1010;
int arr[N], brr[N],n;
int main() {
    cin >> n;
    for (int i = 0; i < n; i++) cin >> arr[i];
    int m = 1;    // 找出所计算的f[i]之中的最大值，边算边找
    for (int i = 0; i < n; i++) {
        brr[i] = 1;    // 设f[i]默认为1，找不到前面数字小于自己的时候就为1
        for (int j = 0; j < i; j++) {
            if (arr[i] > arr[j]) f[i] = max(brr[i], brr[j] + 1);    // 前一个小于自己的数结尾的最大上升子序列加上自己，即+1
        }
        m= max(m, brr[i]);
    }
    cout << m << endl;
    return 0;
}

最长公共子序列

集合表示：f[i][j]表示a的前i个字母，和b的前j个字母的最长公共子序列长度；
集合划分：以a[i],b[j]是否包含在子序列当中为依据，因此可以分成四类：
1.a[i]不在，b[j]不在：max=f[i−1][j−1]；
2.a[i]a[i]不在，b[j]b[j]在：条件给定是a[i]一定不在子序列中，b[j]一定在子序列当中，但仍可以用f[i−1][j]来表示；
3.a[i]，b[j]不在 原理同2；
4.a[i]在，b[j]在： max=f[i−1][j−1]+1；

char a[N],b[N];
int f[N][N];
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);