线性DP、区间DP、计数类DP

线性DP

AcWing 898. 数字三角形

分析：
f[i，j] 这个状态表示一个集合，是所有从起点走到(i，j)的路径，f[i，j] 存的值是这条路径的最大值。
集合划分： f[i，j] 可以划分为两部分：
① 来自 (i，j) 的左上方： f[i-1，j-1] + a[i][j]
② 来自 (i，j) 的右上方： f[i-1，j] + a[i][j]

#include<iostream>
#include<cstring>
using namespace std;
const int N = 505;
int f[N][N],a[N][N];

int main()
{
    int n;
    cin >> n;
    
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++)
            cin >> a[i][j];
            
    for(int i=1; i<=n; i++) //为了不算上j=1的左上方和j=i的正上方
    {
        f[i][0] = -1e9; 
        f[i][i+1] = -1e9;
    }
            
    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 = -1e9;        
    for(int i=1; i<=n; i++) res = max(res,f[n][i]);
    cout << res;
}

---

AcWing 895. 最长上升子序列

分析：
f[i] 这个状态表示一个集合，是所有以第 i 个数结尾的上升子序列，f[i] 存的值是每一个上升子序列长度的最大值。
集合划分： f[i] 的划分可以以第 i-1 个数是谁来划分。可能是 a[1]、a[2]…a[i-1]，也可能不存在，不存在说明子序列只有 a[i] 这一个数。即 f[i] = f[j] + 1（j=1、2、…、i-1 且 a_j < a_i）

#include<iostream>
using namespace std;
const int N = 1005;
int a[N], f[N];

int main()
{
    int n;
    cin >> n;
    for(int i=1; i<=n; i++) cin >> 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]);
    
    cout << res;
}

类似的一道题：zzuli 1304: 防御导弹

---

AcWing 897. 最长公共子序列

分析：
f[i，j] 这个状态表示一个集合，是所有在第一个序列的前 i 个字母中出现，且在第二个序列的前 j 个字母中出现的子序列，f[i，j] 存的值是每一个子序列长度的最大值。
集合划分：f[i，j]可以划分为四种状态：
① 包含 a[i]、包含b[j]：f[i-1，j-1] + 1
② 不包含 a[i]、不包含b[j] : f[i-1，j-1]
③ 包含 a[i]、不包含b[j]: f[i，j-1]，其实 f[i，j-1] 确实是不包含 b[j]，但不一定包含 a[i]，也就是说 f[i，j-1] 涵盖了 “包含 a[i]、不包含b[j]” 这种情况，这样算的话，肯定会有重复，但因为我们求的是最大值，所以重复算并不影响答案。
④ 不包含 a[i]、包含b[j]: f[i-1，j]，同理③

能看出，③④这两种情况都是包含 ② 的，所以总的来说 f[i，j] 划分的三种情况是①③④

#include<iostream>
using namespace std;
const int N = 1005;
char a[N], b[N];
int f[N][N];

int main()
{
    int n, m;
    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); //第④种情况只有a[i]=b[j]时才有的
     }
     
     cout << f[n][m];
}

---

AcWing 902. 最短编辑距离

分析：
f[i，j] 这个状态表示一个集合，是所有将 a[1 ~ i] 变成 b[i ~ j] 的操作方式，f[i，j] 存的值是所有操作方式的操作步骤的最小值。
集合划分：f[i，j]可以根据 a 的最后一次操作划分为三种状态：
① a的最后一次操作是删除，那么删除 a_i 后，a[1 ~ i] 和 b[1 ~ j] 匹配，所以要先做到 a[1 ~ i-1] 和 b[1 ~ j] 匹配，即 f[i-1，j] + 1
② a的最后一次操作是增加，那么插入一个数后 (这个数一一定是 b_j)，a[1 ~ i] 和 b[1 ~ j] 匹配，所以要先做到 a[1 ~ i] 和 b[1 ~ j-1] 匹配，即 f[i，j-1] + 1
③ a的最后一次操作是修改，将 a_i 修改成 b_j ，所以要先做到 a[1 ~ i-1] 和 b[1 ~ j-1] 匹配，即 f[i-1，j-1] + 1，但如果 a_i 原本就和 b_j 相等的话，那么就不用修改了，即 f[i-1，j-1] + 0

#include<iostream>
using namespace std;
const int N = 1005;
char a[N], b[N];
int f[N][N];

