三种背包的模板

01：http://www.ahathinking.com/archives/95.html

0-1背包

2012年4月30日Yx.Ac发表评论阅读评论

文章作者：Yx.Ac   文章来源：勇幸|Thinking (http://www.ahathinking.com)   转载请注明，谢谢合作。

---

四月份还没写，不能这么荒废了呀，赶紧水一篇吧，哈哈。前些日子回顾了DP的一些基础，就做一下整理吧，从0-1背包开始。

本节回顾0-1背包的基本模型，关于它的实现有很多种写法，这里对不同实现做个简单列举，主要是写代码练手了，主要有以下几方面内容：

==0-1背包问题定义 & 基本实现

==0-1背包使用滚动数组压缩空间

==0-1背包使用一维数组

==0-1背包恰好背满

==0-1背包输出最优方案

========================================

0-1背包问题定义 & 基本实现

问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的物品，每种物品只有一个，想计算一下最多能放多少价值的货物。

DP的关键也是难点是找到最优子结构和重叠子问题，进而找到状态转移方程，编码就相对容易些。最优子结构保证每个状态是最优的，重叠子问题也即n状态的求法和n-1状态的求法是一样的；DP在实现上一般是根据状态转移方程自底向上的迭代求得最优解（也可以使用递归自顶向下求解）。

回到0-1背包，每个物体i，对应着两种状态：放入&不放入背包。背包的最优解是在面对每个物体时选择能够最大化背包价值的状态。0-1背包的状态转移方程为


1

f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }

f(i,v)表示前i个物体面对容量为v时背包的最大价值，c[i]代表物体i的cost(即重量)，w[i]代表物体i的价值；如果第i个物体不放入背包，则背包的最大价值等于前i-1个物体面对容量v的最大价值；如果第i个物体选择放入，则背包的最大价值等于前i-1个物体面对容量v-cost[i]的最大价值加上物体i的价值w[i]。

对于实现，一般采用一个二维数组（状态转移矩阵）dp[i][j]来记录各个子问题的最优状态，其中dp[i][j]表示前i个物体面对容量j背包的最大价值。

下面给出0-1背包的基本实现，时间复杂度为O(N*V)，空间复杂度也为O(N*V)，初始化的合法状态很重要，对于第一个物体即f[0][j]，如果容量j小于第一个物体（编号为0）的重量，则背包的最大价值为0，如果容量j大于第一个物体的重量，则背包最大价值便为该物体的价值。为了能单步验证每个状态的最优解，程序最后将状态转移矩阵的有效部分输出到了文件。

代码如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

#include <iostream>

using namespace std;

/* 0-1背包 版本1

 * Time Complexity  O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }

 */

int maxValue[11][201]; /* 前i个物体面对容量j的最大价值，即子问题最优解 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 0; i < N; ++i)

    {

        for(j = 0; j <= V; ++j) /* 容量为V 等号 */

        {

            if(i > 0)

            {

                maxValue[i][j] = maxValue[i-1][j];

                if(j >= weight[i]) /* 等号 */

                {

                    int tmp = maxValue[i-1][j-weight[i]] + value[i];

                    maxValue[i][j] = ( tmp > maxValue[i][j]) ? tmp : maxValue[i][j];

                }

            }else   /* 数组第0行赋值 */

            {

                if(j >= weight[0])

                    maxValue[0][j] = value[0];

            }

        }

    }

    printf("%d",maxValue[N-1][V]);

    /* 重定向输出结果到文件 */

    freopen("C:\\dp.txt","w",stdout);

    for(i = 0; i <= N; ++i)

    {

        for(j = 0; j <= V; ++j)

        {

            printf("%d   ",maxValue[i][j]);

        }

        printf("\n");

    }

}

测试用例：


1

2

3

4

5

6

7

10 3

3 4

4 6

5 7

程序输出的状态转移矩阵如下图，第一行表示第1个物体对于容量0至V时的最优解，即背包最大价值。该实现方法是0-1背包最基本的思想，追踪状态转移矩阵有助于加深理解，POJ上单纯的0-1背包题目也有不少，如3624等，可以水一下，加深理解。

========================================

0-1背包使用滚动数组压缩空间

所谓滚动数组，目的在于优化空间，从上面的解法我们可以看到，状态转移矩阵使用的是一个N*V的数组，在求解的过程中，我们可以发现，当前状态只与前一状态的解有关，那么之前存储的状态信息已经无用了，可以舍弃的，我们只需要空间存储当前的状态和前一状态，所以只需使用2*V的空间，循环滚动使用，就可以达到跟N*V一样的效果。这是一个非常大的空间优化。

