完全背包问题

完全背包问题

标签（空格分隔）： 算法知识文档 动态规划

---

问题描述:

一个旅行者随身携带一个背包,可以放入背包的物品有n种,每种物品的重量和价值分别是$w_i,v_i$,如果背包的最大容量限制是$b$,每种物品可以放多个,怎样选择放入背包的物品以使得背包的价值最大?不妨设上述$w_i, v_i, b$都是整数.

实例:

$n = 4, b = 10$
$v_1 = 1, v_2 = 3, v_3 = 5, v_4 = 9$
$w_1 = 2, w_2 = 3, w_3 = 4, w_4 = 7$

建模:

解是 <x1,x2,...,xn> < x 1 , x 2 , . . . , x n > <script type="math/tex" id="MathJax-Element-155"> </script>,其中 $x_i$是装入背包的第 $i$种物品个数.

目标函数:
$\max \sum_{i=1}^{n} v_ix_i$

约束条件:
$\sum_{i=1}^n x_iw_i \leq b, x_i \in N$

线性规划问题:
由线性条件约束的线性函数取最大或者最小的问题.当$x_i$的取值是正实数.

整数规划问题:
线性规划的变量$x_i$都是非负整数.在该问题中显然放入的每种物品个数都是整数个.

子问题界定和计算顺序:

子问题界定:
由参数$k$和$y$界定
$k$: 考虑对物品$1,2,3,...,k$的选择,即前$k$种物品的选择.$k \in [1, n]$

$y$: 背包总重量不超过$y, y \in [1, b]$

原始输入: $k = n, y = b.$

子问题的计算顺序:
$k = 1,2,3,...,n$
对于给定的$k$, $y = 1,2,3,...,b$

优化函数的递推方程:

$F_k(y)$:装前$k$种物品,总重不超过$y$,背包达到的最大价值.

递推方程:
$F_k(y) = \max \lbrace F_{k-1}(y), F_{k}(y - w_k)+v_k\rbrace$
自然语言描述:
将前$k$种物品装入背包总重不超过$y$获得的最大价值等于将前$k-1$种物品装入背包总重不超过$y$(也就是当前第$k$种物品不装入背包)获得的最大价值,和将前$k$种物品装入背包总重量不超过$y-w_k$获得的最大价值中的最大价值(也就是装入第$k$种物品).

$F_k(0) = 0, k \in [0, n], F_0(y) = 0, y \in [0, b]$
自然语言描述:
将前$k$种物品放入背包总重不超过0获得的最大价值是0.$k \in [0, n]$
将前0种物品放入总重不超过$y$获得的最大价值是0.$y \in [0, b]$.

$F_1(y) = \lfloor \frac{y}{w_1} \rfloor, y \in [1, b], F_k(y) = -\infty, y < 0$
自然语言描述:
将前一个物品放入背包重量不超过$y$,获得的最大价值是$\lfloor \frac{y}{w_1} \rfloor$, $y$除以$w_1$向下取整.
当$y$小于$0$的时候,最大效益设置成负无穷.因为递推方程要查找$F_{k}(y - w_k)$的值,$y - w_k$可能会小于0.

根据投资问题写递推方程:
$F_k(y) = \min_{0 \leq x_k \leq \lfloor \frac{y}{w_k} \rfloor} \lbrace F_{k-1}(y-w_kx_k)+x_kv_k \rbrace$

两个递推方程的比较:
第一种递推方程计算的时间复杂都要小.计算$F_k(y)$时间复杂度是$O(1)$,第二个计算$F_k(y)$最坏时间复杂度是$O(b)$

标记函数:
$i_k(y)$: 装前$k$种物品,总重不超过$y$,背包达到最大价值时装入物品的最大标号.

$$i_k(y) = \begin{cases} i_{k-1}(y), & \text {$F_{k-1}(y) > F_k(y-w_k)+v_k$} \\ k, & \text{ $F_{k-1}(y) \leq F_k(y-w_k)+v_k$} \end{cases}$$

$$i_1(y) = \begin{cases} 0, & \text {$y < w_1$} \\ 1, & \text{ $w_1 \leq y$} \end{cases}$$

实例:

