Coins

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3969    Accepted Submission(s): 1578

 

Problem Description

Whuacmers use coins.They have coins of value A1,A2,A3...An Silverland dollar. One day Hibix opened purse 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(1 ≤ n ≤ 100),m(m ≤ 100000).The second line contains 2n integers, denoting A1,A2,A3...An,C1,C2,C3...Cn (1 ≤ Ai ≤ 100000,1 ≤ Ci ≤ 1000). The last test case is followed by two zeros.

Output

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

Sample Input

3 10 1 2 4 2 1 1 2 5 1 4 2 1 0 0

Sample Output

8 4

題意：給面值不同，有固定個數的硬幣，能有多少種不同的不同總面值的組合方式；

思路：把多重揹包問題用二進位制拆分成 01 揹包求解，再加上一點剪枝；

先解釋一下多重揹包如何優化，這裡有一個數學的結論： 1到n以內的數字，能夠通過 n 內的進位制數組合得到，比如 9以內的二進位制數有 1 2 4 8，可以自己在草稿紙上試一下， 3能通過 1 + 2 得到，5能通過1 + 4 得到，6能通過 2 + 4得到，所以，我們可以利用二進位制數的拆分求出所有 n 以內的數；下面是拆分的過程：

9 - 1 = 8；  8 - 2 = 6； 6 - 4 = 2 ； 2 - 8  < 0； 那麼要求的 9 以內的二進位制數就是  1，2， 4，2，這幾個二進位制是能夠組成 9以內包括 9 的所有整數，然後通過 w[ i ] 乘以這些二進位制數，把他們當作一件物品來做01揹包的處理，當然，如果沒有用二進位制拆分的話，可以直接把9拆分成  1,2,3,4,5,6,7,8,9 然後乘以w[ i ] 當作一件物品來做01揹包處理，這種依次拆分的時間複雜度和不拆直接用多重揹包處理是一樣的，但是，為什麼9個數字，只需要1,2,4,2這四個二進位制數就夠了呢？（這個問題暫時還沒辦法解決，能力有限，目前只要知道，只要拆分的二進位制數字能夠組成 n 以內的所有數的情況下，轉化為單個物品做01揹包的處理就行了），下面是程式碼：

#include<iostream>
#include<cstdio>
#include<cstring>

using namespace std;

#define Maxn 100010
#define INF 0x3f3f3f3f

int dp[Maxn],v[105],num[105],tmp_v[Maxn],book[Maxn];

