背个背包

OPEN

2019-09-14的沈阳网络赛过去很多天了（8天），现在才来针对里面的C题Dawn-K's water虽然有点晚，但是前有某数论降幂，后有上海网络赛签到提前缀和崩掉······

不管怎么说，由于这次完全背包题的爆炸，我们终于决定要向DP迈进了，为了明年的蓝桥杯和ICPC/CCPC加油💪！

　　　　　　　　　　　　　　

一、0/1背包问题

1. 洛谷P1060：一道板子题，0/1背包昨晚看得脑壳疼还没看懂，可能是大脑这天用太久了，今早看李煜东的书终于大雾🙈，感动

我比较害怕以后又忘了原理，但是自己解释得也不一定比李同学好（主要是懒）

以后忘了的话就扇自己一巴掌然后再看看李的书吧╮(╯▽╰)╭（网上博客还真是没看懂）

但事实是这个板子不是最优！！！emmm李的书还是不太全这个，自己盘里的PDF更细一些

最优的板子在这个博客里找叭~(常数优化见洛谷最近提交码）👇

Code

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#define MS(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e8 + 5;
using namespace std;

int v[30], w[30], f[30005];
//0-1背包,钱数代表容量，v价格*w重要度代表价值
int main()
{
    int N, m;
    scanf("%d %d", &N, &m);
    int vi, wi;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d %d", &v[i], &w[i]);
        w[i] *= v[i];
    }
    for (int i = 1; i <= m; i++)
    {
        for (int j = N; j >= v[i]; j--)
            f[j] = max(f[j - v[i]] + w[i], f[j]);
    }
    printf("%d", f[N]);
    return 0;
}

2. 洛谷P1064： 主角还是金明小朋友，0/1背包的拓展题，可能会让人望而却步，事实上储存思路好了就一样easy

Code

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <vector>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <map>
#include <stack>
#include <cmath>
#define MS(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e8 + 5;
using namespace std;
int fw[100][3], fv[65][3], f[33000];
int main()
{
    int N, m;
    scanf("%d %d", &N, &m);
    int v, w, q;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d %d %d", &w, &v, &q);
        if (!q)//the main part
        {
            fw[i][q] = w;
            fv[i][q] = w * v;
        }
        else if (!fw[q][1])//1st attachment
        {
            fw[q][1] = w;
            fv[q][1] = w * v;
        }
        else//2ed attachment
        {
            fw[q][2] = w;
            fv[q][2] = w * v;
        }
    }
    for (int i = 1; i <= m; i++)
    {
        for (int j = N; j >= 0; j--)
        {
            //main part
            if (j >= fw[i][0])
                f[j] = max(f[j], f[j - fw[i][0]] + fv[i][0]);
            //main + 1st
            if (j >= (fw[i][0] + fw[i][1]))
                f[j] = max(f[j], f[j - fw[i][0] - fw[i][1]] + fv[i][1] + fv[i][0]);
            //main + 2ed
            if (j >= (fw[i][0] + fw[i][2]))
                f[j] = max(f[j], f[j - fw[i][0] - fw[i][2]] + fv[i][2] + fv[i][0]);
            //main + 1st + 2ed
            if (j >= (fw[i][0] + fw[i][1] + fw[i][2]))
                f[j] = max(f[j], f[j - fw[i][0] - fw[i][1] - fw[i][2]] + fv[i][0] + fv[i][1] + fv[i][2]);
        }
    }
    printf("%d\n", f[N]);
    return 0;
}

　　　　　　　　　　　　　　

二、完全背包问题

1. Dawn-K's water：开头肯定就是沈阳网络赛这道啦！（什么？先给板子题？是男人就直接正面干！）

Code

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#define inf 0X7f7f7f7f
#define MS0(x) memset(x,0,sizeof(x)
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e8 + 5;
using namespace std;
int w[1005], v[1005];
ll f[10005];//注意长度int你就等着WA嘤
int main()
{
    int n, m;
    while (scanf("%d %d", &n, &m) != EOF)
    {
        MSI(f);//每次更新f[]，由于是背包取价值最小，故以inf初始化
        f[0] = 0;
        for (int i = 1; i <= n; i++)
            scanf("%d %d", &v[i], &w[i]);
        for (int i = 1; i <= n; i++)
            for (int j = w[i]; j <= 10000; j++)
                f[j] = min(f[j], f[j - w[i]] + v[i]);//同取价值最小用min()
        //得到全部f[]后为了求出购买的重量（>=背包容量m），采用从m到最大值枚举的办法求出最小价值并得到此时的重量i
        ll ans = inf, ans2 = 0;
        for (int i = m; i <= 10000; i++)
        {
            if (ans >= f[i])
            {
                ans = f[i];
                ans2 = i;
            }
        }
        printf("%lld %lld\n", ans, ans2);
    }
    return 0;
}

