动态规划学习

1、背包DP

• $01$背包：枚举物品然后枚举体积，体积从大到小枚举更新$f[j]=max(f[j],f[j-w]+v)$.
• 完全背包：枚举物品然后枚举体积，体积从小到大枚举更新$f[j]=max(f[j],f[j-w]+v)$.
• 多重背包(物品有$k$个)：枚举物品后，二进制方式枚举物品件数。体积从大到小枚举，更新：$f[j]=max(f[j],f[j-k\ast w]+k\ast v)$.最后判断剩余$s$是否大于0，如果大于0再做一遍$01$背包。
• 混合背包(前三种混合体)：有限个物品则用多重背包方式优化做，无限物品则完全背包做。
• 分组背包(每个组只能选1个)：一维方法：先枚举体积后枚举物品，且体积枚举从大到小同时需要枚举到0。二维方法先枚举物品再枚举体积，体积也从大枚举到小需要枚举到0.
• 依赖背包(树形背包)：状态定义$f[u][i]$以$u$为根节点的子树中$i$体积最多可以获得的价值，需要通过回溯再继续更新$f[u][j]=max(f[u][j],f[u][j-k]+f[v][k])$.每次递归需要预处理出$f[u][i]$的值。更新先枚举总体积$j$从大到小枚举$[V,wei[u]+wei[v]]$.然后枚举分配到子节点的体积$[wei[v],u-wei[u]]$.

2、线性DP

• 数字三角形模型
  • 朴素版：只能从上走下来和从左边走过来$f[i][j]=max(f[i][j-1],f[i-1][j])+w[i][j]$.
  • 走的方块数量限制：曼哈顿距离$(1,1)->(n,n)$为$2n-2$.所以考虑是不是走的最短路
  • 走两条路：状态定义$f[k][i][j]$表示路径的长度为$k$，第一条路径到达$x_1=i$，第二条路径到达$x_2=j$的方案数。因此状态转移： f k , i , j = m a x { f k − 1 , i , j , f k − 1 , i − 1 , j , f k − 1 , i , j − 1 , f k − 1 , i − 1 , j − 1 + w } f_{k,i,j}=max\{ f_{k-1,i,j},f_{k-1,i-1,j},f_{k-1,i,j-1},f_{k-1,i-1,j-1}+w \} fk,i,j​=max{fk−1,i,j​,fk−1,i−1,j​,fk−1,i,j−1​,fk−1,i−1,j−1​+w}
  • 两条路径不能交叉，实际证明按上面的方式做就可以，上面的最优情况是可以变成不经过重复路线。
• 最长上升子序列模型
  • 最长公共子序列：$O(n^2)$，方程：$f[i][j]=max(f[i-1][j],f[i][j-1])$，如果$a[i]==b[i],f[i][j]=max(f[i][j],f[i-1][j-1]+1)$
  • 最长公共子串：$O(n^2)$，方程：$f[i][j]=max(f[i][j],f[i-1][j-1])$.
  • 最长上升子序列：
    • 方式1：$O(n^2)$，状态$f[i]$表示前$i$个数的最长上升子序列长度，更新：从$j\in [1,i)$找到每一个$a[j]<=a[i]$更新$f[i]=max(f[i],f[j]+1)$.
    • 方式2：$O(nlogn)$，用一个列表存储一个上升子序列，当$a[i]>s[-1]$时将$a[i]$加入到$s$中，小于时，二分查找$s$列表找到第一个大于等于$a[i]$的值用$a[i]$替换掉。

3、状压DP

• TSP问题：定义状态$f[i][j]$表示当前已近到达的状态为$i$，最后到达的城市是$j$，基本的状态转移方程为：$f[i][j]=min(f[i][j],f[i^{\prime }][k]+d[j][k])$，基于当前的状态$i$枚举前一个状态$i^{\prime }$，每次尝试更新从$i^{\prime }$到$i$，其中$i^{\prime }$状态最后到达的是$k$节点，然后更新是从$k$走到$j$。时间复杂度$O(n^2\ast 2^n)$这里的$n$的大小一般小于等于$18$.
• 状压一般就是枚举两个状态，当前状态和能够影响当前状态的前一状态，通过前一状态转移到当前状态。状态之间的转移一般比较容易。

4、数位DP

• 数位$DP$基本可以套板子，主要问题就是考虑前导0是否影响答案，也就是考虑$023$和$23$的区别有没有。下面是通用的板子。其他参数只有$total$是需要被考虑的。$is\_limit$表示的是达到了上线的数字。$is\_num$是表示是否是非0的数字

• from functools import lru_cache
  @lru_cache(maxsize=None)
  l,r = map(int,input().split())
  def f(s,i,total,is_limit,is_num,res=0):
      if i==len(s):
          return total #是否符合条件
      # 如果023和23有区别则需要处理前导0
      if not is_num:res += f(s,i+1,0,False,False)
      up = int(s[i]) if is_limit else 9
      for d in range(1-int(is_num),up+1):
          res += f(s,i+1,total+某个值,is_limit and d==up,True)
      return res
  print(f(str(r),0,0,True,False)-f(str(l-1),0,0,True,False))
  # 如果计算f(r)和f(l-1)时会有关联可以计算一个后清空cache
  f.cache_clear()
  

5、树型DP

• 求树的最大权值：类似于求最大子段和，只不过在树上，每次递归的时候先初始化$f[u]=a[u]$，然后递归$u$节点的每一个子节点，回溯的时候进行更新$iff[v]>0:f[u]+=f[v]$
• 求树的直径：第一次从根节点$dfs$递归到一个深度最大的节点$s$，然后以$s$以根节点递归都得一个最大深度的节点$p$，那么节点$s$到$p$就是树的直径。递归每个节点的儿子节点时遇到父节点跳过。
• 树型$DP$的基本思路是递归的开始进行预处理，然后枚举根节点的每个儿子节点，对儿子节点进行递归，回溯的时候再进行更新。