代码如下，我们可以在每轮内循环结束后输出当前状态的解，与上面使用二维数组输出的状态转移矩阵对比，会发现是一样的效果，重定向输出到文本有助加深理解。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

#include <iostream>

using namespace std;

/* 0-1背包 版本2

 * Time Complexity  O(N*V)

 * Space Complexity O(2*V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }

 */

int maxValue[2][201]; /* 前i个物体面对容量j的最大价值，即子问题最优解 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j, k;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 0; i < N; ++i)

    {

        for(j = 0; j <= V; ++j) /* 容量为V 等号 */

        {

            if(i > 0)

            {

                k = i & 1;    /* i%2 获得滚动数组当前索引 k */

                maxValue[k][j] = maxValue[k^1][j];

                if(j >= weight[i]) /* 等号 */

                {

                    int tmp = maxValue[k^1][j-weight[i]] + value[i];

                    maxValue[k][j] = ( tmp > maxValue[k][j]) ? tmp : maxValue[k][j];

                }

            }else   /* 数组第0行赋值 */

            {

                if(j >= weight[0])

                    maxValue[0][j] = value[0];

            }

        }

    }

    printf("%d",maxValue[k][V]);

    /* 重定向输出结果到文件 */

    freopen("C:\\dp.txt","w",stdout);

    for(i = 0; i <= 1; ++i)

    {

        for(j = 0; j <= V; ++j)

        {

            printf("%d ",maxValue[i][j]);

        }

        printf("\n");

    }

}

这种空间循环滚动使用的思想很有意思，类似的，大家熟悉的斐波那契数列，f(n) = f(n-1) + f(n-2)，如果要求解f(1000)，是不需要申请1000个大小的数组的，使用滚动数组只需申请3个空间f[3]就可以完成任务。

========================================

0-1背包使用一维数组

使用滚动数组将空间优化到了2*V，在背包九讲中提到了使用一维数组也可以达到同样的效果，个人认为这也是滚动思想的一种，由于使用一维数组解01背包会被多次用到，完全背包的一种优化实现方式也是使用一维数组，所以我们有必要理解这种方法。

如果只使用一维数组f[0…v]，我们要达到的效果是：第i次循环结束后f[v]中所表示的就是使用二维数组时的f[i][v]，即前i个物体面对容量v时的最大价值。我们知道f[v]是由两个状态得来的，f[i-1][v]和f[i-1][v-c[i]]，使用一维数组时，当第i次循环之前时，f[v]实际上就是f[i-1][v]，那么怎么得到第二个子问题的值呢？事实上，如果在每次循环中我们以v=v…0的顺序推f[v]时，就能保证f[v-c[i]]存储的是f[i-1][v-c[i]]的状态。状态转移方程为：


1

v = V...0; f(v) = max{ f(v), f(v-c[i])+w[i] }

我们可以与二维数组的状态转移方程对比一下


1

f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }

正如我们上面所说，f[v-c[i]]就相当于原来f[i-1][v-c[i]]的状态。如果将v的循环顺序由逆序改为顺序的话，就不是01背包了，就变成完全背包了，这个后面说。这里举一个例子理解为何顺序就不是01背包了

假设有物体z容量2，价值vz很大，背包容量为5，如果v的循环顺序不是逆序，那么外层循环跑到物体z时，内循环在v=2时，物体z被放入背包，当v=4时，寻求最大价值，物体z放入背包，f[4]=max{f[4],f[2]+vz}，这里毫无疑问后者最大，那么此时f[2]+vz中的f[2]已经装入了一次物体z，这样一来该物体被装入背包两次了就，不符合要求，如果逆序循环v，这一问题便解决了。

代码如下，为了加深理解，可以在内循环结束输出每一个状态的情况到文本中，会发现与使用二维数组时的状态转移矩阵都是一样一样的。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

#include <iostream>

using namespace std;

/* 0-1背包 版本3

 * Time Complexity  O(N*V)

 * Space Complexity O(V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：v = V...0; f(v) = max{ f(v), f(v-c[i])+w[i] }

 */

