AcWing刷题笔记（五）动态规划

动态规划

背包问题

背包问题详细解答

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

方法一：二维暴力解题法：
1、定义：f[i][j]表示只看前i个物品，总体积是j的情况下，总价值是多少。
result=max{f[n][0~V]}
2、思路：
(1)不选第i个物品，f[i][j]=f[i-1][j];
(2)选第i个物品，f[i][j]=f[i-1][j-v[i]];
(3)f[i][j]=max{(1),(2)}
3、初始化：f[0][0]=0;

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int n,m;
int f[N][N];
int w[N],v[N];

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;++i) cin>>w[i]>>v[i];
	for(int i=1;i<=n;++i)
		for(int j=0;j<=m;++j)
		{
			f[i][j]=f[i-1][j];
			if(j>=w[i])
				f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]);
		}
	int res=0;
	for(int i=0;i<=m;++i) res=max(res,f[n][i]);
	cout<<res<<endl;
	return 0;
}

方法二：一维优化解法

#include <bits/stdc++.h>
using namespace std;

const int N=1010;

int n,m;
int f[N][N];
int w[N],v[N];

int main()
{
	cin>>n>>m;
	for(int i=1;i<=n;++i) cin>>w[N]>>v[N];
	for(int i=1;i<=n;++i)
		for(int j=m;j>=w[N];--j)
			f[j]=max(f[j],f[j-w[i]]+v[i]);
	cout<<f[m]<<endl;
	return 0;
}

完全背包问题

有 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

输出样例：

10

方法一：朴素解法：
状态表示：f(i,j)
集合：所有只从前i个物品中选，总体积不会超过j的方案的集合。
属性：max
状态计算：
（1）不选第i个：f(i-1,j)
（2）选k个第i个：f(i-1,j-kwi)
f(i,j)=max(f(i-1,j) , f(i-1,j-wi)+vi , f(i-1,j-2wi)+2*vi , … , f(i-1,j-kwi)+kvi)
又因为 f(i,j-wi)=max( f(i-1,j-wi) , f(i-1,j-2wi)+vi , … f(i-1,j-kwi)+(k-1)vi )
就是把j完全切换成j-wi，发现f(i,j-wi)就是f(i,j)后面部分，因此可以变成
f(i,j)=max(f(i-1,j),f(i,j-wi)+vi)
优化：由于j是从小到大增加，所以f(i,j-wi)一定比f(i-1,j)先计算，但是使用得是上一层和f(i,j-wi)使用本层不冲突，因此等价于f(j),f(j-wi)+vi

#include <iostream>
#include <algorithm>
using namespace std;

const int N=1010;

int n,m;
int w[N],v[N];
int f[N][N];

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;++i) cin>>w[i]>>v[i];
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
        {
            f[i][j]=f[i-1][j];
            if(j>=w[i])
                f[i][j]=max(f[i][j],f[i][j-w[i]]+v[i]);
        }
    cout<<f[n][m]<<endl;
    return 0;
}

方法二：一维优化

#include <iostream>
#include <algorithm>
using namespace std;

const int N=1010;

int n,m;
int w[N],v[N];
int f[N];

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

线性DP

数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

输入格式
第一行包含整数 n，表示数字三角形的层数。接下来 n行，每行包含若干整数，其中第 i 行表示数字三角形第 i层包含的整数。

输出格式
输出一个整数，表示最大的路径数字和。
数据范围
1≤n≤500,
−10000≤三角形中的整数≤10000

输入样例：

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出样例：

30

分析思路：
状态表示：f[i][j]

集合：f[i][j]表示从底向上走到(i,j)所有路线的集合
属性：max（一般包括最大值、最小值和数量）

状态计算：

自下向上分析：当前路径的值为左下和上右下中的最大值以及自己值的和，不用考虑边界值问题，因为下面的总比上面的多。最终值为f[1][1]
自上向下分析：当前路径的值为左上和右上中的最大值以及自己值的和，需要考虑边界问题，因为上面的比下面的少。最终值为最后一行中的最大值。

方法一、自上向下的方法

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N=510,INF=1e9;
int n;
int a[N][N],f[N][N];

int main()
{
	cin>>n;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=i;++j)
			scanf("%d",&a[i][j]);
	for(int i=0;i<=n;++i)
		for(int j=0;j<=n+1;++i)
			f[i][j]=-INF;
	f[1][1]=a[1][1];
	for(int i=2;i<=n;++i)
		for(int j=1;j<=i;++j)
			f[i][j]=max(f[i-1][j-1]+a[i][j],f[i-1][j]+a[i][j]);
	int res=-INF;
	for(int i=1;i<=n;++i) res=max(res,f[n][i]);
	
	cout<<res<<endl;
	return 0;
}

方法二、自下向上的方法

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int const N=510;
int n;
int a[N][N],f[N][N];

int main()
{
	cin>>n;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=i;++j)
			scanf("%d",&a[i][j]);
	for(int i=i;i<=n;++i) f[n][i]=a[n][i];
	for(int i=n-1;i;--i)
		for(int j=1;j<=i;++j)
			f[i][j]=max(f[i+1][j]+a[i][j],f[i+1][j+1]+a[i][j]);
	cout<<f[1][1]<<endl;
	return 0;
}

//优化代码
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

int const N=510;
int n;
int a[N][N],f[N][N];

int main()
{
	cin>>n;
	for(int i=1;i<=n;++i)
		for(int j=1;j<=i;++j)
			scanf("%d",&f[i][j]);
	for(int i=n-1;i;--i)
		for(int j=1;j<=i;++j)
			f[i][j]=max(f[i+1][j],f[i+1][j+1]);
	cout<<f[1][1]<<endl;
	return 0;
}