poj 1742 Coins（dp之多重背包+多次优化）

Description

People in Silverland use coins.They have coins of value A1,A2,A3...An Silverland dollar.One day Tony opened his money-box and found there were some coins.He decided to buy a very nice watch in a nearby shop. He wanted to pay the exact price(without change) and he known the price would not more than m.But he didn't know the exact price of the watch.
You are to write a program which reads n,m,A1,A2,A3...An and C1,C2,C3...Cn corresponding to the number of Tony's coins of value A1,A2,A3...An then calculate how many prices(form 1 to m) Tony can pay use these coins. 

Input

The input contains several test cases. The first line of each test case contains two integers n(<=n<=),m(m<=).The second line contains 2n integers, denoting A1,A2,A3...An,C1,C2,C3...Cn (<=Ai<=,<=Ci<=). The last test case is followed by two zeros.

Output

For each test case output the answer on a single line.

Sample Input

Sample Output

Source

LouTiancheng@POJ

 

传说中的男人八题，是男人就A这八题。有n种面额的硬币，面额个数分别为A_i、C_i，求最多能搭配出几种不超过m的金额？

这是一个多重部分和问题(多重背包问题)，放在了《2.3 记录结果再利用的“动态规划” 优化递推关系式》。最基本的做法是：

dp[i][j] := 用前i种硬币能否凑成j

递推关系式：

dp[i][j] = （存在k使得dp[i – 1][j – k * A[i]]为真，0 <= k <= m 且下标合法）

然后三重循环ijk递推

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

 bool dp[ + ][ + ]; // dp[i][j] := 用前i种硬币能否凑成j
 int A[ + ];
 int C[ + ];

 ///////////////////////////SubMain//////////////////////////////////
 int main(int argc, char *argv[])
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);
 #endif
     int n, m;
     while(cin >> n >> m && n > )
     {
         memset(dp, , sizeof(dp));
         for (int i = ; i < n; ++i)
         {
             cin >> A[i];
         }
         for (int i = ; i < n; ++i)
         {
             cin >> C[i];
         }
         dp[][] = true;
         for (int i = ; i < n; ++i)
         {
             for (int j = ; j <= m; ++j)
             {
                 for (int k = ; k <= C[i] && k * A[i] <= j; ++k)
                 {
                     dp[i + ][j] |= dp[i][j - k * A[i]];
                 }
             }
         }
         int answer = count(dp[n] + , dp[n] +  + m , true); // 总额0不算在答案内
         cout << answer << endl;
     }
 #ifndef ONLINE_JUDGE
     fclose(stdin);
     fclose(stdout);
     system("out.txt");
 #endif
     return ;
 }
 ///////////////////////////End Sub//////////////////////////////////

这种代码不用提交也知道会TLE，因为这个朴素的算法的复杂度是O(m∑iCi)，比如那第二个用例画成图的话会看到：

解释一下，dp数组和更新顺序为：

第二个用例：

————–
因为可以用0个1加上dp[][]拼成0；所以，dp[][]被更新为真
因为可以用1个1加上dp[][]拼成1；所以，dp[][]被更新为真
因为可以用2个1加上dp[][]拼成2；所以，dp[][]被更新为真

————–
因为可以用0个4加上dp[][]拼成0；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成1；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成2；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成4；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成5；所以，dp[][]被更新为真

————–

顺便第一个用例：

————–
因为可以用0个1加上dp[][]拼成0；所以，dp[][]被更新为真
因为可以用1个1加上dp[][]拼成1；所以，dp[][]被更新为真
因为可以用2个1加上dp[][]拼成2；所以，dp[][]被更新为真

————–
因为可以用0个2加上dp[][]拼成0；所以，dp[][]被更新为真
因为可以用0个2加上dp[][]拼成1；所以，dp[][]被更新为真
因为可以用0个2加上dp[][]拼成2；所以，dp[][]被更新为真
因为可以用1个2加上dp[][]拼成3；所以，dp[][]被更新为真
因为可以用1个2加上dp[][]拼成4；所以，dp[][]被更新为真

————–
因为可以用0个4加上dp[][]拼成0；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成1；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成2；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成3；所以，dp[][]被更新为真
因为可以用0个4加上dp[][]拼成4；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成5；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成6；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成7；所以，dp[][]被更新为真
因为可以用1个4加上dp[][]拼成8；所以，dp[][]被更新为真

————–

这个算法每次只记录一个bool值，损失了不少信息。在这个问题中，不光能够求出是否能得到某个金额，同时还能把得出了此金额时A_i还剩下多少个算出来，这样直接省掉了k那重循环。

优化dp定义：

dp[i][j] := 用前i种硬币凑成j时第i种硬币最多能剩余多少个（-1表示配不出来）
            如果dp[i - ][j] >= (前i-1个数可以凑出j，那么第i个数根本用不着)直接为C[i]