int maxV[201];    /* 记录前i个物品中容量v时的最大价值 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    /*

     * 对于第i轮循环

     * 求出了前i个物品中面对容量为v的最大价值

    */

    for(i = 0; i < N; ++i)

    {

        /*

         * 内循环实际上讲maxV[0...v]滚动覆盖前一轮的maxV[0...V]

         * 可输出对照使用二维数组时的情况

         * j从V至0逆序是防止有的物品放入背包多次

        */

        for(j = V; j >= weight[i]; --j)   /* weight > j 的物品不会影响状态f[0,weight[i-1]]  */

        {

            int tmp = maxV[j-weight[i]]+value[i];

            maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;

        }

    }

    printf("%d",maxV[V]);

}

可以看出，使用一维数组，代码非常简练。

========================================

0-1背包恰好背满

在01背包中，有时问到“恰好装满背包”时的最大价值，与不要求装满背包的区别就是在初始化的时候，其实对于没有要求必须装满背包的情况下，初始化最大价值都为0，是不存在非法状态的，所有的都是合法状态，因为可以什么都不装，这个解就是0，但是如果要求恰好装满，则必须区别初始化，除了f[0]=0,其他的f[1…v]均设为-∞或者一个比较大的负数来表示该状态是非法的。

这样的初始化能够保证，如果子问题的状态是合法的（恰好装满），那么才能得到合法的状态；如果子问题状态是非法的，则当前问题的状态依然非法，即不存在恰好装满的情况。

代码如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

#include <iostream>

using namespace std;

int maxV[201];    /* 记录前i个物品中容量v时的最大价值 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 1; i <= V; ++i)  /* 初始化非法状态 */

    {

        maxV[i] = -100;

    }

    for(i = 0; i < N; ++i)

    {

        for(j = V; j >= weight[i]; --j)

        {

            int tmp = maxV[j-weight[i]]+value[i];

            maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;

        }

    }

}

为了加深理解，输出每轮循环的状态矩阵如下，对照每个物体的情况，就会理解为什么做那样的初始化了。

========================================

0-1背包输出最优方案

一般来讲，背包问题都是求一个最优值，但是如果要求输出得到这个最优值的方案，就可以根据状态转移方程往后推，由这一状态找到上一状态，依次向前推即可。

这样就可以有两种实现方式，一种是直接根据状态转移矩阵向前推，另一种就是使用额外一个状态矩阵记录最优方案的路径，道理都是一样的。当然也可以使用一维数组，代码更为简练，这里不罗列，相关代码可以到这里下载。

代码如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

#include <iostream>

using namespace std;

/* 0-1背包 输出最优方案 2 直接根据状态数组算

 * Time Complexity  O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：f(i,v) = max{ f(i-1,v), f(i-1,v-c[i])+w[i] }

 */

int maxValue[11][201]; /* 记录子问题最优解 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 0; i < N; ++i)

    {

        for(j = 0; j <= V; ++j)

        {

            if(i > 0)

            {

                maxValue[i][j] = maxValue[i-1][j];

                if(j >= weight[i])

                {

                    int tmp = maxValue[i-1][j-weight[i]] + value[i];

                    maxValue[i][j] = ( tmp > maxValue[i][j]) ? tmp : maxValue[i][j];

                }

            }else

            {

                if(j >= weight[0])

                    maxValue[0][j] = value[0];

            }

        }

    }

    printf("%d\n",maxValue[N-1][V]);

    i = N-1;

    j = V;

    while(i >= 0)

    {

        if(maxValue[i][j] == maxValue[i-1][j-weight[i]] + value[i])

        {

            printf("%d ",i);

            j = j - weight[i];

        }

        --i;

    }

}

01背包是背包问题的基础，加深理解的最好方式就是动手写一下，然后对照最终的状态转移矩阵一一比对。

本文相关代码可以到这里下载。

（全文完）

参考资料：背包问题九讲 http://love-oriented.com/pack/

分类:算法 数据结构标签:0/1背包, 01背包一维数组, 01背包恰好背满, DP, DP输出最优方案, POJ, 动态规划, 滚动数组, 背包

完全:http://www.ahathinking.com/archives/108.html

完全背包

2012年6月11日Yx.Ac发表评论阅读评论

文章作者：Yx.Ac   文章来源：勇幸|Thinking (http://www.ahathinking.com)   转载请注明，谢谢合作。

---

前面回顾了01背包，在此基础上本节回顾完全背包的几种实现形式，主要有以下几方面内容：

==完全背包问题定义 & 基本实现

==完全背包二进制拆分思想

==完全背包使用滚动数组（略）

==完全背包中的逆向思维

==完全背包使用一维数组

========================================

完全背包问题定义 & 基本实现

问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的货物，每种物品有无限件可用，想计算一下最多能放多少价值的货物。

与01背包不同的是，完全背包每件物体可以放入无限件（只要能放的下），故对于每件物品i，相当于拆分成了v/c[i]件相同的物品，拆分之后物品i就不是放入或不放入的两种情况了，而是放入0件、放入1件、放入2件…等情况了，对于该件物品i，最大价值取放入k件的最大值，故状态转移方程为：


1

f(i,v) = max{ f(i-1,v-k*c[i]) + k*w[i] | 0<=k<=v/c[i] }

各状态的意义不再赘述，上代码，关于复杂度以及每种物品的状态数见代码注释：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

#include <iostream>

using namespace std;

/* 完全背包 版本1

 * Time Complexity  大于O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：f(i,v) = max{ f(i-1,v-k*c[i]) + k*w[i] | 0<=k<=v/c[i]  }

 * 每件物品有v/c[i]种状态

 */