int main(void)
{
   // freopen("in.txt","r",stdin);
   // freopen("out.txt","w",stdout);
    int kind,max_p;
    while (scanf("%d%d",&kind,&max_p) != EOF) {
        if(!kind && !max_p) break;
        for (int i = 1; i <= kind; ++i) scanf("%d",&v[i]);
        for (int i = 1; i <= kind; ++i) scanf("%d",&num[i]);

        memset(dp,0,sizeof(dp));
        
        int cnt = 1;  // 用單獨的陣列存取拆分後的所有面值
        for (int i = 1; i <= kind; ++i) {
            for (int j = 1; j <= num[i]; j <<= 1) {
                tmp_v[cnt] = j*v[i];
                num[i]-=j;
                cnt++;
            }
            if(num[i] > 0) tmp_v[cnt++] = num[i]*v[i];
        }
        
        //用上面拆分後的陣列做01揹包的處理
        // 這裡並沒有用01揹包去求最大值，而是把能夠滿足條件的狀態dp 賦值為1,下標就是能夠組合得到的總面值，
        //否則為 0 ，不存在這樣的面值
        memset(book,0,sizeof(book));
        int max_ = 1;  
        int ans = 0;
        for (int i = 1; i < cnt; ++i) {
                max_+=tmp_v[i];
                max_ = min(max_p,max_);
            for (int j = max_; j >= tmp_v[i]; --j) {   //j的迴圈做了一些剪枝，因為遍歷是從右往左的，在紙上模擬一下
                if(dp[j]) continue;                     //就會明白，當前j遍歷的最大值就是把以前用過的面值的累加，最小值就是
                if(j == tmp_v[i]) dp[j] = 1;            //當前物體的面值；
                else if(j-tmp_v[i] > 0 && dp[j-tmp_v[i]]) dp[j] = 1;
                if(!book[j] && dp[j]) { ans++; book[j] = 1; }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

N天后，對上面的程式碼進行改進，同樣的一道題，要不是遇到poj，我可能以為上面的程式碼就很完美了，事實上，上面的程式碼如果交的poj的coins的話，會時間超限，而上面的程式碼只能在HDU的題庫上AC，不得不說，這題的資料測試上，poj要強HDU很多，下面看看兩個能在poj  AC的程式碼，第一種的用時是 2800ms左右，這裡的方法其實和上面的是一樣的，只是在一些個別資料上面加上了完全揹包來優化了時間；方法：針對一些硬幣的數量，我們把他們統一做二進位制拆分然後做01揹包處理，假設一種硬幣的數量為 10^5，那麼二進位制拆分得到的單個物品的數量就是  log 2(10^5)，不做常數優化的01揹包的情況下，一個數量為10^5的硬幣時間複雜度大概就是  15*V  （V是硬幣組合的最大值），假設V是題目的上限 10^5，那麼單個硬幣的時間複雜度就是1.5*10^6，算是比較大的了，一般時間複雜度為 10^8 為比較適合的；對於這類數量巨大的資料我們如何處理？ 其實仔細想想，但凡硬幣的數量*硬幣的價值的總和大於規定的 V 的時候，我們是不是可以直接把他當做完全揹包處理，如果用完全揹包的話，一個物品不用拆分就能完成這個硬幣的dp操作，時間複雜度為一個V，單個數據就能快上15倍這個樣子，完全揹包的特點就是物品的數量可以無限取，但事實上，物品的數量*物品的價值大於規定的V的值得時候，我們是直接不考慮的；所以和上面的程式碼不同的就是，把硬幣的數量分成兩類，一類就是數量*面值大於 V的，把他當做完全揹包處理，小於或者等於的話，就繼續做上面程式碼的二進位制拆分的01揹包處理；下面給出程式碼：

#include<cstdio>

using namespace std;

#define Maxn 100010

int dp[Maxn],N,V,price[105],num[105];

void com_beg(int x) {   // 完全揹包
    for (int j = price[x]; j <= V; ++j) {  // 這裡 j=price[x] ,是一點剪枝，建議自己獨立思考一下，
                                            // 為什麼這樣剪枝
        if(!dp[j] && j >= price[x] && dp[j-price[x]]) dp[j] = 1;
    }
}

void zero_one (int x) {  // 01揹包
    for (int j = V; j > 0; --j) {  
        if(j < x) break;
        if(!dp[j] && dp[j-x]) dp[j] = 1;
    }
}

int main(void)
{
    while (scanf("%d%d",&N,&V) != EOF) {
        if(!N && !V) break;
        for (int i = 0; i < N; ++i) scanf("%d",&price[i]);
        for (int i = 0; i < N; ++i) scanf("%d",&num[i]);
        for (int i = 1; i <= V; ++i) dp[i] = 0; // 這裡初始化是可以用memeset的，但陣列開的大
        dp[0] = 1;                              // 這樣也許會快一丟丟把。。
        // 這裡dp[0] 其實是一個確切的值，想想，揹包數量為0的時候，不放不就滿足條件了嗎
        for (int i = 0; i < N; ++i) {
            if(num[i]*price[i] >= V) {
                com_beg(i);
            }
            else {
                for (int j = 1; j <= num[i]; j <<= 1) {
                    if(j*price[i] <= V) zero_one (j*price[i]);
                    num[i]-=j;
                }
                if(num[i] > 0 && num[i]*price[i] <= V) zero_one(num[i]*price[i]);
            }
        }
        int ans = 0;
        for (int i = 1; i <= V; ++i) if(dp[i]) ans++;
       printf("%d\n",ans);
    }
    return 0;
}

上面就是其中的一種寫法，但時間還是花費有點多，第二種方法有一個（好像很牛B的名字）多重揹包可行性的名字；下面我解釋一下這種方法是怎樣的一個原理（是我自己理解的，也許不對，可以看看參考一下）；

多重揹包與完全揹包和01揹包最大的不同就是有限定的數量，也就是說，每一種物品限定的數量是不定的，我們回想一下最基本的多重揹包是如何寫的： 在01揹包的基礎上，多加一個迴圈k，k的作用就是一個限制的作用，當k 大於當前物品的數量的時候就退出，然後下一個又繼續；如果我們能用別的方法代替這個k去限定物品的數量，也許就可以把這個k的迴圈去掉了；多重揹包可行性的問題其實是一個系列的問題，都是問你一個物品能有多少種組合，而不是問你最大重量或者最小重量是多少，對於01揹包和完全揹包的問題上，我們用dp來表示當前的狀態，並且把當前的子問題的答案儲存到dp數組裡頭，比如，我們要求最大值，那麼就把當前狀態的子問題的最大值放進dp裡面，那這道coins的子問題只是問我們能否組合得到，所以，可以用0和1來表示是或者否，而多重揹包可行性的問題就是利用了這一點，把硬幣的數量值放在dp裡頭，把dp的資料用一個特別的值隔開，一邊表示能組合一邊表示不能，而且這個資料同時還能夠儲存硬幣的數量，來限定這個硬幣的使用；下面有幾張圖：

假設硬幣有 兩種 kind 1 和 kind 2；kind 1 的價值為1，另一個為2，數量分別為 2 和 3，V的值是6，dp【j】的j值表示的意思和上面的一樣，就是罐子裡面硬幣的總值；

kind 1 的情況，kind 1 是第一個放入的，所以毫無疑問，能組合的總值就是kind 1 的倍數，我們一維 dp 初始化為 0 ，表示的是硬幣還一次沒用，當 j的 1的時候，罐子內是可以放一枚 kind 1 硬幣的，然後在dp + 1，表示用了一枚了，並且用另外一個數值來存能夠滿足條件的組合，就是book[ 1 ] = 1； 然後 j = 2 的時候，dp【2】 == 0 && book【2】 == 0  ，說明硬幣總值為 2 的罐子還沒出現過（這裡要注意，我們每次一個硬幣只放一個），然後我們找 dp【j - price[ 1 ]】也就是 dp [ 2 - 1 ] ，發現是存在這種總值的罐子，那麼我們直接在這個罐子裡面投一枚  kind 1 ，就能得到 j = 2，硬幣總值為 2  的罐子了，然後dp 【2】 = dp【1】+ 1；為什麼 + 1？這裡 + 1的意思是完成 j = 2 的時候用了已經有一枚kind 1 的總值為 1 的罐子：

既然dp【2】 已經到kind 1 數量的上限了，是不是就意味著j = 2 後面就不用遍歷了呢？並不是，下面看看 kind 2 的情況就明白了：

我們先看 j = 2 的時候，j = 2的時候，顯然上一次就已經用 book 記錄了 book【2】 == 1；也就是說，即使不加kind 2的硬幣，也能組合得到 j == 2 的罐子，所以不用放一枚kind 2 硬幣，然後我們在看 j = 3 的時候，顯然 book【3】 == 0，就去看dp【j - price【2】】的值，也就是 dp【3 - 2】 = dp 【1】，顯然 book【1】 == 1 && dp【1】 == 0，如果當前dp【1】 == 0，說明在不用kind 2硬幣的情況下存在 j == 1的罐子的組合，那麼我們在 j = 1 這個罐子裡頭放一個  kind 2 的硬幣，那就能夠有j = 3 的罐子了，這裡我們只用了一枚 kind 2的硬幣，因為組合得到的 j = 1的罐子沒用kind 2的硬幣（判斷dp【1】就能知道），j = 4也是一樣的道理，j = 5的時候，發現book【5】== 0；那麼我們就找 book【3】，book【3】= 1，注意，上圖中第一行雖然dp【3】 == 0，但是在第二行的dp【3】是不為0的，說明存在j = 3的罐子，這時候發現dp【3】 = 1，說明組合得到 j = 3的時候用了一枚，那麼組合得到dp【5】的時候就應該dp【5】 = dp【3】 + 1；這時候dp【5】 = 2；說明組合dp【5】用了2了兩枚kind 2的硬幣，以此類推，如果dp【j】大於當前硬幣的數量的時候，就能直接判斷不可行了；下面給出程式碼：

#include<cstdio>
#include<cstring>

using namespace std;

#define Maxn 100010

int dp[Maxn],N,V,price[105],num[105],book[Maxn];

int main(void)
{
    while (scanf("%d%d",&N,&V) != EOF) {
        if(!N && !V) break;
        for (int i = 1; i <= N; ++i) scanf("%d",&price[i]);
        for (int i = 1; i <= N; ++i) scanf("%d",&num[i]);
        for (int i = 0; i <= V; ++i) dp[i] = 0;
        memset(book,0,sizeof(book));
        book[0] = 1; //  0這種組合是無論如何都存在的

        for (int i = 1; i <= N; ++i) {
            for (int k = 1; k <= V; ++k) dp[k] = 0;
            for (int j = price[i]; j <= V; ++j) {
                if(!book[j] && book[j - price[i]] && dp[j-price[i]] < num[i]) {
                    dp[j] = dp[j-price[i]] + 1;
                    book[j] = 1;
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= V; ++i) if(book[i]) ans++;
       printf("%d\n",ans);
    }
    return 0;
}