POJ 3260 The Fewest Coins（完全背包 + 多重背包 + 单调队列优化）

题意：

John去买东西，东西的价格是T(1 <= T <= 10000)，John所在的地方有n(1 <= n <= 100)种的硬币，面值分别为V1, V2, ..., Vn (1 <= Vi <= 120)。John带了C1枚面值为V1的硬币，C2枚面值为V2的硬币，...，Cn枚面值为Vn的硬币(0 <= Ci <= 10000)。售货员那里每种硬币都有无限多个。问为了支付这个T，John给售货员的硬币数目加上售货员找回的零钱的硬币数目最少是多少。如果无法支付T，输出-1 。

思路：

1. 和 POJ 1252 类似，只不过这次对于找零变成了完全背包，相对来说复杂度减少了一点点。

2. 问题的难点在于如何确定背包容量的上限，看到 discuss 上有人说 T + vmax * vmax 是上限，其实再把 vmax /= 2 也是可以的。

3. 多重背包 + 倍增优化是可以做的，最近在学习单调队列，顺便就用单调队列优化了下，16ms，真心膜拜 0ms 的大神。

4. 单调队列优化的时候，用 二分搜索 反而比 从后往前遍历 要慢，可能是数据的原因吧，有关单调队列的性质还有待于慢慢理解。

 

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

const int MAXD = 10010;
const int MAXN = 150;
const int INFS = 0x3fffffff;

int dp[MAXD << 2], A[MAXD << 2], B[MAXD << 2];
int V[MAXN], C[MAXN];

void ZeroOnePack(int w, int val, int vol)
{
    for (int v = vol; v >= w; --v)
        if (dp[v - w] != INFS)
            dp[v] = min(dp[v], dp[v - w] + val);
}

void CompletePack(int w, int val, int vol)
{
    for (int v = w; v <= vol; ++v)
        if (dp[v - w] != INFS)
            dp[v] = min(dp[v], dp[v - w] + val);
}

inline int BinarySearch(int arr[], int l, int r, int val)
{
    while (l <= r)
    {
        int m = (l + r) >> 1;
        if (arr[m] > val)
            r = m - 1;
        else
            l = m + 1;
    }
    return l - 1;
}

void MultiplePack(int w, int val, int n, int vol)
{
    if (n == 1)
    {
        ZeroOnePack(w, val, vol);
        return ;
    }
    if (w * n >= vol)
    {
        CompletePack(w, val, vol);
        return ;
    }

    for (int rem = 0; rem < w; ++rem)
    {
        int la = 0, ra = -1;
        int lb = 0, rb = -1;
        for (int v = rem, i = 0; v <= vol; v += w, ++i)
        {
            if (la + n == ra && A[la] == B[lb])
                ++la, ++lb;
            else if (la + n == ra)
                ++la;

            ++ra;
            if (dp[v] != INFS)
                A[ra] = dp[v] - i * val;
            else
                A[ra] = INFS;

            //while (lb <= rb && A[ra] < B[rb])
            //    --rb;

            if (lb <= rb)
                rb = BinarySearch(B, lb, rb, A[ra]);
            B[++rb] = A[ra];

            dp[v] = min(dp[v], B[lb] + i * val) ;
        }
    }
}

int main()
{
    int n, vol;
    while (scanf("%d %d", &n, &vol) != EOF)
    {
        int vmax = 0;
        for (int i = 0; i < n; ++i)
        {
            scanf("%d", &V[i]);
            vmax = max(vmax, V[i]);
        }
        for (int i = 0; i < n; ++i)
            scanf("%d", &C[i]);

        vmax >>= 1;
        vmax *= vmax;
        vmax += vol;

        dp[0] = 0;
        for (int v = 1; v <= vmax; ++v)
            dp[v] = INFS;

        for (int i = 0; i < n; ++i)
            MultiplePack(V[i], 1, C[i], vmax);

        for (int i = 0; i < n; ++i)
            for (int v = vmax - V[i]; v >= 0; --v)
                dp[v] = min(dp[v], dp[v + V[i]] + 1);

        if (dp[vol] != INFS)
            printf("%d\n", dp[vol]);
        else
            printf("-1\n");
    }
    return 0;
}