DP- 01背包问题

 

这个01背包 ， 理解了一天才勉强懂点 ， 写个博客  （  推荐   http://blog.csdn.net/insistgogo/article/details/8579597）

 

题目 ：

　　有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可以使价值总和最大。

 

分析一下 ：

　　面对一件物品 ， 我有两种选择 ， 放或者不放 ， 若是不放 ， 则最大价值是 前 n - 1 件物品放入容量为 j 的背包 ， 若是放 ， 则最大价值是将前 n - 1 件物品放入剩余容量为 j - c[j] ， 此时的

价值是 前 n - 1 件物品放入剩余容量为 v - c[ j ] 的价值加上放入该物品的价值 .......一直此过程 ， 最后的最大价值便是 c[ n ] [ v ] 。

 

（ 偷一个图 ）：

　　

 　　要怎样去实现这个代码呢 ？ 先用最好的理解的二维数组去解决这个问题 ， 两个维度分别存的是 物品的个数以及 当前背包的总容量 ， 由于我第一层 for 是从 遍历全部的物品 ， 即面对某个物品 ， 第二层 for  我是遍历体积 ， 每次让体积 + 1 ， 这样就会产生一种 什么效果呢 ？ 在面对每个物品时 ， 我全部的体积都去试一下 ， 这个过程 从最终的意义上考虑实际都是在为最后 背包容量满的时候服务 ， 这个过程 也就叫作构建最优子结构的过程 ， 而且当前产生的结果 ， 对后面不会有任何影响 ， 也就是无后效性 。

　　（ 关于这个代码 ， 我感受有一个地方很精髓 ， 就是 当面对 一号 物品时 ， 个人状态转移方程考虑的是前 i - 1 个物品 ， 即没有物品的时候 ， 此时我创建的数组就能够在 i = 0  的位置留出地方 ， 而且借助 memset 将这些位置都给 0 ）

　　（还有 这个的背包容量也能够从 V 开始遍历 直到 1 结束 ， 则会打出另外一张表）

 

代码示例 ：

　　

// 感受 DP 中的背包问题 就是一个制做表格的过程
// 所制做的表的大小是 n * v 

#include <iostream>
#include <algorithm>
using namespace std ;

int dp[10][500] ;   // 定义为全局变量 会被初始化为 0
int weight[15] ;
int value[15] ;

int main ( ) {
    int n , v ;

    cin >> n >> v ;
    for ( int i = 1 ; i <= n ; i++ ) {
        cin >> weight[i] >> value[i] ;
    }

    for ( int i = 1 ; i <= n ; i++ ) {
        for ( int j = 1 ; j <= v ; j++ ) {
            if ( weight[i] <= j )
                dp[i][j] = max ( dp[i-1][j] , dp[i-1][j-weight[i]] + value[i] ) ;
            else
                dp[i][j] = dp[i-1][j] ; // 若是当前面对此物品背包中不能再放东西 ，但表的这一栏又不能空 ，
                                        // 因此填的数 是这个体积下，没有此物品的体积
        }
    }

    cout << dp[n][v] << endl ;

    return 0 ;
}

 

 

二 . 优化空间复杂度

　　用二维数组去写的话 ， 复杂度为 O （n*v） ， 在数据大的时候直接超内存 ， 因此能够借助一维数组 ， 将复杂度优化为 O （n）

　　贴上个人代码 ：

　　　　

// 感受 DP 中的背包问题 就是一个制做表格的过程
// 所制做的表的大小是 n * v
#include <iostream>
#include <algorithm>
using namespace std ;

int dp[1500] ;   // 定义为全局变量 会被初始化为 0
int weight[15] ;
int value[15] ;

int main ( ) {
    int n , v ;

    cin >> n >> v ;
    for ( int i = 1 ; i <= n ; i++ ) {
        cin >> weight[i] >> value[i] ;
    }

    for ( int i = 1 ; i <= n ; i++ ) {
        for ( int j = v ; j >= 1 ; j-- ) {
            if ( weight[i] <= j )
                dp[j] = max ( dp[j] , dp[j-weight[i]] + value[i] ) ;  // 当面对一个物品时 ， 此时数组所对应的便是前 i - 1 的价值 
        }
    }

    cout << dp[v] << endl ; 

    return 0 ;
}

 

 

 

// 用一维数组作 ， 感受和数字三角形的题很像 ， 从底下递推 。此背包问题就是 ， 在面对每一个物品时，不断地更新数组中的数据 ， 而且在面对每一个物品时 ， 其体积是从 V 到 1 递推  

// 用一维数组作 ， 当面对一个物品 ， 在这个位置上 ，数组所存的数便是 在该体积下 ， 前 i - 1 件物品的最大价值

 

有一个问题 ： 体积为何要是逆序递推呢 ？

而后附上我程序的运行结果 ：

　　

 

三 .  初始化的细节问题 

　　在最优解得背包问题 ， 有两种问法 ；

