动态规划dp（一）

动态规划dp

• dp首先分两步表示(以背包为例)
  • 1.状态表示 | 考虑用二维还是一维表示状态 s[i,j]:表示所有满足条件的选法的集合 f(i.j)表示s[i,j]集合的一个属性
    • 表示的是哪一个集合
      • 满足条件的所有选法的一个集合(条件…)
    • 表示的是什么属性(数)(max,min,数量)
  • 2.状态计算 |考虑如何一步一步计算每一个状态 将f(i,j)全部依次枚举之后得到的结果是f(n,m):所有从n个物体中的选法的集合的总价值的max,最后直接输出f[n][m]
    • 状态计算对应–集合的划分(如何把我们当前的这个集合划分成若干个子集,使得每一个集合都能用前一个更小集合表示出来)(划分的原因是:为了找状态转移方程)
    • 子集的划分原则
      • 不重(不一定必须满足,比如max)
      • 不漏
• dp的优化一般是dp的代码或者方程进行变形

---

一.背包问题

1. 01背包问题

每件物品用0\1次,挑选物品(值),在不超过背包体积的情况下,物品值最大.
S[i,j] 表示从0～i个物品里面挑选物品，物品重量不超过j的方案的集合。此时集合里的方案包含，在0~i位置的每一个物品, 都有“选”和“不选”的两种选择（这也是01背包的特点
滚动数组优化

dp步骤
1.状态表示 f(i,j)
条件:只从前i个物品中选,总体积<=j
集合:表示的是满足条件的所有选法
属性:总价值的最大值
2.状态计算 集合的划分
f(i,j):把从前i个物体中选,总体积<=j的选法(集合)划分成两个子集,

• 不选i(即前i个物体选,总体积不超过j的最大值的[前提 f(i,j)]不含i的集合);
  • 即:f(i-1,j);
  • 这个里面的j包含v[i]吗?,是的,相当于菜单上只有i-1道菜可以选,但是钱还有j元
• 选i(即即前i个物体选,总体积不超过j的最大值的[前提 f(i,j)]含i的集合)
  • 即1~i,j,i;<难点>
  • 思路:给每一个人±x,大小关系不变(类似递推)
  • 由于该集合里面都包含第i个物品,先把所有物品里的第i个物品去掉,所以含i的集合就变成:从1~i-1中选总体积不超过(j-v[i])的最大值的集合
  • 即f(i-1,j-v[i])+w[i];去掉第i个物品的占用体积+第i个物品的值
  • f(i-1,j-v[i])为什么要减去占用体积理解:去饭店点菜,菜单上有i道菜,一共j元,已经有一个价值v[i]的菜一定要点,so,剩下的钱就是j-v[i],剩下可以点的菜就是i-1

整个结果就是左右两个子集取max
f(i,j)=max(f(i-1,j),f(i-1,j-v[i])+w[i]);

为什么要这样划分呢？因为这样更方便求f(i,j)。
f(i,j)为集合S[i,j]的函数，在这题里f(i, j)=Max(集合中方案的权重),即最大值。
如何对f(i, j) 求值呢？想办法推导出递推的公式。参考斐波那契数列f(i) = f(i-1) + f(i - 2) 加f(0) = 0, f(1) = 1的base case）看能不能找到等式关系这个时候发现选i和不选i能够推导f(i,j)，所以S[i, j]集合就分成了选i和不选i的两部分。
分好后再按题目要求分别进行计算max，再联合两个部分（求两个部分max中的max），就能得到f(i,j)。

• 要枚举计算所有的状态 f[0 ~ n][0 ~ m]在枚举过程中不断更新最优解,得到f[n][m]
• 初始化
  f[0][0 ~ m]=0表示第0件物品,总体积不超过0\1\2\3…\m时候的集合max
• 左边不选i的集合肯定存在 ;但是选i的集合(属性最大值条件下)不一定存在,只有当v[i]<=j情况下才出现(条件判断)

二维:

#include<iostream>
#include<algorithm>
using namesapce std;
const int N=1010;
int n,m;
int v[N],w[N];
int f[N][N];
int main()
{
  cin>>n>>m;
  for(int i=1;i<=n;i++>)
  {
    cin>>v[i]>>w[i];
    for(int j=1;j<=m;j++)
    {
      //钱不够买i这个菜,就点菜不变
      f[i][j]=f[i-1][j];
      //如果钱购买这个菜,需要决策(max)买还是不买,买则钱包的钱要减少,菜单上可点的数量也变少1
      if(j>=v[i])
      f[i][j]=max(f[i][j],f[i-1][j-v[i]]+w[i]);
    }
  }
  cout<<f[n][m]<<endl;
  return 0;
}

优化:转二维到一维,滚动数组

原因:

• f[i]这一维只用到了f[i-1] 改成一维的滚动数组 (而i-1层是f[i]带过来的;删掉第一维的时候,遍历到f[i]的时候就已经用的是i-1的f[j])
• j包括j-v[i]都是< j的 一侧

修改:

• 代码中j=0 if(j>=v[i])的时候选i才成立;此时j < v[i]时for循环(相比二维f[j] 没有不选i时的初始化)都是没有用的;所以循环时从v[i]开始递增,变成for(int j=v[i];j<=m;j++)

• j-v[i]<=j,j是递增更新的,所以f[j-v[i]]在第i层(外层循环的层数)循环时在计算f[i]时被重新更新,但是此时我们应该保留i-1层时候的f[j-v[i]];
  为什么呢就是:

• for(int i = 1;i<=n;i++)
  {
    //从小到大j递增
    for(int j=v[i];j<=m;j++)
    {
        f[j]=max(f[j],f[j-v[i]]+w[i]);
        //等价于
        f[i][j]=max(f[i][j],f[i][j-v[i]]+w[i]);
        //然而实际是我们要求的是上一层的值,不需要在这一层被更新
        f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
    }
  }
  

所以修改的方法就是将j从大到小递减,j从小到大使得遍历过的在前面的值更新为i层的值,后面的没有遍历过的值还仍然是i-1次上一次循环的值;从大到小使得值的更新从后往前,后为i层,前为i-1层,所以满足;此时f[j-v[i]]没有被更新过

• 滚动数组:![image][picture1]
  只需要用到两层,两层间不断滚动f[i]与f[i-1]之间不断滚动

一维:

#include<iostream>
#include<algorithm>
using namespace std;
const int N =1010;
int n,m;
int v[N],w[N],f[N];
int main()
{
  cin>>n>>m;
  for(int i=1;i<=n;i++>)
  {
    cin>>v[i]>>w[i];
    for(int j=m;j>=v[i];j--)
    f[j]=max(f[j],f[j-v[i]]+w[i]);
  }
  cout<<f[m]<<endl;
  return 0;
}

2. 完全背包问题

每件物品无限个…滚动数组优化

1.状态表示:
集合:所有只考虑前i个物体,且总体积不大于j的所有选法;
属性:max
2.状态计算:–集合划分–按第i个物品(无限个)选0\1\2\3…\k多少个来划分集合

• 不选i(不选i的所有选法)菜单上可选的菜少1
  • f(i-1,j)
• 考虑i(选k个i的所有选法的集合)
  • 1.去掉k个i物品
  • 2.求max,f(i-1,j-k*v[i])
  • 3.再加回来k个物品i,f(i-1,j-k*v[i]) + w[i]*k;
• 综合起来发现k=0的时候同样满足式子得:f[i,j]=f[i-1,j-v[i]*k]+w[i]k;

基本思路得一个三循环的代码

//f(i,j)=f(i-1,j-v[i]*k)+w[i]*k;
 for (int i = 1; i <= n; i++)
 {
    cin >> v[i] >> w[i];
    for (int j = 1; j <= m; j++)for(int k=1;k*v[i]<=j;k++)
    f[i][j] = max(f[i][j],f[i - 1][j-v[i] * k] + w[i] * k);
    }
    cout << f[n][m] << endl;

考虑三循环转二循环–想办法去掉k

![image][tmp1]

 //f(i,j)=f(i-1,j-v[i]*k)+w[i]*k;
 for (int i = 1; i <= n; i++)
 {
  cin >> v[i] >> w[i];
  for (int j = 1; j <= m; j++)
  {
   //f[i,j]=max(f[i-1,j],f[i,j-v[i]+w)
   //不点这个菜
   f[i][ j] = f[i - 1][j];
   //点这个菜
   if (j >= v[i]) f[i][j] = max(f[i][j], f[i][j - v[i]] + w[i]);
  }
 }
 cout << f[n][m] << endl;

二维转一维

两个代码其实只有一句不同（注意下标）

i-1层数据
f[i][j] = max(f[i][j],f[i-1][j-v[i]]+w[i]);//01背包
就是第i层数据
f[i][j] = max(f[i][j],f[i][j-v[i]]+w[i]);//完全背包问题

因为和01背包代码很相像，我们很容易想到进一步优化。核心代码可以改成下面这样

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N];
int main() 
{
 cin >> n >> m;
 //f(i,j)=f(i-1,j-v[i]*k)+w[i]*k;
 for (int i = 1; i <= n; i++)
 {
  cin >> v[i] >> w[i];
  for (int j = v[i]; j <= m; j++)
  {
      //用的是i层的数据,所以就是从小到大滚动数组就行
      
   //f[i,j]=max(f[i-1,j],f[i,j-v[i]+w)
   f[j] = max(f[j], f[j - v[i]] + w[i]);
  }
 }
 cout << f[m] << endl;
 return 0;
}

为什么多重背包要用单调队列来优化? 因为多重背包是求一个滑动窗口内的最大值,而滑动窗口的优化必须用到单调队列优化.

3. 多重背包问题

每件物品有限个 si件…

• 状态表示f[i,j]
  • 集合:所有从前i个物体选,且总体积不超过j的选法
  • 属性 max
• 状态计算-集合划分-根据第i个物体选多少个来划分-0/1/2…/s[i]个
• 状态转移方程
  • f[i,j]=max(f[i-1,j],f[i-1,j-v[i]*k]+w[i]k) k=0~s[i]
    菜单上的菜少了1个,然后钱少k(0,或者k)个i菜价格,不是用的滚动数组,
    暴力做法 数据大些就会超时:

#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N],s[N];
int f[N][N];
int main() 
{
 cin >> n >> m;
 //f(i,j)=f(i-1,j-v[i]*k)+w[i]*k;
 for (int i = 1; i <= n; i++)
 {
  cin >> v[i] >> w[i]>>s[i];
  for (int j = 0; j <= m; j++)
  {
   for (int k = 0; k <= s[i]&&k*v[i]<=j; k++)
   {
    f[i][j] = max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);
   }
  }
 }
 cout << f[n][m] << endl;
 return 0;
}

优化:
疑惑1：为什么最后一项会是f[i-1,j-(S+1)v]+Sw?
在完全背包中,通过两个状态转移方程：
f[i , j ] = max( f[i-1,j] , f[i-1,j-v]+w , f[i-1,j-2v]+2w , f[i-1,j-3v]+3w, …)
f[i , j-v]= max( f[i-1,j-v] , f[i-1,j-2v] + w, f[i-1,j-2v]+2w , …)

通过上述比较，可以得到 f[ i ][ j ] = max(f[ i - 1 ][ j ],f[ i ][ j - v ] + w)。

再来看下多重背包,
f[i , j ] = max( f[i-1,j] ,f[i-1,j-v]+w ,f[i-1,j-2v]+2w ,… f[i-1,j-Sv]+Sw, )
f[i , j-v]= max( f[i-1,j-v] ,f[i-1,j-2v]+w, … f[i-1,j-Sv]+(S-1)w, f[i-1,j-(S+1)v]+Sw )

• 怎么比完全背包方程比较就多出了一项?
  其实，一般从实际含义出发来考虑即可，这里是在分析f[i,j-w]这个状态的表达式，首先这个状态的含义是 从前i个物品中选，且总体积不超过j-w的最大价值， 我们现在最多只能选s个物品，因此如果我们选s个第i个物品，那么体积上就要减去 sv,价值上就要加上sw，那更新到状态中去就是 f[i - 1, j - v - s * v] + s * w。

• 那为什么完全背包不会有最后一项？
  完全背包由于对每种物品没有选择个数的限制，所以只要体积够用就可以一直选，没有最后一项。

状态转移是f[i[j]=max(f[i][j],f[i-1][j-v])，要用到上一行j前面的数，所以不能从vi到m，这样的f[j-v]其实是f[i][j-vi]

二进制拆分优化:

原理：一个数能够被拆分为任意二进制的和。 (这个原理造出来好多算法啊QAQ)

T=2^p2+2p3+…+2^pn

而且小于等于T的所有整数都能被2p1,2^p2,2p3…2^pn的和表示出来
证明我不会，但是我知道任意一个数都有自己的二进制形式，比如 13=1101
小于等于13的二进制数肯定不会超过4位，对于T如果有K位，那么小于等于T的数都不可能大于K位
(因为2^1 + 2^2 + 2^3 … + 2^p-1 = 2^p - 1)
网络上有个例子就是什么：
2⁰⁺²1+2^{2能表示出1到7的任意整数，那么2}0+2¹⁺²2+6就能表示出1~13的整数
这个例子的剖析就是说：
一个数表示拆成小于它的所有二的次方的和(这个二次方的指数要是递增的)后会剩下一个数。
然后我们这样拆分之后就能用log(n)个数表示出 你想表示出来的1~n中的任意数了

为什么可以进行二进制优化
我们首先确认三点：

（1）我们知道转化成01背包的基本思路就是判断我是取了你好呢还是不取你好。
（2）我们知道任意一个实数可以由二进制数来表示，也就是2^0~2k其中一项或几项的和。
（3）这里多重背包问的就是每件物品取多少件可以获得最大价值。

分析：

• 如果直接遍历转化为01背包问题，是每次都拿一个来问，取了好还是不取好。那么根据数据范围，这样的时间复杂度是O(n^3),也就是1e+9，这样是毫无疑问是会TLE的。

• 假如10个取7个好，那么在实际的遍历过程中在第7个以后经过状态转移方程其实已经是选择“不取”好了。现在，用二进制思想将其分堆，分成k+1个分别有2^{k个的堆，然后拿这一堆一堆去问，我是取了好呢，还是不取好呢，经过dp选择之后，结果和拿一个一个来问的结果是完全一样的，因为dp选择的是最优结果，而根据第二点任意一个实数都可以用二进制来表示，如果最终选出来10个取7个是最优的在分堆的选择过程中分成了2}0=1,2^1=2,22=4,10 - 7 = 3 这四堆，然后去问四次，也就是拿去走dp状态转移方程，走的结果是第一堆1个，取了比不取好，第二堆2个，取了比不取好，第三堆四个，取了比不取好，第四堆8个，取了还不如不取，最后依旧是取了1+2+4=7个。

s->logs
log(s)
nvlog(s)

#include<iostream>
#include<algorithm>
using namesapce std;
const int
int n,m;

4. 分组背包问腿

有n组,每组里面只能选1个物品…