int maxV[11][201];    /* 记录子问题最优解，物品可重复 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j, k;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 0; i < N; ++i)

    {

        for(j = 0; j <= V; ++j)

        {

            if(i > 0)

            {

                maxV[i][j] = maxV[i-1][j];

                if(j/weight[i] >= 1)

                {

                    int max_tmp = 0;

                    for(k = 1; k <= j/weight[i]; ++k)//正是因为加了i-1这一个限制条件，所以用二维数组做的完全背包必须再加一重k循环，因为有了i-1这个限制，所以不可能访问到本次也就是第i次循环的数据

                    {

                        if(maxV[i-1][j-k*weight[i]] + k*value[i] > max_tmp)

                        {

                            max_tmp = maxV[i-1][j-k*weight[i]] + k*value[i];

                        }

                    }

                    maxV[i][j] = maxV[i][j] > max_tmp ? maxV[i][j] : max_tmp;

                }

            }else

            {

                if(j/weight[0] >= 1)

                {

                    maxV[0][j] = j/weight[0] * value[0];

                }

            }

        }

    }

    printf("%d",maxV[N-1][V]);

}

========================================

完全背包二进制拆分思想

这种实现方式是对完全背包的基本实现做了一个优化，叫“二进制拆分”。所谓“拆分物体”就是将一种无限件物品拆分成有效的几件物品，拆分物体的目的是通过减少物品个数来降低复杂度。

在完全背包中，每种物品i对于容量v来讲实际上相当于有v/c[i]件，故在上述的基本实现中，k就要循环测试v/c[i]次。

这里的拆分是利用了一种二进制思想：即任何数字都可以表示成若干个2^k数字的和，例如7可以用1+2+2^2表示；这很好理解，因为任何正数都可以转成二进制，二进制就是若干个“1”（2的幂数）之和。

所以不管最优策略选择几件物品i，我们都可以将物品i拆成费用为c[i]*2^k，价值为w[i]*2^k的若干件物品。这样物品的状态数就降为了log(v/c[i])，是很大的改进。

在代码实现上，与基本实现的差别很小，区别如下


1

2

3

4

5

6

7

8

9

10

11

12

13

14

/* 完全背包 版本2

 * Time Complexity  大于O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：f(i,v) = max{ f(i-1,v-2^k*c[i]) + 2^k*w[i] | 0<=k<=log v/c[i]  }

 * 每件物品降低为 log(v/c[i]) 种状态

 */

for(k = 1; k <= j/weight[i]; k <<= 1)

{

     if(maxV[i-1][j-k*weight[i]] + k*value[i] > max_tmp)

     {

          max_tmp = maxV[i-1][j-k*weight[i]] + k*value[i];

     }

}

对于使用滚动数组的实现，这里就不写了，跟01背包是一样的。

========================================

完全背包中的逆向思维

我们知道，在01背包和完全背包的实现中，都是针对每种物品进行讨论，即外循环都是for i=0…n，然后每种物品对于容量v的变化而求得最大价值；

在完全背包中，由于物品的件数无限，所以我们可以倒过来想，我们针对每个容量讨论，外循环为容量，对于每个容量j，我们求j对于所有物品能装载的最大价值，这样一来我们就能将时间复杂度降为O(N*V)了。代码如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#include <iostream>

using namespace std;