　1 . 在不超过背包容量时 ， 如何装会得到最大价值 ？

　2 .当背包刚好装满时 ， 得到的最大价值是多少 ？

 

　　两种问法的惟一区别就在于就在于背包是否装满 ， 这两种问法的实现仅仅区别于对数组元素的初始化 。

　　初始化 f 数组就表示 ， 在没有放入任何物品时背包的合法状态 。

　　对于刚好装满的状况 ， 我应对此二维数组的 dp[ i ] [ 0 ]  初始化为 0 ， 由于我在面对一个物品时 ， 我此时背包的容量为 0 ， 不能再听任何东西 ， 即为刚好装满的时候 ， 将此 dp 数组其他位置所有初始为  负无穷 ， 其他过程所有同上 ... 最后时 输出刚好的最优解 即 dp[ n ][ v ] 。

　　对于不超过背包容量的状况 ， 我只须要将数组中的元素所有初始为 0 。若是背包并不是 要所有装满 ， 那么任何背包都有一个合法解 ， 即什么也不装 。

 

 刚好装满的二维数组代码 ：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std ;

int dp[10][500] ;   // 定义为全局变量 会被初始化为 0
int weight[15] ;
int value[15] ;

int main ( ) {
    int n , v ;
    int i , j;

    cin >> n >> v ;
    memset ( dp , 0x8f , sizeof(dp) ) ;  // 将数组所有元素初始化为 负无穷
    for ( i = 0 ; i <= n ; i++ ) {
        dp[i][0] = 0 ;
    }

    for ( i = 1 ; i <= n ; i++ ) {
        cin >> weight[i] >> value[i] ;
    }

    for ( i = 1 ; i <= n ; i++ ) {
        for ( j = 1 ; j <= v ; j++ ) {
            if ( weight[i] <= j ) {
                dp[i][j] = max ( dp[i-1][j] , dp[i-1][j-weight[i]] + value[i] ) ;
            }
            else
                dp[i][j] = dp[i-1][j] ;
        }
    }

    cout << dp[n][v] << endl ;
    return 0 ;
}

 

刚好装满的一维数组的代码 ：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std ;

int dp[1500] ;   // 定义为全局变量 会被初始化为 0
int weight[15] ;
int value[15] ;

int main ( ) {
    int n , v ;

    memset ( dp , 0x8f , sizeof(dp) ) ;
    dp[0] = 0 ;
    cin >> n >> v ;
    for ( int i = 1 ; i <= n ; i++ ) {
        cin >> weight[i] >> value[i] ;
    }

    for ( int i = 1 ; i <= n ; i++ ) {
        for ( int j = v ; j >= weight[i] ; j-- ) {
            dp[j] = max ( dp[j] , dp[j-weight[i]] + value[i] ) ;  // 当面对一个物品时 ， 此时数组所对应的便是前 i - 1 的价值
        }
    }

    cout << dp[v] << endl ;

    return 0 ;
}

 

 附上利用机器打得表 ：

　　

 

 

四 . 一个常数的优化

　　在用一维数组 ， 作背包问题时 ， 背包容量是从  v 到 1 遍历 ，但实际上只须要遍历到 weight[ i ] 。

代码示例 ：

　　

#include <iostream>
#include <algorithm>
using namespace std ;

int dp[1500] ;   // 定义为全局变量 会被初始化为 0
int weight[15] ;
int value[15] ;

int main ( ) {
    int n , v ;

    cin >> n >> v ;
    for ( int i = 1 ; i <= n ; i++ ) {
        cin >> weight[i] >> value[i] ;
    }

    for ( int i = 1 ; i <= n ; i++ ) {
        for ( int j = v ; j >= weight[i] ; j-- ) {    //////////  修改处
            dp[j] = max ( dp[j] , dp[j-weight[i]] + value[i] ) ;  // 当面对一个物品时 ， 此时数组所对应的便是前 i - 1 的价值
        }
    }

    cout << dp[v] << endl ;

    return 0 ;
}

 

背包的路径输出（板子）

int n,m;
int v[MAX],w[MAX];
int dp[MAX];
bool path[MAX][MAX];
int V;
void solve()
{
    memset(dp,0,sizeof(dp));
   memset(path,false,sizeof(path));
   for(int i=0;i<n;i++)
   {
       for(int j=V;j>=w[i];j--)
        if(dp[j-w[i]]+v[i]>dp[j])
        {
            dp[j]=dp[j-w[i]]+v[i];
            path[i][j]=true;//cout<<i<<j<<endl;
        }
   }
   cout<<dp[V]<<endl;
   int ans[MAX];
   int k=0;
   for(int i=n-1;i>=0;i--)
   {
       if(path[i][V]){
        ans[++k]=i;
        V-=w[i];
       }
   }
   //输出所选择的物品
   for(int i=k;i>0;i--)
     cout<<ans[i]<<endl;
}