这个虽说也有模板成分，但是由此出来的模板拓展要记得理解嗷~

万岁我用三天就解决了🙈比数论某降幂轻松多了

2. Jury Compromise：这道题要是日后能自个儿码出来我觉得那时我还是很强的，网上有很多错解，参考博客：CNBLOGS，CSND

代码码了3天，算是很良心了，知识精化在注释里，仔细看看挺好，事实上我觉得这玩意儿算01背包hh（虚脱orz）

Code

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <vector>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <map>
#include <stack>
#include <cmath>
#define inf 0X7f7f7f7f
#define MS_I(x) memset(x,-inf,sizeof(x))
#define MS(x) memset(x,0,sizeof(x))
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e8 + 5;
using namespace std;
int p[201], d[201];
int f[201][801];//20*20*2//我们把m作为v1，p-d作为V2，并考虑到负数下标的问题，所以设大小为800起
//f[i][j] = k表示在到已经选择了i个候选人且（P-D）Weiht为j时P+D的Value
int ans[21], path[201][21][801];//该题网上Blog所有path为二维而非三维的题解全是错的了
int main()
{
    int n, m;
    int t = 0;
    while (scanf("%d %d", &n, &m) && (n != 0 || m != 0))
    {
        t++;
        //记得更新嗷
        MS_I(f);
        MS(p);
        MS(d);
        MS(ans);
        //path三维路径目前题解里有三维数组和二维+vector容器(超省内存，省一半时间)两种存储办法，这里我们用经典三维数组更能直观体现本质三维dp，故将vector注释
        MS(path);
        //vector<int> path[21][801];
        int range = m * 20;
        f[0][range] = 0;//原f[0][0]=0在V2下标问题的处理下也随之变成f[0][m*20] = 0
        for (int i = 1; i <= n; i++)
            scanf("%d %d", &p[i], &d[i]);
        for (int i = 1; i <= n; i++)
            for (int j = m; j >= 1; j--)//逆序（每人最多选一次）(01背包实锤）
                //（题解里这个是f[j][k + p[i] - d[i]] <= f[j - 1][k] + p[i] + d[i]，省去了我这里多出的越界判定，算是一个很好的小优化
                //（不过我是为了按传统套路来硬是WA了n遍才终于改对了！）
                //关于 k = p[i] - d[i] && k - p[i] + d[i] <= 2 * range是由于k - p[i] + d[i]可能越界因此不存在该情况加的判定
                for (int k = p[i] - d[i]; k <= range * 2; k++)
                {
                    path[i][j][k] = path[i - 1][j][k];
                    //而根据之前初始化-inf，故f[j - 1][k - p[i] + d[i]] < 0亦说明不存在该情况排去
                    if (f[j - 1][k - p[i] + d[i]] >= 0 && k - p[i] + d[i] <= 2 * range)//后者没加就WA哭
                    {
                        if (f[j][k] <= f[j - 1][k - p[i] + d[i]] + p[i] + d[i])
                        {
                            f[j][k] = f[j - 1][k - p[i] + d[i]] + p[i] + d[i];
                            path[i][j][k] = i;
                        }
                    }
                }
        int minIndex, mk;
        //得到abs(P - D)最小值k
        for (mk = 0; mk <= range; mk++)
            if (f[m][range - mk] >= 0 || f[m][range + mk] >= 0)
                break;
        (f[m][range - mk] > f[m][range + mk]) ? minIndex = range - mk : minIndex = range + mk;
        //目前f[m][minIndex] = P + D; minIndex = P - D + 20 * m
        //但是不能以为P = (f[m][minIndex] + k) / 2, D同理，因为k自带绝对值属性...所以还是老老实实...
        cout << "Jury #" << t << endl << "Best jury has value ";
        cout << (f[m][minIndex] + minIndex - range) / 2 << " for prosecution and value ";
        cout << (f[m][minIndex] - minIndex + range) / 2 << " for defence:" << endl;
        //以下三行为vector方法代码（超短！）由于按照顺序遍历，最后的路径本身就是有序的，所以直接输出就可以了
        //int tmp = m;
        //for (int i = 0; i < m; i++)
        //    cout << " " << path[m][minIndex][i];
        //下面开始演示三维数组path递归，事实上很好理解的嘛，从后往前
        for (int i = n, j = m, k = minIndex; j >= 1;)
        {
            int r = path[i][j][k];
            ans[j] = r;
            k -= p[r] - d[r];
            j--;
            i = path[r - 1][j][k];
        }
        for (int i = 1; i <= m; i++)
            cout << " " << ans[i];
        printf("\n\n");
    }
    return 0;
}

