动态规划之01背包，完全背包，多重背包模板

最新推荐文章于 2024-06-21 11:01:18 发布

原创最新推荐文章于 2024-06-21 11:01:18 发布 · 522 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划

算法小记专栏收录该内容

3 篇文章

订阅专栏

本文详述了动态规划在解决01背包、完全背包和多重背包问题中的应用，提供了一套完整的模板，便于理解和记忆。通过实例解析，帮助读者掌握如何运用动态规划解决这类问题。

自己整理的模板，记录一下：

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>

using namespace std;

const int M = 500;
const int N = 500;

#pragma region"01背包问题"
// 未优化版
int pack01(vector<int>& weight, vector<int>& value, int sum, int n)
{
    int dp[M][N];
    for (int i = 0; i <= sum; ++i)
    {
        dp[0][i] = i >= weight[0] ? value[0] : 0;
    }
    for (int i = 1; i < n; ++i)
    {
        for (int v = weight[i]; v <= sum; ++v)
        {
            dp[i][v] = max(dp[i - 1][v], dp[i - 1][v - weight[i]] + value[i]);
        }
    }
    return dp[n - 1][sum];
}

// 空间优化版（滚动数组）
int pack01optimize(vector<int>& weight, vector<int>& value, int sum, int n)
{
    int dp[N];
    for (int i = 0; i <= sum; ++i)
    {
        dp[i] = i >= weight[0] ? value[0] : 0;
    }
    for (int i = 1; i < n; ++i)
    {
        for (int v = sum; v >= weight[i]; --v)
        {
            dp[v] = max(dp[v], dp[v - weight[i]] + value[i]);
        }
    }
    return dp[sum];
}

#pragma endregion

#pragma region"完全背包问题"
// 完全背包问题（每个物品可以选无数次）
int packComplete(vector<int>& weight, vector<int>& value, int sum, int n)
{
    int dp[N];
    for (int i = 0; i <= sum; ++i)
    {
        dp[i] = i >= weight[0] ? (dp[i - weight[0]] + value[0]) : 0;
    }
    for (int i = 1; i < n; ++i)
    {
        for (int v = weight[i]; v <= sum; ++v) // 和01背包的区别
        {
            dp[v] = max(dp[v], dp[v - weight[i]] + value[i]);
        }
    }
    return dp[sum];
}
#pragma endregion

#pragma region"多重背包"
#pragma region"二进制优化版"
void oneZeroPack(int dp[], int sum, int weight, int value)
{
    for (int i = sum; i >= weight; --i)
    {
        dp[i] = max(dp[i], dp[i - weight] + value);
    }
}

void completePack(int dp[], int sum, int weight, int value)
{
    for (int i = weight; i <= sum; ++i)
    {
        dp[i] = max(dp[i], dp[i - weight] + value);
    }
}
// 把每个物体分成1， 2， 4 ..., 2^(k - 1), cnt - 2^k + 1个，然后转变成01背包问题，其中k为满足cnt - 2^k + 1 > 0的最大整数
int MultiPack(vector<int>& weight, vector<int>& value, vector<int>& cnt, int sum, int n)
{
    int dp[N] = {};
    for (int i = 0; i < n; ++i)
    {
        if (weight[i] * cnt[i] >= sum)
        {
            completePack(dp, sum, weight[i], value[i]);
        }
        else
        {
            int k = 1;
            for (k = 1; k <= cnt[i]; k <<= 1)
            {
                oneZeroPack(dp, sum, weight[i], value[i]);
                cnt[i] -= k;
            }
            if (cnt[i])
            {
                oneZeroPack(dp, sum, weight[i], value[i]);
            }
        }
    }
    return dp[sum];
}
#pragma endregion

#pragma region"单调队列版"
struct Pack
{
    int num, value;
    Pack(int _num, int _value) : num(_num), value(_value)
    {
    }
};
deque<Pack> q;
int multiPackQueue(vector<int>& weight, vector<int>& value, vector<int>& cnt, int sum, int n)
{
    int dp[N];
    for (int i = 0; i < n; ++i)
    {
        if (cnt[i] > (sum / weight[i])) cnt[i] = sum / weight[i];
        for (int d = 0; d < weight[i]; ++d)
        {
            q.clear();
            for (int j = 0; j <= (sum - d) / weight[i]; ++j)
            {
                int tValue = dp[d + j * weight[i]] - j * value[i];
                while (!q.empty() && q.back().value <= tValue) q.pop_back();
                q.push_back(Pack(j, tValue));
                while (!q.empty() && q.front().num < j - cnt[i]) q.pop_front();
                dp[d + j * weight[i]] = q.front().value + j * value[i];
            }
        }
    }
    return dp[sum];
}

#pragma endregion
#pragma endregion