PKU 1276 Cash Machine

题目见此：http://poj.grids.cn/practice/1276

解题思路：

1. 一看就是多重背包，没什么说的了……
2. 一开始不会单调队列优化，后来写了个优化了，可以对照着看看，加深理解

未用单调队列优化：

#include <iostream>
#include <string.h>
using namespace std;
#define sum(a, b) a+b
const int MAXN = 11, MAXV = 100010;
int f[MAXV], c[MAXN], w[MAXN], n[MAXN], N, V;

void Pack_01(int cost, int weigh)
{
    for(int j=V ; j>=cost ; j--)
        f[j] = max(f[j], f[j-cost]+weigh);
}
void Pack_Com(int cost, int weigh)
{
    for(int j=cost ; j<=V ; j++)
        f[j] = max(f[j], f[j-cost]+weigh);
}
void Pack_Mul(int cost, int weigh, int amount)
{
    if(cost * amount >= V)
    {    Pack_Com(cost, weigh);    return;}
    for(int k=1 ; k<amount ; k=k<<1)
    {
        Pack_01(k*cost, k*weigh);
        amount -= k;
    }
    Pack_01(amount*cost, amount*weigh);
}

int main()
{
    while(cin >> V)
    {
        memset(f, 0, sizeof(f));
        cin >> N;
        for(int i=1 ; i<=N ; i++)
            cin >> n[i] >> c[i];
        for(int i=1 ; i<=N ; i++)
            Pack_Mul(c[i], c[i], n[i]);
        cout << f[V] << endl;
    }
}

 

单调队列优化：

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;

const int MAXV = 100001, MAXN = 1001;
int N, V, f[MAXV], c[MAXN], n[MAXN];

struct MQ
{
    int pos[MAXV], val[MAXV];
    int head, tail, winlen;
    void reset(const int& _winlen)
    {    head = 0, tail = -1, winlen = _winlen;    }
    void push_back(const int& index,const int& _val)
    {
        while(head <= tail && val[tail] < _val)
            tail--;
        pos[++tail] = index;
        val[tail] = _val;
        while(index - pos[head] >= winlen)
            head++;
    }
    int top()
    {    return val[head];    }
}q;

int main()
{
    while(scanf("%d %d", &V, &N) != EOF)
    {
        for(int i=1 ; i<=N ; i++)
            scanf("%d %d", &n[i], &c[i]);
        memset(f, 0, sizeof(f));
        for(int i=1 ; i<=N ; i++)
        {
            if(n[i] == 0)    continue;
            else if(n[i] == 1)
                for(int j=V ; j>=c[i] ; j--)
                    f[j] = max(f[j], f[j-c[i]]+c[i]);
            else if(n[i] > V / c[i])
                for(int j=c[i] ; j<=V ; j++)
                    f[j] = max(f[j], f[j-c[i]]+c[i]);
            else
            {
                for(int d=0 ; d<c[i] ; d++)
                {
                    q.reset(n[i]+1);
                    for(int j=0 ; j<=(V-d)/c[i] ; j++)
                    {
                        q.push_back(j, f[j*c[i]+d]-j*c[i]);
                        f[j*c[i]+d] = q.top() + j*c[i];
                    }
                }
            }
        }
        printf("%d\n", f[V]);
    }
}

理解单调队列优化多重背包的方法，可以看以下两篇文章，比较详细：http://www.cnblogs.com/ka200812/archive/2012/07/11/2585950.html

http://wenku.baidu.com/view/2655b60476c66137ee0619b4.html

我的理解：

1. 原dp方程是：dp[j]=max{dp[j-k*v[i]]+k*w[i]}  (1<=k<=m[i])。首先要清楚为什么原dp方程不能用单调队列优化：因为k的范围：因为k的范围是与j无关的，必须要化简成f(j)<=k<j之类的形式。
2. 那么经过化简（方法见以上两篇文章）：

　　　　dp[λ*c[i]+d] = max(dp[kk*c[i]+d] - kk*w[i]) + λ*w[i]    

　　　　λ表示商，d表示余数，λ*c[i]+d表示原来的j，kk=λ-原来的k，且kk的范围是[λ-n[i], λ]

　　　　这样就满足了单调队列优化的形式，λ*w[i]是不动量，dp[kk*c[i]+d] - kk*w[i]是放入队列中的值，k满足[λ-n[i], λ]，所　以要把λ从小到大循环，注意[λ-n[i], λ]表示原来的j，而插入队列pos中的是λ！！

     3.  要把多重背包中01背包和完全背包的情况分开处理一下，算是一种优化

很适合理解单调队列优化多重背包的一道题~