int main()
{
    int n, m;
    cin >> n >> a+1 >> m >> b+1;
    
    for(int i=1; i<=m; i++) f[0][i] = i; //a的长度为0，变成b需要增加i个字母
    for(int i=1; i<=n; i++) f[i][0] = i; //a的长度为i，变成b需要删除i个字母
    
    for(int i=1; i<=n; i++)
     for(int j=1; j<=m; j++)
      {
          f[i][j] = min(f[i-1][j] + 1, f[i][j-1] + 1);
          if(a[i] == b[j]) f[i][j] = min(f[i][j], f[i-1][j-1]);
          else f[i][j] = min(f[i][j], f[i-1][j-1] + 1);
      }
      
    cout << f[n][m];  
}

---

AcWing 899. 编辑距离

#include<iostream>
#include<string.h>
using namespace std;
const int N = 15, M = 1005;
char a[M][N];
int f[N][N];
int n, m;

int pd(char a[],char b[])
{
    int la = strlen(a+1), lb = strlen(b+1); //a、b的长度
    for(int i=0; i<=lb; i++) f[0][i] = i;
    for(int i=0; i<=la; i++) f[i][0] = i;
    
    for(int i=1; i<=la; i++)
     for(int j=1; j<=lb; j++)
     {
         f[i][j] = min(f[i-1][j] + 1, f[i][j-1] + 1);
         if(a[i] == b[j]) f[i][j] = min(f[i][j], f[i-1][j-1]);
         else f[i][j] = min(f[i][j], f[i-1][j-1] + 1);
     }
     return f[la][lb];
}

int main()
{
    cin >> n >> m;
    
    for(int i=0; i<n; i++) cin >> a[i] + 1;
    
    while(m--)
    {
        int limit, cnt = 0;
        char b[N];
        cin >> b+1 >> limit;
        for(int i=0; i<n; i++)
        if(pd(a[i],b) <= limit) cnt++; 
       
        cout << cnt << endl;
    }
}

---

区间DP

AcWing 282. 石子合并

分析：
f[i，j] 这个状态表示一个集合，是所有将第 i 堆石子到第 j 堆石子合并成一堆石子的合并方式，f[i，j] 存的值是所有合并方式代价的最小值。
集合划分：在合并第 i~j 堆石子时，以最后一次合并两堆石子的分界线 k 的位置来分类，s 是前缀和

#include<iostream>
using namespace std;
const int N = 305;
int s[N], f[N][N];

int main()
{
    int n;
    cin >> n;
    for(int i=1; i<=n; i++) 
    {
        cin >> s[i];
        s[i] += s[i-1]; 
    }
    
    for(int len=2; len<=n; len++) //枚举长度,len从2开始，len=1时，只有一对石子，不用合并
     for(int i=1; i+len-1<=n; i++) //枚举起点
     {
         int l = i, r = i+len-1; //区间起点、终点
         f[l][r] = 1e9;
         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]); 
     }
    cout << f[1][n];
}

---

计数类DP

AcWing 900. 整数划分

这一题可以按照完全背包的思想做

分析：
f[i，j] 这个状态表示一个集合，是所有从 1~ i 中选，总体积恰为 j 选法的集合。f[i，j] 存的值是从 1~ i 中选，总体积恰为 j 的选法的数量。
集合划分：按照完全背包的思想，是按照第 i 个物品选几个来划分的(0/1/2/3…/s，s是最大能选第 i 个物品的个数)

f[i][j] = f[i - 1][j] + f[i - 1][j - i] + f[i - 1][j - 2 * i] + …;
f[i][j - i] = f[i - 1][j - i] + f[i - 1][j - 2 * i] + …;

所以，f[i][j] = f[i-1][j] + f[i][j-i]

#include<iostream>
using namespace std;
const int N = 1005, mod = 1e9 + 7;
int f[N][N]; //f[i][j]:从 1~i 中选，体积恰为 j

int main()
{
    int n;
    cin >> n;
    for(int i=1; i<=n; i++) f[i][0] = 1; //从前 i 个选，体积为0，说明一个都不选，只有一种方案
    
    for(int i=1; i<=n; i++)
     for(int j=1; j<=n; j++)
     {
         f[i][j] = f[i-1][j] % mod;
         if(j >= i) f[i][j] = max(f[i][j], f[i-1][j] + f[i][j-i]) % mod;
     }
    
    cout << f[n][n];
}

二维到一维空间优化：

#include<iostream>
using namespace std;
const int N = 1005, mod = 1e9 + 7;
int f[N]; //f[i][j]:从 1~i 中选，体积恰为 j

int main()
{
    int n;
    cin >> n;
     f[0] = 1; //从前 i 个选，体积为0，说明一个都不选，只有一种方案
    
    for(int i=1; i<=n; i++)
     for(int j=i; j<=n; j++)
          f[j] =  max(f[j],f[j] + f[j-i]) % mod;
    cout << f[n];
}