二维费用背包问题+空间优化(滚动数组)
2017-09-01 13:54
453 查看
题目描述:
在计算机世界,我们一直追求用最小的资源产生最大的价值。
现在,假设你可以支配m个0和n个1。同时有一些只有0和1组成的字符串。
你的任务是用这些0和1去组成这些字符串,输出最多能组成多少个字符串。每个0和1只能被使用一次。
样例输入
样例一
输入: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
输出: 4
解释: 用5个0和3个1可以至多组成4个给定字符串,分别为“10”、”0001”、”1”、”0”。
该题意可以转换为==》你有容量为m个0,n个1的背包,然后给你如何把字符串数组中的字符串放到该背包中,使得放的字符串数目尽可能地多?
然后就可以得出去状态转移方程:
dp[i][j][k]代表有j个0和k个1的背包,[b]然后把前i个串放进去该背包中,所[b]放的字符串数目的最大值[/b][/b]
dp[i][j][k] = max{ dp[i-1][j][k](不放),dp[i-1][j-v[i]][k-u[i]]([b]放) }[/b]
代码如下:
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
#define maxn 128
string s[] = { "10", "0001", "111001", "1", "0" };
int m = 5;//0的数目
int n = 3;//1的数目
int zeroNum[maxn], oneNum[maxn];
int dp[maxn][maxn][maxn];
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j < s[i].length(); j++)
{
if (s[i][j] == '1'){
oneNum[i]++;
}
else{
zeroNum[i]++;
}
}
}
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j <= m; j++)
{
for (int k = 0; k <= n; k++)
{
if (j >= zeroNum[i] && k >= oneNum[i]){
dp[i][j][k] = max(dp[i - 1][j][k], dp[i-1][j - zeroNum[i]][k - oneNum[i]] + 1);
}
else{
dp[i][j][k] = dp[i - 1][j][k];
}
}
}
}
cout << dp[5][m]
<< endl;
return 0;
}
空间优化(滚动数组):
由于前i个串的情况都是由前i-1个串推导出来的,与前1~i-2的情况没有任何的关系,这也就是无后效性(个人理解,不对求纠正),然后我们可以把这一维去掉,即状态转移方程变成:
dp[i][j][k] = max{ dp[i-1][j][k](不放),dp[i-1][j-v[i]][k-u[i]](放) } =》dp[j][k] = max{ dp[j][k](不放),dp[j-v[i]][k-u[i]](放)
}(j、k的遍历顺序要变成倒序)
[b]变成倒序的理由:因为dp[i][j][k]是由dp[i-1][j - zeroNum[i]][k - oneNum[i]]推导出来的,而不是dp[i][j - zeroNum[i]][k - oneNum[i]]
所以dp[i][j - zeroNum[i]][k - oneNum[i]]必须后于dp[i][j][k]求值才能保证dp[i][j][k]是由dp[i-1][j - zeroNum[i]][k - oneNum[i]]推导而来的[/b]
代码如下:
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
#define maxn 128
string s[] = { "10", "0001", "111001", "1", "0" };
int m = 5;//0的数目
int n = 3;//1的数目
int zeroNum[maxn], oneNum[maxn];
int dp[maxn][maxn];
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j < s[i].length(); j++)
{
if (s[i][j] == '1'){
oneNum[i]++;
}
else{
zeroNum[i]++;
}
}
}
for (int i = 1; i <= 5; i++)
{
for (int j = m; j >= zeroNum[i]; j--)
{
for (int k = n; k >= oneNum[i]; k--)
{
if (j >= zeroNum[i] && k >= oneNum[i]){
dp[j][k] = max(dp[j][k], dp[j - zeroNum[i]][k - oneNum[i]] + 1);
}
}
}
}
cout << dp[m]
<< endl;
return 0;
}
在计算机世界,我们一直追求用最小的资源产生最大的价值。
现在,假设你可以支配m个0和n个1。同时有一些只有0和1组成的字符串。
你的任务是用这些0和1去组成这些字符串,输出最多能组成多少个字符串。每个0和1只能被使用一次。
样例输入
样例一
输入: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
输出: 4
解释: 用5个0和3个1可以至多组成4个给定字符串,分别为“10”、”0001”、”1”、”0”。
该题意可以转换为==》你有容量为m个0,n个1的背包,然后给你如何把字符串数组中的字符串放到该背包中,使得放的字符串数目尽可能地多?
然后就可以得出去状态转移方程:
dp[i][j][k]代表有j个0和k个1的背包,[b]然后把前i个串放进去该背包中,所[b]放的字符串数目的最大值[/b][/b]
dp[i][j][k] = max{ dp[i-1][j][k](不放),dp[i-1][j-v[i]][k-u[i]]([b]放) }[/b]
代码如下:
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
#define maxn 128
string s[] = { "10", "0001", "111001", "1", "0" };
int m = 5;//0的数目
int n = 3;//1的数目
int zeroNum[maxn], oneNum[maxn];
int dp[maxn][maxn][maxn];
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j < s[i].length(); j++)
{
if (s[i][j] == '1'){
oneNum[i]++;
}
else{
zeroNum[i]++;
}
}
}
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j <= m; j++)
{
for (int k = 0; k <= n; k++)
{
if (j >= zeroNum[i] && k >= oneNum[i]){
dp[i][j][k] = max(dp[i - 1][j][k], dp[i-1][j - zeroNum[i]][k - oneNum[i]] + 1);
}
else{
dp[i][j][k] = dp[i - 1][j][k];
}
}
}
}
cout << dp[5][m]
<< endl;
return 0;
}
空间优化(滚动数组):
由于前i个串的情况都是由前i-1个串推导出来的,与前1~i-2的情况没有任何的关系,这也就是无后效性(个人理解,不对求纠正),然后我们可以把这一维去掉,即状态转移方程变成:
dp[i][j][k] = max{ dp[i-1][j][k](不放),dp[i-1][j-v[i]][k-u[i]](放) } =》dp[j][k] = max{ dp[j][k](不放),dp[j-v[i]][k-u[i]](放)
}(j、k的遍历顺序要变成倒序)
[b]变成倒序的理由:因为dp[i][j][k]是由dp[i-1][j - zeroNum[i]][k - oneNum[i]]推导出来的,而不是dp[i][j - zeroNum[i]][k - oneNum[i]]
所以dp[i][j - zeroNum[i]][k - oneNum[i]]必须后于dp[i][j][k]求值才能保证dp[i][j][k]是由dp[i-1][j - zeroNum[i]][k - oneNum[i]]推导而来的[/b]
代码如下:
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
#define maxn 128
string s[] = { "10", "0001", "111001", "1", "0" };
int m = 5;//0的数目
int n = 3;//1的数目
int zeroNum[maxn], oneNum[maxn];
int dp[maxn][maxn];
int main()
{
for (int i = 1; i <= 5; i++)
{
for (int j = 0; j < s[i].length(); j++)
{
if (s[i][j] == '1'){
oneNum[i]++;
}
else{
zeroNum[i]++;
}
}
}
for (int i = 1; i <= 5; i++)
{
for (int j = m; j >= zeroNum[i]; j--)
{
for (int k = n; k >= oneNum[i]; k--)
{
if (j >= zeroNum[i] && k >= oneNum[i]){
dp[j][k] = max(dp[j][k], dp[j - zeroNum[i]][k - oneNum[i]] + 1);
}
}
}
}
cout << dp[m]
<< endl;
return 0;
}
相关文章推荐
- hdu 2152 Fruit 【分组背包解母函数——滚动数组优化陷阱问题】
- 01背包问题(当有的背包重量是非整数时)的递归(优化成动态规划+再用滚动数组优化)解法+一些动态规划(递归,搜索)的高级技巧
- HDU 2602 Bone Collector(01二维背包&一维背包&滚动数组优化二维背包的原理 )
- 01背包空间优化的形式(滚动数组)(2955)
- 背包九讲之五(二维费用的背包问题)
- HDU-2159 FATE(二维费用背包问题)
- 0-1背包使用滚动数组压缩空间
- hdu2159—FATE(二维费用的背包问题)
- P05: 二维费用的背包问题
- 背包问题及其空间优化
- HDU 2159 二维费用背包问题
- emmmmm......滚动数组和0/1背包问题的一些新体会
- 01背包问题 总结关于为什么01背包优化成1维数组后,内层循环是逆序的?
- 潜水员(二维费用的背包问题)
- hdu 3496 Watch The Movie(二维费用的背包问题)
- HDU 2159 二维费用背包问题
- 01背包问题的扩展——二维费用 LeetCode 474
- 知识点:01背包(多种姿势:二维实现+一维实现+滚动数组实现+背包装满+输出最优方案)
- 二维费用的背包问题
- P05: 二维费用的背包问题