LogSeq/pages/动态规划.md

• 考虑状态和转移两种东西
  • 可以把状态看作是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的状态

      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背包和完全背包区别就在于容量维度的迭代顺序

  • 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的区间里面取最大值
  • 实现如下

    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这个点。
    • 显然第一维可以推掉，所以实际上数组是两维度的
  • 实现

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