DP学习总结

(个人理解)
动态规划

思想：

当问题的解可以由比他规模小一点的问题的解推出来的时候(无后效性)，就可以考虑能不能用动态规划
诈一看，就不就是递归的思想
没错！它就是的
动态规划就是基于递归，在递归的基础上进行优化

首先看递归哪里需要优化
例如斐波那契数列递推式
fun(x) == fun(x-1) + fun(x-2)
递归结束条件
if( x为1或者2的时候) return 1

当递归计算f(5)和f(6) 的时候,f(4)会被计算2次

所以存在重复计算 (画重点)

dp就是优化了递归的重复计算，让它不用重复计算 ,这也是dp优于其他做法的原因

做法
把计算过的结果都保存下来，等到再需要用到它的时候，就直接用，就保证了每一个结果都只会被计算一次

结论: dp == 递归思想 + 打表

状态

为什么要设置状态呢?
因为要打表嘛，打表是为了把每一个结果保存起来，那么它保存在哪里？怎么知道这个结果它对应的问题是什么?
这就需要设置状态了。

状态设置方法
找到每个问题的标志因素, 也就是每个问题的不同点
利用不同点来表示问题

例如斐波那契数列,求每一个数的不同点，可以是数在斐波那契中的位置。(也就是按位置进行分类)

那么就可以以他们的位置，来设置状态.
假设一个结果保存在 f[i] 这个元素中，它就表示的是斐波那契中第i个元素的值

设置状态就是，给每一个保存下来的值，赋予一个意义，这个意义对应于一类实际的问题

所以，打表需要设置状态，设置状态后，就可以按照一类问题得到这个问题对应的结果了。

结论：问题和结果通过状态联系起来了

状态转移方程

这里做一个比较;

状态目的:
把问题和结果联系起来

状态计算目的:
把问题和问题联系起来

设置完状态后，就只需要找到问题之间的关系，通过小问题推出大问题，这个过程本质就是找一个递推式的过程

例如斐波那契的递推式就是
f[i] == f[i-1] + f[i-2]
（这里的f[i]是一个问题的解，并不是一个函数）
这就是斐波那契数列的状态转移方程

动态规划就2个难题
1.状态表示
2.找状态转移方程

具体找这个递推式，就要看具体的问题了,本质就是找问题是怎么由比他规模小的子问题求出来的

方法
借用一下y总的方法
出处：acwing y总

把最后问题的状态抽象成一个集合
然后把这个集合进行划分，划分成若干个子集(重点在于划分)
要求所有子集不重不漏
看这个集合的值，是怎么由这些子集得出来的
每个子集对应于一个状态
划分方法
进行划分的时候，一般考虑最后一步是什么

做递归的时候，也可以这样进行抽象
结论：状态转移方程 == "大"状态和"小"状态的关系

特别注意:
当上面都想好了后，要考虑边界问题
每一个状态都是有意义的，要看一开始要不要把一些易知的状态值初始化一下

大总结:
1.可以运用递归思想的问题可以考虑使用dp
2.dp优化了递归的重复计算,方法是打表
3.设置状态是为了打表
4.状态将问题和结果联系起来了
5.状态转移方程将问题和问题联系起来了
6.找递推式可以运用集合的角度

动态规划时间复杂度分析
转态数量*每个状态计算量

经典题目

背包部分问题

01背包
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

题中要求的是容量为V的背包放不超过N个东西的最大值
稍微改变一下，题目要求的就是从前N个物品中选，放入容量为V的背包可行方案中的最大值

可以看出，比问题规模小的问题，他们的区别就在于，物品和容量的变化,所以就可以用这2个元素来设置状态

设置 f[i,j]表示选前i个物品，放入容量为j的背包中可行方案中的最大价值

设置完状态现在就看状态转移方程怎么得

把 f[i,j] 看成一个集合(集合元素是所有可行方案)，现在对他进行划分

划分依据最后一步是什么到这个(也就是到这个集合的前一步)集合的，可以看出最后一步可以是选不选第i个物品

那么f[i,j]可以划分为，有i这个物品的，没有i这个物品的

然后2者取个最大值