3. 洛谷P5020-货币系统：虽然好像还有些什么其他的方法，但是我jio得反正用完全装满背包就对了啦~

（dp[m[i]]==1加深了对dp[]的理解好评，这种题其实要想到背包还是好做，但比赛时就看能不能想到了）

Code

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#define inf 0X7f7f7f7f
#define MS_I(x) memset(x,-inf,sizeof(x))
#define MS(x) memset(x,0,sizeof(x))
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 25005;
using namespace std;

int m[105];
int dp[maxn];

int main()
{
    int T;
    scanf("%d", &T);
    while (T--)
    {
        int n, ans = 0, tmax = 0;
        scanf("%d", &n);
        MS(m);
        MS_I(dp);
        dp[0] = 0;
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &m[i]);
            tmax = max(tmax, m[i]);
        }
        for (int j = 1; j <= n; j++)
            for (int k = m[j]; k <= tmax; k++)
                dp[k] = max(dp[k], dp[k - m[j]] + 1);
        for (int i = 1; i <= n; i++)
            if (dp[m[i]] == 1)
                ans++;
        printf("%d\n", ans);
    }
    return 0;
}

三、多重背包问题

完全背包和多重背包都有关于二进制降低时间复杂度的思路（虽然我不知道完全背包上述模板用了个啥）

所以多重背包我们好好学习下这个思想

1. Coins/ POJ || HDOJ : POJ上的数据比HDOJ上的数据要硬一些，本来李同学对于POJ上有别的方法的

但是我由于懒得看选择了更为深奥的楼教主算法——单调队列优化多重背包【Θ(VN)】

而HDOJ上的数据直接用二进制拆分板子转换为0-1背包和完全背包就可以了【Θ(V×∑log n[i])】

Code

① HDOJ：

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#define inf 0X7f7f7f7f
#define MS_I(x) memset(x,-inf,sizeof(x))
#define MS(x) memset(x,0,sizeof(x))
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e5 + 5;
using namespace std;
int dp[maxn];
int a[105], c[105];

int main()
{
    int n, m;
    while (scanf("%d %d", &n, &m) && (n != 0 || m != 0))
    {
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for (int i = 1; i <= n; i++)
            scanf("%d", &c[i]);
        MS_I(dp);
        dp[0] = 0;
        for (int i = 1; i <= n; i++)
        {
            if (c[i] * a[i] >= m)
                for (int j = a[i]; j <= m; j++) //完全背包
                    dp[j] = max(dp[j], dp[j - a[i]] + 1);
            else
            {
                for (int k = 1; k < c[i]; k <<= 1) //binary thought
                {
                    for (int j = m; j >= a[i] * k; j--) //0-1背包
                        dp[j] = max(dp[j], dp[j - a[i] * k] + 1);
                    c[i] -= k;
                }
                if (c[i] > 0)
                    for (int j = m; j >= a[i] * c[i]; j--) //0-1背包
                        dp[j] = max(dp[j], dp[j - a[i] * c[i]] + 1);
            }
        }
        int ans = 0;
        for (int i = 1; i <= m; i++)
        {
            if (dp[i] >= 0)
                ans++;
        }
        printf("%d\n", ans);
    }

    return 0;
}

② POJ：（不知道为什么直接套模板（关键是我还不懂）更加超时，当然简化之后还是过了的）（注释贼多系列+）

强烈要求阿萌本人日后多看这几个博客（啊啊啊楼教主我真的弄不懂啊）👉 CSDN， cnblogs，其他博客1，其他博客2

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <queue>
#define inf 0X7f7f7f7f
#define MS_I(x) memset(x,-inf,sizeof(x))
#define MS(x) memset(x,0,sizeof(x))
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e5 + 5;
using namespace std;

bool dp[maxn], tqueue[maxn];//储存bool值
int a[105], c[105];

