- 考虑状态和转移两种东西
	- 可以把状态看作是DAG上的点，然后状态转移就是边
- LCS问题
	- 两个序列`A[1..n]`和`B[1..m]`，求最长的子序列既是A的也是B的
	- 状态的定义：$f(i,j)=A[1:i]和B[1:j]的LCS$
	- 状态转移：如果`A[i]==B[j]`，那就直接接到后面`f[i,j] = f[i-1, j-1] + 1`；否则更新为`max(f[i-1, j], f[i, j-1])`
- LIS问题
	- 求最长子序列，子序列满足某些有序限制
	- 状态为：以第i个元素结尾的子序列的最长
	- 状态转移：在前面的子序列里面找一个最长且满足要求的子序列接在后面，也就是$f[i] = \max_{1 \le j \lt i, w[i] \lt w[j]}(f[j]) + 1$
- 01背包
	- n个物品，每个物品有价值v和重量w两种属性，W容量的包。每个物品是唯一的，求能装进包里的物品的价值最大。
	- 状态：$f[i, c]$为前i个物品已经处理完成，容量为c情况下的最大价值
	- 状态转移：当前物品装或者不装的决策。`f[i,c] = max(f[i-1, c], f[i-1, c-w[i]] + v[i])`。如果没有装物品，那么容量不变，价值也不变；如果装了第i个物品，那么它的价值增加且容量减小，因为这里当前状态`f[i,c]`是固定的（写的是一个逆推的形式），因此从更小容量转移过来
	- 在具体做的时候，需要注意一下顺序和空间压缩。
		- 因为第i个物品的i是有顺序的，因此可以压缩掉一维。变成这样`f[c] = max(f[c], f[c-w[i]] + v[i])`
		- 在滚动压缩的时候，需要保证逆推的顺序，否则容量较小的情况更新过后会影响到后面的推导。不过在非滚动数组的情况下，这则是不需要的，因为反正用的是i-1的状态
		  ```c
		  for (int i = 1; i <= n; ++ i)
		    for (int c = W; c >= w[i]; -- c)
		      f[c] = max(f[c], f[c - w[i]] + v[i])
		  ```
- 完全背包
	- n个物品，每个物品有价值v和重量w两种属性，W容量的包。**每个物品可以取多次**，求能装进包里的物品的价值最大。
	- 状态是一样的，唯一的区别在于，完全背包需要枚举当前物品取的次数
	- 不过这也可以优化掉，因为如果是正向推的话，已经包含了取所有可能次数的情况。
	- **0-1背包和完全背包区别就在于容量维度的迭代顺序**
	- ```c
	  for (int i = 1; i <= n; ++ i)
	    for (int c = w[i]; c <= W; ++ c)
	      f[c] = max(f[c], f[c - w[i]] + v[i]);
	  ```
- 多重背包
	- n种物品，每个物品有价值v和重量w两种属性，W容量的包。每种物品有k个，求能装进包里的物品的价值最大。
	- 转化为01背包求解。因为每种物品k个就等于有k个属性相同的物品分别取或者不取。
- 二维背包
	- 这道题是很明显的 0-1 背包问题，可是不同的是选一个物品会消耗两种价值（经费、时间），只需在状态中增加一维存放第二种价值即可，同时枚举的时候也变成了两个量。
	- 也就是状态方程变成了`f[i, c, d] = f[i-1, c - c[i], d-d[i]] + v[i]`
- 背包状态数
	- 把最大值换成求和，初始状态变成1（因为可以啥也不装）
	- `f[i, c] += f[i-1, c-w[i]]`
