动态规划——0-1背包问题

 0-1背包问题：

　　描述：给定n中物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为c，问应如何选择装入背包中的物品，使得装入背包中的物品总价值最大？

　　0-1背包问题是一个特殊的整数规划问题。

　　　　　　

　　设所给0-1背包问题的子问题;

　　　　　　　　

　　其最优值为m(i，j)，即m(i，j)是背包容量为j，可选择物品为i，i+1，…，n时0-1背包问题的最优值。由0-1背包问题的最优子结构性质，可以建立计算m(i，j)的递归式如下:

　　　　　　

NO1：递归实现

/*
*Description 递归实现
*设有一个背包可以放入的物品重量为S，现有n件物品，重量分别是w1，w2，w3，…wn。 
*问能否从这n件物品中选择若干件放入背包中，使得放入的重量之和正好为S。 
*如果有满足条件的选择，则此背包有解，否则此背包问题无解。
*/
# include<stdio.h>
# include<string.h>

int date[1005];

int f(int w,int s)
{
    if(w==0) return 1;//正好
    if(w<0||w>0 &&s==0) return 0;
    if(f(w-date[s],s-1)) return 1;//退出来再选下一个 
    return f(w,s-1);//选择下一个
}

int main()
{
    int i,Weight,n;
    while(scanf("%d %d",&Weight,&n)!=EOF)
    {
        memset(date,0,sizeof(date));
        for(i=1;i<=n;i++)
            scanf("%d",&date[i]);
        if(f(Weight,n))
            printf("YES
");
        else 
            printf("NO
");
    }
    return 0;
}

NO2：动态规划——从后往前实现

/*
*从后往前得到最终结果
*二维数组m[][]来存储m(i,j)的相应值
*i：物品的取值范围(i,n)
*j：当前背包的最大容量值
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

# define max(a,b) a>b?a:b
# define min(a,b) a<b?a:b

void Knapsack(int *v, int *w,int c, int n, int m[][100])
{
    int i,j,jmax;
    jmax=min(w[n]-1, c);         //装不下n号物品的最大重量
    for(j = 0; j <= jmax; j++)
        m[n][j] = 0;
    for(j = w[n]; j <= c; j++)
        m[n][j] = v[n];
    for(i = n-1; i > 1; i--)
    {
        jmax = min(w[i]-1, c);
        for(j = 0; j <= jmax; j++)
            m[i][j] = m[i+1][j];
        for(j = w[i]; j <= c; j++)
            m[i][j] = max(m[i+1][j],m[i+1][j - w[i]] + v[i]);
    }
    m[1][c] = m[2][c];
    if(c >= w[1])
        m[1][c] = max(m[2][c],m[2][c - w[1]] + v[1]);
}

void Traceback(int m[][100], int *w, int c, int n, int *x)
{
    int i;
    for(i = 1; i < n; i++)
        if(m[i][c] == m[i + 1][c])
            x[i] = 0;
        else
        {
            x[i] = 1;
            c -= w[i];            //背包容量的变化，逐渐减少
        }
        x[n] = (m[n][c]) ? 1 : 0;
}

void main()
{
    int j;
    int i,n,c;
    int v[100]={0},w[100]={0};
    int m[100][100] = {0};
    int x[100]={0};

    printf("please input the num : n = ");
    scanf("%d",&n);
    printf("
please input the capacitance : c = ");
    scanf("%d",&c);
    printf("
please input the value :
");
    for(i = 1; i <= n; i++)
        scanf("%d",&v[i]);
    printf("
please input the weight :
");
    for(i = 1; i <= n; i++)
        scanf("%d",&w[i]);

    Knapsack(v,w,c,n,m);

    Traceback(m,w,c,n,x);

    printf("
the result is :");
    for(i = 1; i <= n; i++)
        if(x[i]==1)
            printf("%d  ",i);
    Sleep(10000000);

}

NO3：动态规划——从前往后实现

/*
*从前往后得到最终结果
*二维数组m[][]来存储m(i,j)的相应值
*i：物品的取值范围(1，i)
*j：当前背包的最大容量值
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

# define max(a,b) a>b?a:b
# define min(a,b) a<b?a:b

void Knapsack(int *v, int *w,int c, int n, int m[][100])
{
    int i,j,jmax;
    jmax=min(w[n]-1, c);
    for(j = 0; j <= jmax; j++)
        m[n][j] = 0;
    for(j = w[n]; j <= c; j++)
        m[n][j] = v[n];
    for(i = n-1; i > 1; i--)
    {
        jmax = min(w[i]-1, c);
        for(j = 0; j <= jmax; j++)
            m[i][j] = m[i+1][j];
        for(j = w[i]; j <= c; j++)
            m[i][j] = max(m[i+1][j],m[i+1][j - w[i]] + v[i]);
    }
    m[1][c] = m[2][c];
    if(c >= w[1])
        m[1][c] = max(m[2][c],m[2][c - w[1]] + v[1]);
}

void Traceback(int m[][100], int *w, int c, int n, int *x)
{
    int i;
    for(i = 1; i < n; i++)
        if(m[i][c] == m[i + 1][c])
            x[i] = 0;
        else
        {
            x[i] = 1;
            c -= w[i];
        }
        x[n] = (m[n][c]) ? 1 : 0;
}

void Knapsack_pre(int *v, int *w,int c, int n, int m[][100])
{
    int i,j,jmax;
    jmax=min(w[1]-1, c);
    for(j = 0; j <= jmax; j++)
        m[1][j] = 0;
    for(j = w[1]; j <= c; j++)
        m[1][j] = v[1];
    for(i = 2; i <= n; i++)
    {
        jmax = min(w[i]-1, c);
        for(j = 0; j <= jmax; j++)
            m[i][j] = m[i-1][j];
        for(j = w[i]; j <= c; j++)
            m[i][j] = max(m[i-1][j],m[i-1][j - w[i]] + v[i]);
    }
}

void Traceback_pre(int m[][100], int *w, int c, int n, int *x)
{
    int i;
    for(i = n; i > 0; i--)
        if(m[i][c] == m[i - 1][c])
            x[i] = 0;
        else
        {
            x[i] = 1;
            c -= w[i];
        }
        x[1] = (m[1][c]) ? 1 : 0;
}

void main()
{
    int j;
    int i,n,c;
    int v[100]={0},w[100]={0};
    int m[100][100] = {0};
    int x[100]={0};

    printf("please input the num : n = ");
    scanf("%d",&n);
    printf("
please input the capacitance : c = ");
    scanf("%d",&c);
    printf("
please input the value :
");
    for(i = 1; i <= n; i++)
        scanf("%d",&v[i]);
    printf("
please input the weight :
");
    for(i = 1; i <= n; i++)
        scanf("%d",&w[i]);

    Knapsack_pre(v,w,c,n,m);

    Traceback_pre(m,w,c,n,x);

    printf("

");
    printf("m :
");
    for(i = 1; i <= n; i++)
    {
        for(j = 0; j <= c; j++)
            printf("%d   ",m[i][j]);
        printf("
");
    }

    printf("

");
    printf("x : 
");
    for(i = 1; i <= n; i++)
        printf("%d   ",x[i]);

    printf("
the result is :");
    for(i = 1; i <= n; i++)
        if(x[i]==1)
            printf("%d  ",i);
    Sleep(10000000);

}

NO4：自顶向下的递归实现 + 自底向上实现 + 基于备忘录的自顶向下实现

  1 #include <stdio.h>
  2 
  3 #define N    4
  4 #define W    5
  5 
  6 //物品的重量
  7 int w[] = {-1, 2, 1, 3, 2};
  8 
  9 //价值数组
 10 int vi[] = {-1, 12, 10, 20, 15};
 11 
 12 int v[N+1][W+1]; //v[i][j]表示从前i个物品选能够放进承重量为j的背包的子集的最大总价值
 13 
 14 void init()
 15 {
 16     int  i, j;
 17     for (i = 0; i <= N; i++)
 18         for (j = 0; j <= W; j++)
 19             v[i][j] = -1;
 20 
 21     for (i = 0; i <= N; i++)
 22         v[i][0] = 0;
 23 
 24     for (i=0; i <= W; i++)
 25         v[0][i] = 0;
 26 }
 27 
 28 
 29 //基于备忘录的动态规划算法
 30 int MKFnapsack_MEMOIZE(int i, int j)
 31 {
 32     int value;
 33     if (v[i][j] < 0)  //如果v[i][j]还没有计算,则进行计算
 34     {
 35         if (j < w[i])
 36             value = MKFnapsack_MEMOIZE(i-1,j);
 37         else
 38         {
 39             int v1 = MKFnapsack_MEMOIZE(i-1, j);
 40             int v2 = MKFnapsack_MEMOIZE(i-1, j-w[i]) + vi[i];
 41             value = v1 >=v2 ? v1:v2;
 42         }
 43         v[i][j] = value;
 44     }
 45     return v[i][j]; //如果v[i][j]已经进行计算,则不进行计算,直接返回即可
 46 }
 47 
 48 //自顶向下的动态规划算法
 49 int MKFnapsack_TOP_TO_BOTTOM(int i, int j)
 50 {
 51     int value;
 52     
 53     if(i <= 0 || j <= 0)
 54         return 0;
 55 
 56     //不管v[i][j]是否计算过,都进行计算
 57     if (j < w[i])
 58         value = MKFnapsack_TOP_TO_BOTTOM(i-1, j);
 59     else
 60     {
 61         int v1 = MKFnapsack_TOP_TO_BOTTOM(i-1, j);
 62         int v2 = MKFnapsack_TOP_TO_BOTTOM(i-1, j-w[i]) + vi[i];
 63         value = v1 >= v2 ? v1:v2;
 64     }
 65 
 66     return value;
 67 }
 68 
 69 //自底向上的算法
 70 int MKFnapsack_BOTTOM_TO_TOP(int Ni, int Wi)
 71 {
 72     int i, j;
 73     for (i = 1; i <= Ni; i++)
 74     {
 75         for(j = 1; j <= Wi; j++)
 76         {
 77             if(j < w[i])
 78                 v[i][j] = v[i-1][j];
 79             else //j >=w[i]
 80             {
 81                 int v1= v[i-1][j];
 82                 int v2 = v[i-1][j-w[i]] + vi[i];
 83                 v[i][j] = v1 >= v2 ? v1:v2;
 84             }
 85         }
 86     }
 87     return v[N][W];
 88 }
 89 
 90 void print_v(int Ni, int Wi)
 91 {
 92     int i, j;
 93     for(i = 0; i <= Ni; i++)
 94     {
 95         for(j = 0; j <= Wi; j++)
 96             printf("%d ", v[i][j]);
 97         printf("
");
 98     }
 99 }
100 
101 int main()
102 {
103     printf("top to bottom most value is:%d
", MKFnapsack_TOP_TO_BOTTOM(N, W));
104 
105     init();//数组初始化
106     printf("memoize most value is:%d
", MKFnapsack_MEMOIZE(N, W));
107     print_v(N, W);
108 
109     init();
110     printf("bottom to top most value is:%d
", MKFnapsack_BOTTOM_TO_TOP(N, W));
111     print_v(N, W);
112 
113     return 0;
114 }

 分析：

　　自顶向下的递归算法，写法最简单，但效率是最低的，它往往把问题搞成指数级。而自底向上的算法是DP的经典策略，它比自顶向下的效率高，但是，它往往也计算了没有必要计算的子问题(见上图)。而基于备忘录的自顶向下的算法是前两者的集大成者，效率最优。