int main()
{
    int n, m;
    while (scanf("%d %d", &n, &m) && (n != 0 || m != 0))
    {
        for (int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        for (int i = 1; i <= n; i++)
            scanf("%d", &c[i]);
        MS(dp);
        MS(tqueue);//单调队列初始化


        dp[0] = true;
        for (int i = 1; i <= n; i++)//枚举物品种类
        {
            if (c[i] == 1)//0-1背包
            {
                for (int j = m; j >= a[i]; j--)
                    if (dp[j - a[i]])
                        dp[j] = 1;
            }
            else if (c[i] * a[i] >= m)//完全背包
            {
                for (int j = a[i]; j <= m; j++)
                    if (dp[j - a[i]])
                        dp[j] = 1;
            }
            else
            {
                for (int j = 0; j < a[i]; j++)//枚举余数
                {
                    int haveT = 0, st = 0, ed = -1;//st,ed 为单调队列的开始和结尾（这里算又一次初始化）（并且他们都喜欢这样）
                    //haveT 用于判断队列中是否有一个true值

                    for (int k = j; k <= m; k += a[i])//完全背包model,步长为a[i]
                    //注释写了完全背包 model, 但实际上写成 01 背包 model 也是可以的, 结果与之无关
                    //但写成 01 背包 model 更加合适, 毕竟分组背包的经典解法是转化为 01 背包
                    {
                        if (ed - st == c[i])    //若队列大小达到指定值，第一个元素X1出队。
                            haveT -= tqueue[st++];

                        //元素X2进队,这个地方入队如果是标准nomotone queue alg的话应该会以ele = f[k] - i * w再将ele入队的形式出现（标准模式请见Blog）
                        tqueue[++ed] = dp[k];         //queue[++ed] = dp[v]可以减少判断                                                
                        haveT += dp[k];

                        //haveT为1的条件为【last】haveT + x2 (- x1) >= 0
                        if (haveT)//如果队列中有一个true，则dp[k]为max()即为true
                            dp[k] = 1;
                    }
                }
            }
        }
        int ans = 0;
        for (int i = 1; i <= m; i++)
            ans += dp[i];
        printf("%d\n", ans);
    }
    return 0;
}

四、混合背包问题

首先我们把上述三种背包的代码以函数的形式表现出来方便如背包九讲中的伪代码一般（我实在不想写背包了（望向DFS与BFS））

Code

1. 0-1背包

 

void completePack(int cost, int weight)
{
    for (int v = V; v >= cost; v++)
        dp[v] = max(dp[v], dp[v - cost] + weight);
}

 

2. 完全背包

void completePack(int cost, int weight)
{
    for (int v = cost; v <= V; v++)
        dp[v] = max(dp[v], dp[v - cost] + weight);
}

3. 多重背包

void multiplePack(int cost, int weight, int amount)
{
    if (cost * amount >= V)
        completePack(cost, weight);
    else
    {
        int k = 1;
        while (k < amount)
        {
            zeroOnePack(k * cost, k * weight);
            amount -= k;
            k = 2 * k;
        }
        zeroOnePack(amount * cost, amount * weight);
    }
}

五. 分组背包

洛谷P1757：分组背包的板子题，由于三层循环相互影响不是很方便函数化就和一般的教程一样分开啦~

也像一般教程一样强调一下循环嵌套顺序——先遍历所有组k再遍历V→0最后在组内遍历i进行if判断，然后pair和vector一起的注意事项见代码

#pragma warning (disable:4996)
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#define inf 0X7f7f7f7f
#define MS_I(x) memset(x,-inf,sizeof(x))
#define MS(x) memset(x,0,sizeof(x))
#define MSI(x) memset(x,inf,sizeof(x))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 1e3 + 5;
using namespace std;

int kn, V, n;
int dp[maxn];
int a[maxn], b[maxn];
vector<pair<int, int> > c[maxn];//注意vector和pair右边的> >不要放在一起

int main()
{
    scanf("%d %d", &V, &n);
    int numberG;
    for (int i = 1; i <= n; i++)
    {
        scanf("%d %d %d", &a[i], &b[i], &numberG);
        c[numberG].push_back(make_pair(a[i], b[i]));
        kn++;
    }
    MS(dp);
    for (int k = 1; k <= kn; k++)
        for (int j = V; j >= 0; j--)
            for (int i = 0; i < c[k].size(); i++)
                if (j >= c[k][i].first)
                    dp[j] = max(dp[j], dp[j - c[k][i].first] + c[k][i].second);

    cout << dp[V] << endl;
    return 0;
}

END

目前我们就先将背包学习到这啦~（我都要吐了），今后有遇到背包最好要认出来然后做出来呀🙈，做不出再来这里跪博客了哈哈