有i这个物品的 也就是前i-1个物品放入容量为j-v[i]的背包中的最大价值+第i个物品的价值
也就是 f[i-1,j-v[i]]+w[i]

没有第i个物品的，也就是前i-1个物品放入容量为j的背包的最大价值
f[i-1,j]

所以状态转移方程就是 f[i,j]=max(f[i-1,j],f[i-1,j-v[i]]+w[i])
这里还需要考虑放不下第i件物品，放不下的话，就是 f[i-1,j]

这些考虑完了后，还有一个要考虑的就是状态的初值

这里要求的是最大值所以一开始都初始化为0
再考虑边界
f[i,0]放不下，所以也是0,
f[0,i]不放没有价值也是0

最后我们的答案对应的状态的值就是 f[物品数，背包容量]

#include<iostream>
using namespace std;

const int N=1010;
int f[N][N],v[N],w[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d",&v[i],&w[i]);
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(j>=v[i])//当放不下第i个物品的时候，就不放
            f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
            else f[i][j]=f[i-1][j];
    
    printf("%d\n",f[n][m]);
    
    return 0;
}

再看状态转移方程
f[i,j]=max(f[i-1,j],f[i-1,j-v[i]]+w[i])

都是只用到了i-1的值，那么就可以用滚动数组了，把2维变成一维

变成一维后，用这个一维数组保存每次选完一件物品后的值

那么执行到第i件物品的时候，f[]中保存的是前i-1件物品的最大价值

那么
f[i-1,j] 变成了f[j]
f[i-1,j-v[i]+w[i]]变成了f[j-v[i]]+w[i]

遍历的话，必须 背包容量~0,因为每次要求f[j-v[i]]是保存的是前i-1物品的最大价值

#include<iostream>
using namespace std;

const int N=1010;
int f[N],v[N],w[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d",&v[i],&w[i]);
    
    for(int i=1;i<=n;i++)
        for(int j=m;j>=v[i];j--)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
            
    printf("%d\n",f[m]);
    
    return 0;
}

01背包时间复杂度 O(nm)

完全背包
完全背包和01背包的区别在于完全背包的物品可以放任意个
他每个物品都有无限个

转态不变 还是 f[i,j]

然后进行划分，在01背包的时候，划分是划分为有和没有第i个物品的，那么完全背包就可以划分为,有几个第i个物品的

没有的 f[i-1,j]
有1个的 f[i-1,j-v[i]]+w[i]
有2个的f[i-1,j-2v[i]]+2w[i]
…
最多有V/v[i]件第i个物品

那么状态转移方程就是
f[i,j]=max(f[i-1,j],f[i-1,j-v[i]]+w[i],f[i-1,j-2v[i]]+2w[i]…)

#include<iostream>
using namespace std;

const int N=1010;
int f[N][N],v[N],w[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d",&v[i],&w[i]);
    
    for(int i=1;i<=n;i++)
        for(int k=0;k<=m/v[i];k++)
            for(int j=1;j<=m;j++)
            if(j>=k*v[i]) f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
    printf("%d\n",f[n][m]);
    
    return 0;
}

这个时间复杂度是很高的，所以要进行优化

f[i,j]=max(f[i-1,j],f[i-1,j-v[i]]+w[i],f[i-1,j-2v[i]]+2w[i]…)

看这个方程，他的后面几项都有j-kv[i]
那么想 f[i,j-v[i]] == ?
f[i,j-v[i]] = max(f[i-1,j-v[i]],f[i-1,j-2v[i]]+w[i],f[i-1,j-3v[i]]+2w[i]…)
这个式子是和后面几项符合的,最后的最大值，只要加上一个w[i]，就可以和上面对应了.

所以 f[i,j] =max(f[i-1,j],f[i,j-v[i]]+w[i])

这样就可以不用枚举物品个数了

#include<iostream>
using namespace std;

const int N=1010;
int f[N][N],v[N],w[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d",&v[i],&w[i]);
    
    for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                if(j>=v[i]) f[i][j]=max(f[i-1][j],f[i][j-v[i]]+w[i]);
                else f[i][j]=f[i-1][j];
                
    printf("%d\n",f[n][m]);
    
    return 0;
}

然后优化成一维的