/* 完全背包 版本3

 * Time Complexity  O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10

 */

int maxValue[201][11]; /* 记录子问题的各状态 */

int weight[11];

int value[11];

int maxV[201]; /* 记录子问题的最优解 */

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 1; i <= V; ++i)

    {

        int i_maxV = 0;        /* 记录子问题i的最优解 */

        /* 每个容量求面对所有物体能装载的最大价值 */

        for(j = 0; j < N; ++j)

        {

            if(i >= weight[j])

            {

                int tmp = maxV[i-weight[j]] + value[j];

                maxValue[i][j] = maxV[i-1] > tmp ? maxV[i-1] : tmp;

            }else

            {

                maxValue[i][j] = maxV[i-1];

            }

            if(maxValue[i][j] > i_maxV)

            {

                i_maxV = maxValue[i][j];

            }

        }

        maxV[i] = i_maxV;

    }

    printf("%d",maxV[V]);

    /* 重定向输出结果到文件 */

    freopen("C:\\dp.txt","w",stdout);

    for(i = 0; i <= V; ++i)

    {

        for(j = 0; j < N; ++j)

        {

            printf("%d ",maxValue[i][j]);

        }

        printf("   %d\n",maxV[i]);

    }

}

同样，可以将状态转移矩阵重定向输出到文件进行对比，一看就明白了，这里就不贴图片了。

========================================

完全背包使用一维数组

对于01背包和完全背包，无论是空间复杂度还是时间复杂度，最优的方法还是使用一维数组进行实现。

基于01背包的分析，由于不必考虑物品的重复放入，故v的循环采用顺序即可。

能够想到用一维数组的人很聪明，因为他很巧妙地减少了一重循环，这是为什么呢，你仔细想一下，如果用一维数组，那么就没有了现在的dp数组只能访问第i-1重循环的限制，dii重循环可以访问这重循环前面计算出来的数据，也就是说，在这重（第i重）循环中，可以多次累加i物品，这样就避免了三重循环。 代码如下：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

#include <iostream>

using namespace std;

/* 完全背包 版本4

 * Time Complexity  O(N*V)

 * Space Complexity O(V)

 * 设 V <= 200 N <= 10

 * 状态转移方程：v =0...V; f(v) = max{ f(v), f(v-c[i])+w[i] }

 */

int maxV[201];    /* 记录前i个物品中容量v时的最大价值, 物品可重复 */

int weight[11];

int value[11];

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d",&weight[i],&value[i]);

    }

    for(i = 0; i < N; ++i)

    {

        for(j = weight[i]; j <= V; ++j)  /* j<weight[i]的对前面的状态不会有影响 */

        {

            int tmp = maxV[j-weight[i]]+value[i];

            maxV[j] = (maxV[j] > tmp) ? maxV[j] : tmp;

        }

    }

    printf("%d",maxV[V]);

}

========================================

PS：值得一提的是，在01背包和完全背包中，我们用到了两种思想，个人认为还是很有用的，其他地方也会用到很多，我们有必要在此留心：

  • 滚动数组压缩空间的思想
  • 二进制拆分的思想

记得有一回看到的面试题就用到了二进制拆分的思想，具体是啥忘了，以后碰到再说吧，就这样。

本文相关代码可以到这里下载。

（全文完）

参考资料：背包问题九讲 http://love-oriented.com/pack/

分类:算法 数据结构标签:一维动规, 二进制拆分, 完全背包, 滚动数组

多重：http://www.ahathinking.com/archives/109.html

多重背包

2012年6月11日Yx.Ac发表评论阅读评论

