sduacm2016级暑假集训背包_尼克生日后剩下n瓶苏打水。每瓶由两个值描述:剩余苏打水量ai和瓶子容量bi(ai≤bi)-优快云博客

本文精选了七个经典的算法问题，包括多重背包、动态规划等技术的应用，详细解析了每道题目的解题思路与核心代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

比赛地址
密码：acm2016

A - Cash Machine (POJ1276)

题目链接
【题意】
给出一个价值m，然后给出n，代表n个方案，接着n对代表个数与价值，但不超过m的最大价值
【分析】
多重背包模板题，不用二进制优化也能过，这里用了二进制优化转成01背包做的，然后注意m=0,n!=0的情况不能直接continue掉。。因为后面n!=0还会读数据，GG栽在这里3发。
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =100000 + 10;

int f[MAX_N], w[MAX_N];
int main()
{
    int n,m;
    while (~scanf("%d%d",&m,&n)){
        if (!n){
            puts("0");
            continue;
        }
        memset(f,0,sizeof(f));
        int x, y;
        int cnt = 0;
        for (int i=1;i<=n;i++) {
            scanf("%d%d",&x,&y);
            int t = 1;
            while (t<=x){
                w[++cnt] = t * y;
                x -= t;
                t <<= 1;
            }
            if (x>0){
                w[++cnt] = x * y;
            }
        }
        f[0] = 1;
        for (int i=1;i<=cnt;i++)
            for (int j=m;j>=w[i];j--)
               f[j] = f[j] || f[j-w[i]];
        for (int i=m;i>=0;i--)
        if (f[i]){
            printf("%d\n",i);
            break;
        }
    }
}

B - Balance (POJ1837)

题目链接
【题意】
给出一个天平，共有C个挂钩和G个砝码，并给出这C个挂钩的位置和砝码的权值，求能使得天平平衡的方案数。
【分析】
设f[i][j]表示用i个砝码在j位置的方案数，那么显然有f[i][j] = f[i][j] + f[i-1][j - w[i] * p[k]].
其中1<=i<=G，0<=j<=15000，1<=k<=C
初始值为f[0][7500] = 1; //7500是依题目数据范围而定的，可以更大，不能更小
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =20000 + 10;
const double PI = acos(-1.0);

int f[25][MAX_N];
int p[25],w[25];

int main()
{
    int n,m;
    scanf("%d%d",&m,&n);
    for (int i=1;i<=m;i++) scanf("%d",&p[i]);
    for (int i=1;i<=n;i++) scanf("%d",&w[i]);
    f[0][7500] = 1;
    for (int i=1;i<=n;i++)
        for (int j=0;j<=15000;j++){
            if (f[i-1][j])
                for (int k=1;k<=m;k++)
                    f[i][j+w[i]*p[k]] += f[i-1][j];
        }
    printf("%d\n",f[n][7500]);
}

C - Vacations (Codeforces 698A)

题目链接
【题意】
有n天假期，每天有4种状态，0表示体育馆关闭且没有比赛，1表示体育馆关闭且有比赛，2表示体育馆开启且没有比赛，3表示体育馆开启且有比赛。
不能连续两天去体育馆也不能连续两天打比赛，求最小的休息天数。
【分析】
设f[i][j] 表示第i天做第j件事能得到的最小休息天数，其中1<=i<=n，j = 0，1，2分别表示休息，去体育馆，打比赛。
那么转移方程很容易就可以得出，不细说了，见Code。
最后ans = min(f[n][j])，0<=j<=2
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =100000 + 10;
int f[MAX_N][5];
int a[MAX_N];

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&a[i]);
    memset(f,INF,sizeof(f));
    for (int i=0;i<4;i++) f[0][i] = 0;

    for (int i=1;i<=n;i++){
        switch (a[i]){
            case 0:
                f[i][0] = min(f[i-1][0],min(f[i-1][1],f[i-1][2])) + 1;
                break;
            case 1:
                f[i][0] = min(f[i-1][0],min(f[i-1][1],f[i-1][2])) + 1;
                f[i][2] = min(f[i-1][0],f[i-1][1]);
                break;
            case 2:
                f[i][0] = min(f[i-1][0],min(f[i-1][1],f[i-1][2])) + 1;
                f[i][1] = min(f[i-1][0],f[i-1][2]);
                break;
            case 3:
                f[i][0] = min(f[i-1][0],min(f[i-1][1],f[i-1][2])) + 1;
                f[i][2] = min(f[i-1][0],f[i-1][1]);
                f[i][1] = min(f[i-1][0],f[i-1][2]);
                break;
        }
    }
    int ans = INF;
    for (int i=0;i<3;i++)
        ans = min(ans,f[n][i]);
    printf("%d\n",ans);
}

D - Bottles (Codeforces 730J)

题目链接
【题意】
有n瓶苏打水，其中每瓶中有一些苏打水，给你每瓶苏打水现在的体积，和瓶子的容积，求最小用几个瓶子可以盛下所有的苏打水，且最小需要多少花费，将x升苏打水导入其他瓶子种需要的花费是x。
【分析】
显然最小需要几个瓶子是固定的，只要取体积最大的若干个瓶子，使它们的总体积大于总的苏打水的体积即可，尽管不一定直接选择这些瓶子，但最小的数量使一定的。然后选择某些杯子，倒水总体积就是水的总体积减去这些选中杯内的水。所以我们要在选中杯子的总容积大于等于水的总体积的前提下最大化选中的杯子中的水的总体积。
然后用f[i][j]表示选择了i个杯子，一共j体积的水能够获得的最大体积，然后每次考虑一个杯子时像背包那样考虑加入能不能更新。
最后扫一遍求出第一个>=sum的f[i][j]即可。
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =100 + 10;