输入:
$v_1 = 1, v_2 = 3, v_3 = 5, v_4 = 9,$
$w_1 = 2, w_2 = 3, w_3 = 4, w_4 = 7$
$b = 10$

计算:
$F_k(y)的计算表如下:$

k/y	1	2	3	4	5	6	7	8	9	10
0	0	0	0	0	0	0	0	0	0	0
1	0	1	1	2	2	3	3	4	4	5
2	0	1	3	3	4	6	6	7	9	9
3	0	1	3	5	5	6	8	10	10	11
4	0	1	3	5	5	6	9	10	10	12

追踪解:

k/y	1	2	3	4	5	6	7	8	9	10
0	0	0	0	0	0	0	0	0	0	0
1	0	1	1	1	1	1	1	1	1	1
2	0	1	2	2	2	2	2	2	2	2
3	0	1	2	3	3	3	3	3	3	3
4	0	1	2	3	3	3	4	3	4	4

$i_4(10) = 4 => 1 \leq x_4$
$i_4(10 - w_4) = i_4(3) = 2 => 1 \leq x_2, x_4 = 1, x_3 = 0$
$i_2(3-w_2) = i_2(0) = 0 => x_2 = 1, x_1 = 0$

第一个: 装入$0$个
第二个: 装入$1$个
第三个: 装入$0$个
第四个: 装入$1$个

总的重量: 10
总的最大价值: 12

算法时间复杂度:$O(nb)$

$$\begin{array}{|rrrrrrrr|} \hline & \color{red}{CODE:}& \hline \end{array}$$

#include <bits/stdc++.h>

using namespace std;

#define MAX_D 100005 // 最大背包容量
#define MAX_N 105 // 最大物品数目
int w[MAX_N], v[MAX_N], F[MAX_D]; // 节省空间的做法
int n,b; // 物品数目,背包容量

void printAns(){
    for(int i = 0; i <= b; i++){
        printf("%d\t", F[i]);
    }
    printf("\n");
}

void solve(){
    int i,j;
    memset(F, 0, sizeof(int)*(b+1));
    for(i = 1; i <= n; i++){ // 前i个物品
        for(j = w[i]; j <= b; j++){ // 放入背包容量不超过j 
            F[j] = max(F[j], F[j - w[i]]+v[i]);
        }
        printAns();
    }
    printf("%d\n", F[b]);
}

int main(){
    freopen("in.txt", "r", stdin);
    int i;
    while(~scanf("%d%d", &n, &b) && n && b){
        for(i = 1; i <= n; i++) scanf("%d%d", &w[i], &v[i]); // 输入重量和价值
        solve();
    }
    return 0;
}

输入:
4 10
2 1
3 3
4 5
7 9

输出:
0 0 1 1 2 2 3 3 4 4 5
0 0 1 3 3 4 6 6 7 9 9
0 0 1 3 5 5 6 8 10 10 11
0 0 1 3 5 5 6 9 10 10 12
12

实战题目:Investment

Investment
Time Limit: 1000MS Memory Limit: 30000K
Total Submissions: 11595 Accepted: 4038

Description

John never knew he had a grand-uncle, until he received the notary’s letter. He learned that his late grand-uncle had gathered a lot of money, somewhere in South-America, and that John was the only inheritor.
John did not need that much money for the moment. But he realized that it would be a good idea to store this capital in a safe place, and have it grow until he decided to retire. The bank convinced him that a certain kind of bond was interesting for him.
This kind of bond has a fixed value, and gives a fixed amount of yearly interest, payed to the owner at the end of each year. The bond has no fixed term. Bonds are available in different sizes. The larger ones usually give a better interest. Soon John realized that the optimal set of bonds to buy was not trivial to figure out. Moreover, after a few years his capital would have grown, and the schedule had to be re-evaluated.
Assume the following bonds are available:
Value Annual
interest
4000 400
3000 250