文章作者：Yx.Ac   文章来源：勇幸|Thinking (http://www.ahathinking.com)   转载请注明，谢谢合作。

---

前面已经回顾了01背包和完全背包，本节回顾多重背包的几种实现形式，主要有以下几方面内容：

==多重背包问题定义 & 基本实现

==多重背包二进制拆分实现

==防火防盗防健忘

========================================

多重背包问题定义 & 基本实现

问题：有个容量为V大小的背包，有很多不同重量weight[i](i=1..n)不同价值value[i](i=1..n)的货物，第i种物品最多有n[i]件可用，计算一下最多能放多少价值的货物。

对于多重背包的基本实现，与完全背包是基本一样的，不同就在于物品的个数上界不再是v/c[i]而是n[i]与v/c[i]中较小的那个。状态转移方程如下


1

f(i,v) = max{ f(i-1,v-k*c[i]) + k*w[i] | 0<=k<=n[i] }

代码与完全背包的区别仅在内部循环上由


1

for(k = 1; k <= j/weight[i]; ++k)

变为


1

for(k = 1; k <=n[i] && k<=j/weight[i]; ++k)

当然，输入上的区别就不说了。

========================================

多重背包二进制拆分实现

跟完全背包一样的道理，利用二进制的思想将n[i]件物品i拆分成若干件物品，目的是在0-n[i]中的任何数字都能用这若干件物品代换，另外，超过n[i]件的策略是不允许的。

方法是将物品i分成若干件，其中每一件物品都有一个系数，这件物品的费用和价值都是原来的费用和价值乘以这个系数，使得这些系数分别为1,2,4,…,2^(k-1),n[i]-2^k+1，且k满足n[i]-2^k+1>0的最大整数。例如，n[i]=13，就将该物品拆成系数为1、2、4、6的四件物品。分成的这几件物品的系数和为n[i]，表明不可能取多于n[i]件的第i种物品。另外这种方法也能保证对于0..n[i]间的每一个整数，均可以用若干个系数的和表示。

代码如下：测试用例见代码末的注释


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

#include <iostream>

using namespace std;

/* 多重背包 二进制拆分

 * Time Complexity  大于O(N*V)

 * Space Complexity O(N*V)

 * 设 V <= 200 N <= 10 ，拆分后 物品总数 < 50

 * 每件物品有 log n[i]种状态

 */

int maxV[201];

int weight[50]; /* 记录拆分后物体重量 */

int value[50];  /* 记录拆分后物体价值 */

int V, N;

void main()

{

    int i, j;

    scanf("%d %d",&V, &N);

    int weig, val, num;

    int count = 0;

    for(i = 0; i < N; ++i)

    {

        scanf("%d %d %d",&weig,&val,&num);

        for(j = 1; j <= num; j <= 1) // 二进制拆分

        {

            weight[count] = j * weig;

            value[count++] = j * val;

            num -= j;

        }

        if(num > 0)

        {

            weight[count] = num * weig;

            value[count++] = num * val;

        }

    }

    for(i = 0; i < count; ++i)  // 使用01背包

    {

        for(j = V; j >= weight[i]; --j)

        {

            int tmp = maxV[j-weight[i]] + value[i];

            maxV[j] = maxV[j] > tmp ? maxV[j] : tmp;

        }

    }

    printf("%d",maxV[V]);

}

/*

    【输入样例】

    4 20

    3     9     3

    5     9     1

    9     4     2

    8     1     3

    【输出样例】

    47

*/

========================================

简单背包基础总结：

回顾了3种简单背包后，有些思想慢慢体会，实践中，对于01背包和完全背包使用一维数组实现是最简便高效的，对于多重背包，最好就是输入时进行二进制拆分，然后使用01背包，这样比基本实现和在运算时再进行拆分要简捷的多。

防火防盗防健忘：

没事水一下：POJ  PKU：

01背包： 3211、3624、3628

完全背包：1252、1384、2063

多重背包：1014、1276、1742、2392、3260（完全+多重）

本文相关代码可以到这里下载。

（全文完）

参考资料：背包问题九讲http://love-oriented.com/pack/

分类:算法 数据结构标签:PKU, POJ, 二进制拆分, 多重背包

时间： 2024-10-04 15:53:20

三种背包的模板的相关文章

【背包问题】0-1背包、完全背包、多重背包、混合三种背包、二位费用背包、分组背包

一.0-1背包问题 输入:第一行物品的个数n,第二行背包的质量m,随后n行每行给出每个物品的重量和价值,每种物品只有一个. 输出:背包可以达到的最大价值 样例输入: 5 10 1 5 2 4 3 3 4 2 5 1 样例输出: 14 动态规划的过程中需要逆序,因为如果不是逆序那么 当i=0的时候 f[0]=0; f[1]=max(f[1],f[1-w[0]]+v[0])=5; f[2]=max(f[2],f[2-w[0]]+v[0])=10; f[3]=max(f[3],f[3-w[0]]+v[

背包九讲之4（混合三种背包问题）

1 /* 2 将01背包,完全背包,和多重完全背包问题结合起来,那么就是混合三种背的问题 3 根据三种背包的思想,那么可以得到 4 混合三种背包的问题可以这样子求解 5 for(int i=1; i<=N; ++i) 6 if(第i件物品是01背包) 7 zeroOnePack(c[i],w[i]); 8 else if(第i件物品是完全背包) 9 completePack(c[i],w[i]); 10 else if(第i件物品是多重完全背包) 11 multiplePack(c[i],w[i

数论快速入门（同余、扩展欧几里德、中国剩余定理、大素数测定和整数分解、素数三种筛法、欧拉函数以及各种模板）

数学渣渣愉快的玩了一把数论,来总结一下几种常用的算法入门,不过鶸也是刚刚入门, 所以也只是粗略的记录下原理,贴下模板,以及入门题目(感受下模板怎么用的) (PS:文中蓝色字体都可以点进去查看百度原文) 附赠数论入门训练专题:点我打开专题(题目顺序基本正常,用以配套数论入门) 一.同余定理 简单粗暴的说就是:若 a-b == m 那么 a%m == b%m 这个模运算性质一眼看出...直接上入门水题: Reduced ID Numbers 附AC代码(这个也没啥模板....知道就好) #inclu

C++模板源代码的三种组织方式

模板代码和非模板代码是有区别的,如果像非模板代码那样把模板的声明放在头文件.h中,把模板的定义放在源文件.cpp中,那么使用这个模板时会得到一个链接错误.这个错误的原因在于,模板的定义还没有被实例化.为了实例化一个模板,编译器必须知道哪一个定义应该被实例化以及使用什么样的模板参数来实例化. 我们可以用以下三种方式来组织模板代码: 1. 包含模型(Inclusion Modal) a. 把模板的定义包含进声明模板的头文件中,如果模板声明在头文件tmpl.h中,定义在tmpl.cpp中,那可以将#i

poj 3486 A Simple Problem with Integers（树状数组第三种模板改段求段）

1 /* 2 树状数组第三种模板(改段求段)不解释! 不明白的点这里:here! 3 */ 4 #include<iostream> 5 #include<cstring> 6 #include<cstdio> 7 #include<algorithm> 8 #define N 100005 9 using namespace std; 10 11 typedef long long LL; 12 13 LL ss[N], B[N], C[N]; 14 15

21Spring_JdbcTemplatem模板工具类的使用——配置文件（连接三种数据库连接池）

上一篇文章提到过DriverManagerDataSource只是Spring内置的数据库连接池,我们可选的方案还有c3p0数据库连接池以及DBCP数据库连接池. 所以这篇文章讲一下上面三种数据库连接池的配置文件的形式. 第一种:DriverManagerDataSource:Spring内置的数据库连接池. 第一步:编写配置文件: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="

混合三种背包问题（背包九讲）

问题: 如果将P01.P02.P03混合起来.也就是说,有的物品只可以取一次(01背包),有的物品可以取无限次(完全背包),有的物品可以取的次数有一个上限(多重背包).应该怎么求解呢? 01背包与完全背包的混合: 考虑到在P01和P02中给出的伪代码只有一处不同,故如果只有两类物品:一类物品只能取一次,另一类物品可以取无限次,那么只需在对每个物品应用转移方程时,根据物品的类别选用顺序或逆序的循环即可,复杂度是O(VN).伪代码如下: for i=1..N if 第i件物品属于01背包 for v

halcon三种模板匹配方法

转自 : http://blog.csdn.net/hust1900/article/details/8843270 halcon有三种模板匹配方法:即Component-Based.Gray-Value-Based.Shaped_based,分别是基于组件(或成分.元素)的匹配,基于灰度值的匹配和基于形状的匹配,此外还有变形匹配和三维模型匹配也是分属于前面的大类 本文只对形状匹配做简要说明和补充: Shape_Based匹配方法: 上图介绍的是形状匹配做法的一般流程及模板制作的两种方法. 先要

小蚂蚁学习页面静态化（2）——更新生成纯静态化页面的三种方式

更新生成纯静态化页面的三种方式:1.按照时间间隔更新.2.手动更新.3.定时更新(需要系统配合). 1. 按照时间间隔更新. 当用户第一次访问这个页面的时候,程序自动判断,该静态文件是否存在,并且该文件是否还在有效时间内,如果该文件未超出了有效时间,用户访问的是已经生成的静态文件.如果超出了有效时间,用户得到的是动态输出的内容,同时重新生成静态文件.稍微修改一下昨天的代码为例: <?php //首先判断是否有静态文件,并且文件的最新修改时间到现在是否大于20秒 if(is_file('./tex