int a[MAX_N], b[MAX_N], f[MAX_N][MAX_N*100];

int main()
{
    int n,sum = 0;
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        sum += a[i];
    }
    for (int i=1;i<=n;i++) scanf("%d",&b[i]);
    memset(f,-1,sizeof(f));
    f[0][0] = 0;

    for (int i=1;i<=n;i++)
        for (int j=sum;j>=a[i];j--)
            for (int k=i;k>0;k--) if (f[k-1][j-a[i]]!=-1){
                f[k][j] = max(f[k][j],f[k-1][j-a[i]]+b[i]);

    for (int i=1;i<=n;i++)
    for (int j=sum;j>=0;j--){
        if (f[i][j]>=sum){
            printf("%d %d\n",i,sum - j);
            return 0;
        }
    }
}

E - Sonya and Problem Wihtout a Legend (Codeforces 713C)

题目链接
【题意】
给一个序列，可以进行若干次操作，每次操作选择一个数让它+1或-1，问最少要几次操作使得序列变为严格单调递增序列。
【分析】
//————————————分割线———
直接考虑结果的整个数列，必然存在那么几个数，从始至终，都没有变过，那么假设有一些数会受到这个数影响，比如一个数ai不变，如果aj 是受ai影响，那么就会消耗abs(ai-i-aj+j)，那么我把每一个ai-i设为一个基准线。那么f[ai-i]就是当前基准线花费最小的情况
//————————————分割线———
首先考虑不是严格递减的情况：不严格递减最后修改完成后的各个数一定是原序列中的某一个数。
这个大概可以这么理解：原序列，从左到右扫过去，如果左边的大于右边的，要么左边的减掉使其等于右边的，要么右边的加上使其等于左边的。

于是就可以考虑用dp来做了：
f[i][j]表示序列前i个数都单调递增且第i个数更改为不大于原序列中第j个数的最少代价。
那么 f[i][j]=abs(b[i]−a[j])+min(f[i−1][k]),k≤j

原问题是求严格单调递增，这个可以转化成不严格单调递增：让原序列每个数a[i]减去i
这样转化可行是因为：这里写图片描述
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =3000 + 10;
int a[MAX_N], b[MAX_N];
LL f[MAX_N][MAX_N];

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        a[i] -= i;
        b[i] = a[i];
    }
    sort(b+1,b+n+1);
    for (int i=1;i<=n;i++){
        LL x = f[i-1][1];
        for (int j=1;j<=n;j++){
            x = min(x,f[i-1][j]);
            f[i][j] = abs(a[i]-b[j]) + x;
        }
    }
    LL ans = f[n][1];
    for (int i=2;i<=n;i++)
        ans = min(ans,f[n][i]);
    printf("%I64d\n",ans);
}

F - Couple Cover (Codeforces 691F)

题目链接
【题意】
有n个球，每个球上面有一个分数，两个游戏者分别拿一个球(互换算两种情况)，如果这两个球的分数的乘积≥给定的p，那么游戏者赢，否则它们输。
有m组询问，对于每一组询问输出他们赢的方案数有多少种。
【分析】
我们可以预先处理出来sum[i]数组，代表分数乘积≤sum[i]的方案数，因为n≤1e6，ai≤3e6，而p≤3e6，所以处理出来前3e6个就好，直接用ai表示有多少个i这个数，然后i从1->m，j从1->m枚举sum[i*j] += a[i] * a[j]即可，m表示最大的ai
注意要用long long
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =3000000 + 10;

int a[MAX_N];
LL sum[MAX_N];

int main()
{
    int n, m = 0, x;
    scanf("%d",&n);
    for (int i=1;i<=n;i++){
        scanf("%d",&x);
        m = max(m, x);
        a[x]++;
    }
    for (int i=0;i<=m;i++)
    for (int j=0;j<=m;j++){
        if (i * j > 3e6) break;
        if (i!=j) sum[i*j] += (LL) a[i]*a[j];
        else sum[i*j] += max((LL) a[i]*(a[j] - 1),0LL);
    }
    for (int i=1;i<=3e6;i++) sum[i] += sum[i-1];
    int p;
    scanf("%d",&p);
    while (p--){
        scanf("%d",&x);
        LL N = n;
        printf("%I64d\n",N * (N - 1) - sum[x - 1]);
    }
}

G - Boredom (Codeforces 455A)

题目链接
【题意】
给出一个长度为n的序列，从数列中删除ak，会删除ak+1与ak-1的元素，能得到Σak的分数，求能得到最大的分数。
【分析】
设f[i]代表从该数列中前i个元素删除若干元素能得到的最大分数，那么对于i元素有两种状态
1：i-1已删那么f[i] = f[i-1]
2：i-1不删那么f[i] = f[i-2] + a[i] * i，取两种情况中较大的。
即f[i] = max(f[i-1],f[i-2] + a[i] *i)，a[i]代表i元素的数量，1≤i≤m，m代表出现过的最大元素。
最后答案就是f[m]
要用long long
【Code】

#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;

#define INF 0x3f3f3f3f
typedef long long LL;
const int MAX_N =100000 + 10;

LL a[MAX_N], f[MAX_N];

int main()
{
    LL n, m = 0, x;
    scanf("%I64d",&n);
    for (int i=1;i<=n;i++){
        scanf("%I64d",&x);
        m = max(m,x);
        a[x]++;
    }
    f[0] = 0;
    f[1] = a[1];
    for (int i=2;i<=m;i++)
        f[i] = max(f[i - 1],f[i - 2] + a[i] * i);
    printf("%I64d\n",f[m]);
}