dp[i][j] =  如果j < A[i]或者dp[i][j - a[i]] <= (面额太大或者在配更小的数的时候就用光了）-
            其他（将第i个数用掉一个） dp[i][j-a[i]] - 

最后统计一下dp数组第n行>=0的个数就知道答案了：

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

 int dp[ + ][ + ]; // dp[i][j] := 用前i种硬币凑成j时第i种硬币最多能剩余多少个
 int A[ + ];
 int C[ + ];

 ///////////////////////////SubMain//////////////////////////////////
 int main(int argc, char *argv[])
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);
 #endif
     int n, m;
     while(cin >> n >> m && n > )
     {
         memset(dp, -, sizeof(dp));
         dp[][] = ;
         for (int i = ; i < n; ++i)
         {
             cin >> A[i];
         }
         for (int i = ; i < n; ++i)
         {
             cin >> C[i];
         }
         for (int i = ; i < n; ++i)
         {
             for (int j = ; j <= m; ++j)
             {
                 if (dp[i][j] >= )
                 {
                     dp[i + ][j] = C[i];
                 }
                 else if (j < A[i]                        // 用一个就超出，不能用
                         || dp[i + ][j - A[i]] <= )      // 连凑比j小的数的时候都用完了，此时更加用完了
                 {
                     dp[i + ][j] = -;
                 }
                 else
                 {
                     dp[i + ][j] = dp[i + ][j - A[i]] - ;       // 用上了一个第i个硬币
                 }
             }
         }
         int answer = count_if(dp[n] + , dp[n] +  + m , bind2nd(greater_equal<int>(), )); // 总额0不算在答案内
         cout << answer << endl;
     }
 #ifndef ONLINE_JUDGE
     fclose(stdin);
     fclose(stdout);
     system("out.txt");
 #endif
     return ;
 }
 ///////////////////////////End Sub//////////////////////////////////

还是拿第二个用例画个图：

第二个用例：
 - - - - -
- - - - - -
- - - - - -
————–
dp[][]不为负,dp[][]更新为硬币0的个数。
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
 - - - - -
   - - -
- - - - - -
————–
dp[][]不为负,dp[][]更新为硬币1的个数。
dp[][]不为负,dp[][]更新为硬币1的个数。
dp[][]不为负,dp[][]更新为硬币1的个数。
余额太大，dp[][]更新为硬币1的个数。
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
 - - - - -
   - - -
   -
————–

第一个用例：
 - - - - - - - - - -
- - - - - - - - - - -
- - - - - - - - - - -
- - - - - - - - - - -
————–
dp[][]不为负,dp[][]更新为硬币0的个数。
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
dp[][]用完了，dp[][]更新为硬币0的个数。
 - - - - - - - - - -
   - - - - - - - -
- - - - - - - - - - -
- - - - - - - - - - -
————–
dp[][]不为负,dp[][]更新为硬币1的个数。
dp[][]不为负,dp[][]更新为硬币1的个数。
dp[][]不为负,dp[][]更新为硬币1的个数。
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]用完了，dp[][]更新为硬币1的个数。
dp[][]用完了，dp[][]更新为硬币1的个数。
dp[][]用完了，dp[][]更新为硬币1的个数。
dp[][]用完了，dp[][]更新为硬币1的个数。
dp[][]用完了，dp[][]更新为硬币1的个数。
dp[][]用完了，dp[][]更新为硬币1的个数。
 - - - - - - - - - -
   - - - - - - - -
     - - - - - -
- - - - - - - - - - -
————–
dp[][]不为负,dp[][]更新为硬币2的个数。
dp[][]不为负,dp[][]更新为硬币2的个数。
dp[][]不为负,dp[][]更新为硬币2的个数。
dp[][]不为负,dp[][]更新为硬币2的个数。
dp[][]不为负,dp[][]更新为硬币2的个数。
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]其他，dp[][]更新为dp[][]
dp[][]用完了，dp[][]更新为硬币2的个数。
dp[][]用完了，dp[][]更新为硬币2的个数。
 - - - - - - - - - -
   - - - - - - - -
     - - - - - -
         - -
————–

本以为这次照着书上的思路来的应该没问题了吧，数组再利用就懒得做了。于是提交，结果MLE

于是打起精神来重复利用数组，注意到上图中的箭头都是垂直的，也就是说可以定义

dp[j] := 在第i次循环时之前表示用前i-1种硬币凑成j时第i种硬币最多能剩余多少个（-1表示配不出来），循环之后就表示第i次的状态

于是就省了一维数组：

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

 int dp[ + ]; // dp[i][j] := 用前i种硬币凑成j时第i种硬币最多能剩余多少个
 int A[ + ];
 int C[ + ];

 ///////////////////////////SubMain//////////////////////////////////
 int main(int argc, char *argv[])
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);
 #endif
     int n, m;
     while(cin >> n >> m && n > )
     {
         memset(dp, -, sizeof(dp));
         dp[] = ;
         for (int i = ; i < n; ++i)
         {
             cin >> A[i];
         }
         for (int i = ; i < n; ++i)
         {
             cin >> C[i];
         }
         for (int i = ; i < n; ++i)
         {
             for (int j = ; j <= m; ++j)
             {
                 if (dp[j] >= )
                 {
                     dp[j] = C[i];
                 }
                 else if (j < A[i]                        // 用一个就超出，不能用
                         || dp[j - A[i]] <= )       // 连凑比j小的数的时候都用完了，此时更加用完了
                 {
                     dp[j] = -;
                 }
                 else
                 {
                     dp[j] = dp[j - A[i]] - ;     // 用上了一个第i个硬币
                 }
             }
         }
         int answer = count_if(dp + , dp +  + m , bind2nd(greater_equal<int>(), )); // 总额0不算在答案内
         cout << answer << endl;
     }
 #ifndef ONLINE_JUDGE
     fclose(stdin);
     fclose(stdout);
     system("out.txt");
 #endif
     return ;
 }
 ///////////////////////////End Sub//////////////////////////////////

提交，AC，并且足足算了2秒钟。这就是男人八题么