With a capital of e10 000 one could buy two bonds of $4 000, giving a yearly interest of$800. Buying two bonds of $3 000, and one of$4 000 is a better idea, as it gives a yearly interest of $900. After two years the capital has grown to$11 800, and it makes sense to sell a $3 000 one and buy a$4 000 one, so the annual interest grows to $1 050. This is where this story grows unlikely: the bank does not charge for buying and selling bonds. Next year the total sum is$12 850, which allows for three times $4 000, giving a yearly interest of$1 200.
Here is your problem: given an amount to begin with, a number of years, and a set of bonds with their values and interests, find out how big the amount may grow in the given period, using the best schedule for buying and selling bonds.

Input

The first line contains a single positive integer N which is the number of test cases. The test cases follow.
The first line of a test case contains two positive integers: the amount to start with (at most $1 000 000), and the number of years the capital may grow (at most 40). The following line contains a single number: the number d (1 <= d <= 10) of available bonds. The next d lines each contain the description of a bond. The description of a bond consists of two positive integers: the value of the bond, and the yearly interest for that bond. The value of a bond is always a multiple of$1 000. The interest of a bond is never more than 10% of its value.

Output

For each test case, output – on a separate line – the capital at the end of the period, after an optimal schedule of buying and selling.

Sample Input

1
10000 4
2
4000 400
3000 250

Sample Output

14050

Source

Northwestern Europe 2004

题目分析:

题目大意:
有$t$个测试样例,一开始有 $m_0$ 的资金,有 $d$ 种债劵,第 $i$ 债劵的价值是 $w_i$ ,利息是 $v_i$ ,求通过买债劵投资 $y$ 年后得到的最大收益( $y$ 年后有的钱).

样例计算说明:
最开始: 有$m_0 = 10000$元钱,购买一个$w_1 = 4000$两个$w_2 = 3000$的债劵( $m$ 刚好足够买),此时利息是
$r_0 = v_1 + 2v_2 = 400 + 2*250 = 900$元.

第一年: 有 $m_1 = m_0+r_0 = 10900$元,今年也继续按照上一年的方案购买债劵得到利息:$r_1 = r_0 = 900$元

第二年: 有 $m_2 = m_1 + r_1 = 11800$元,今年的购买方案是:买两个$w_1 = 4000$, 买一个 $w_ 2 = 3000$, 需要$11000$元,是可以购买的,此时利息$r_2 = 2v_1 + v_2 = 2*400+250 = 1050$元.

第三年: 有$m_3 = m_2 + r_2 = 12850$元,今年的购买方案是:买三个$w_1 = 4000$,需要$12000$元,显然是够的.此时$r_3 = 3*400 = 1200$元.

第四年: 有$m_4 = m_3 + r_3 = 12850+1200 = 14050$元,就是输出的结果.

样例计算总结:
通过计算样例我们不难发现,每一次得到购买债劵的最优方案使得利息最大就可以得到每一年的最大收益.而得到最优方案的过程就是一个完全背包的模型.

题目难点:
将数据缩小

轻松ACCEPT:

$$\begin{array}{|rrrrrrrr|} \hline & \color{red}{CODE:}& \hline \end{array}$$

// http://poj.org/problem?id=2063
#include <cstdio>
#include <cstring>

#define MAX_D 15
#define K1 1000
#define max(a, b) a > b ? a : b;
const int MAX_M = 1e6+5;
int t,y,d,m;
int a,b;
int w[MAX_D],v[MAX_D],F[MAX_M];

void solve(){
    int i,j,_y;
    memset(F, 0, sizeof(F));
    for(_y = 1; _y <= y; _y++){ // 年份
        for(i = 1; i <= d; i++){ // 债劵种类
            for(j = w[i]; j <= a; j++){ // 完全背包
                F[j] = max(F[j], F[ j-w[i] ] + v[i]);
            }
        }
        m += F[a]; // 加上
        a = m/K1; // 缩小数据
    }
    printf("%d\n", m);
}

int main(){
    //freopen("in.txt", "r", stdin);
    int i;
    scanf("%d", &t); // 输入测试样例种数
    while(t--) {
        scanf("%d%d%d", &m, &y, &d); // 输入初始资金,年数,债劵种数
        a = m/K1; // 将数据缩小
        for(i = 1; i <= d; i++)  {
            scanf("%d%d", &w[i], &v[i]);
            w[i] /= K1; // 将数据缩小
        }
        solve();
    }
    return 0;
}