- 背包方案
	- 一种方案是，另外开一个数组记录状态`[i, c]`下有没有取i
	  ```
	  int v = V;  // 记录当前的存储空间
	  
	  // 因为最后一件物品存储的是最终状态，所以从最后一件物品进行循环
	  for (从最后一件循环至第一件) {
	    if (g[i][v]) {
	      选了第 i 项物品;
	      v -= 第 i 项物品的重量;
	    } else {
	      未选第 i 项物品;
	    }
	  }
	  ```
	- 另一种方案则是，不优化空间，然后倒着推算更新点（如果状态和前一个物品不一样，那肯是发生了转移）
	  ```
	      for (int i = n; i > 0; -- i) {
	          if (dp[i][res] != dp[i-1][res]) {
	              sel[i] = 1;
	              res -= w[i];
	          }
	      }
	  ```
- 区间dp
	- 具有明显的可划分性质
	- 经典的合并石子题：有n个数排成一个环，进行n-1次合并操作，每次操作将相邻的两堆合并成一堆，能获得新的一堆中的石子数量的和的得分。你需要最大化你的得分。
	- 状态：`f[l, r]`表示区间`[l:r]`合并所能得到的最大分数
	- 方程：枚举合并点k，取最大值。$f[l, r] = max_{i\le k \lt j}(f[i, k] + f[k+1, j]) + sum(a[i : j])$
		- 可以用前缀和来优化求和的过程
	- 这里的阶段划分并不是自然的（LIS、LCS自然就是LTR或者RTL，背包也就是依次取或者不取一个物品），需要用区间长度进行划分。
		- 对于该问题，还需要解决围成环这个问题，比较好的解决方法是展开成链式之后复制一遍，最后在n个长度为n的区间里面取最大值
	- 实现如下
	  ```c
	  for (int len = 1; len <= n; ++ len) {
	    for (int i = 1; i + len - 1 <= 2 * n; ++ i) { // 实际上是j<=2*n
	      int j = len + i - 1;
	      for (int k = i; k < j; ++ k) {
	        f[i][j] = max(f[i][j], f[i][k] + f[k+1][j] + sum[j] - sum[i-1]);
	      }
	    }
	  }
	  // ...
	  ans = [&]() {
	    int mx = 0;
	    for (int i = 1; i <= n; ++ i) mx = max(mx, f[i][i + n - 1]);
	    return mx;
	  }();
	  ```
	- 能量项链也是完全一样的思路，除了值的计算方法稍有区别。
- 树形dp
	- 就是在树上做dp，一般而言，状态肯定有某一维是“以节点u为根的子树”这样的东西。然后遍历子树求解就好了。
	- 例题1：POJ1463。有若干结点，结点之间有路相连，构成树形结构，如果在一个结点上放置一个士兵，与这个结点相连的路就可以被监视，现在要监视所有的路，问至少要多少士兵。
		- 状态：$f[u, 0/1]$为节点u放置或者不放置士兵情况下的最小值
		- 状态转移：如果当前节点不放，那么子节点就必须放置，也就是`f[u][0] = sum(f[v][1])`；如果当前节点放置，那么子节点可以放，也可以不放，对每个子节点的两种状态求最小值然后加起来（再加上自己1）：`f[u][1] = sum(min(f[v][0],f[v][1]) + 1`。
	- 舞会那个题的思路也是类似的，就不赘述了
- Floyd最短路
	- 状态：$f[k, i, j]$表示只经过编号不超过k的节点，从i到j的最短路长度
	- 状态转移：`f[k,i,j] = min(f[k-1, i, j], f[k-1, i, k] + f[k-1, k, j])`。决策就是要不要经过k这个点。
		- 显然第一维可以推掉，所以实际上数组是两维度的
	- 实现
	  ```c
	  int dis[maxn][maxn];
	  memset(dis, 0x3f, sizeof(dis));
	  for (int i = 1; i <= n; ++ i) dis[i][i] = 0;
	  for (int i = 1; i <= m; ++ i) {
	    int u = read(), v = read(), w = read();
	    dis[u][v] = dis[v][u] = w;
	  }
	  for (int k = 1; k <= n; ++ k){
	    for (int i = 1; i <= n; ++ i) {
	      for (int j = 1; j <= n; ++ j){
	        f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
	      }
	    }
	  }
	  ```