f[i,j] =max(f[i-1,j],f[i,j-v[i]]+w[i])
可以发现和01背包的区别在于f[i,j-v[i]+w[i]]

在01背包里，我们倒着遍历是为了避免出现这种情况，所以现在是这种情况，只要顺着来就可以了

#include<iostream>
using namespace std;

const int N=1010;
int f[N],w[N],v[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d",&v[i],&w[i]);
    
    for(int i=1;i<=n;i++)
        for(int j=v[i];j<=m;j++)
            f[j]=max(f[j],f[j-v[i]]+w[i]);
    
    printf("%d\n",f[m]);
    return 0;    
}

时间复杂度O(nm)

多重背包
区别于完全背包，他在物品的数量上给出了限制,规定了最多能有几个。

其实这个也可以就用一开始上面的完全背包的代码，加上一个
k<=min(num[i],m/v[i])

#include<iostream>
using namespace std;

const int N=1010;
int f[N][N],v[N],w[N],nums[N],n,m;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++) scanf("%d %d %d",&v[i],&w[i],&nums[i]);
    
    for(int i=1;i<=n;i++)
        for(int k=0;k<=min(nums[i],m/v[i]);k++)
            for(int j=1;j<=m;j++)
            if(j>=k*v[i]) f[i][j]=max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
    printf("%d\n",f[n][m]);
    
    return 0;
}

时间复杂度是O(n m nums)这复杂度，遇到大数据就过不了了

所以要进行优化
这里采用2进制优化

把每个物品按照物品的数量分
假设一个物品的数量为num

那么就分为
v[i] 价值为 w[i]的一个物品
2v[i] 价值为 2w[i] 的一个物品
4v[i]价值为 4w[i]的一个物品
…
num-(前面分出去的)*v[i] 价值为 num-(前面分出去的)*w[i]

现在假设物品被分成了
v[i] 价值为 w[i]的一个物品
2v[i] 价值为 2w[i] 的一个物品
4v[i]价值为 4w[i]的一个物品

然后再考虑每个物品放不放，就相当于一个2进制数上那一位是不是1
所以考虑这3件物品放不放就可以代表放1~7件第i个物品的最大价值了

所以把所有物品进行二进制拆分，看成不同的物品，然后每件物品就只要考虑放和不放，就化成了01背包问题

#include<iostream>
using namespace std;

const int N=1e6;
int f[N],w[N],v[N],n,m,cnt;

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++)
    {
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        
        int k=1;
        while(k<=c)
        {
            v[++cnt]=k*a;
            w[cnt]=k*b;
            c-=k;
            k<<=1;
        }
        
        if(c>0)
        {
            v[++cnt]=c*a;
            w[cnt]=c*b;
        }
    }
    
    for(int i=1;i<=cnt;i++)
        for(int j=m;j>=v[i];j--) f[j]=max(f[j],f[j-v[i]]+w[i]);
        
    printf("%d\n",f[m]);
    
    return 0;
}

时间复杂度O(n lognums m)

分组背包问题
有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；
输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100
输入样例
3 5
2
1 2
2 4
1
3 4
1
4 5
输出样例：
8

状态f[i,j]表示前i组放入容量为j的背包里的最大价值
每一组里面东西只有一个，或者没有

那么划分就可以按组来划分
划分为有第i组的
那么就要看放第i组那个物品价值最大
max(f[i-1,j-v[i,j]+w[i,j]…)
这里就是要遍历一遍那一组背包里的物品

没有第i组的
f[i-1,j]

最后再转成1维的

#include<iostream>
using namespace std;

const int N=110;
int v[N][N],w[N][N],n,m,f[N],num[N];

int main()
{
    scanf("%d %d",&n,&m);
    
    for(int i=1;i<=n;i++)
    {
        
        scanf("%d",&num[i]);
        
        for(int j=1;j<=num[i];j++) scanf("%d %d",&v[i][j],&w[i][j]);
    }

    for(int i=1;i<=n;i++)
        for(int j=m;j>=1;j--)
            for(int k=1;k<=num[i];k++)
                if(j>=v[i][k]) f[j]=max(f[j],f[j-v[i][k]]+w[i][k]);
            
    printf("%d\n",f[m]);
    
    return 0;
}