DP专题·三(01背包+完全背包)

1、hdu 2126 Buy the souvenirs

　　题意：给出若干个纪念品的价格，求在能购买的纪念品的数目最大的情况下的购买方案。

　　思路：01背包+记录方案。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn = 35;
const int maxw = 510;
int cnt[maxw];
int dp[maxw];
int p[maxn];
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        for (int i = 0; i < n; i++) scanf("%d", p + i);
        memset(dp, 0, sizeof(dp));
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < n; i++)
        {
            for (int v = m; v >= p[i]; v--)
            {
                if (dp[v - p[i]]+1 > dp[v])
                {
                    dp[v] = dp[v - p[i]]+1;
                    cnt[v]=cnt[v-p[i]]==0?1:cnt[v-p[i]];
                }
                else if (dp[v - p[i]] + 1 == dp[v])
                {
                    cnt[v] += cnt[v - p[i]]==0?1:cnt[v-p[i]];
                }
            }
        }
        if (dp[m] != 0)printf("You have %d selection(s) to buy with %d kind(s) of souvenirs.\n", cnt[m], dp[m]);
        else printf("Sorry, you can't buy anything.\n");
    }
    return 0;
}

 2、hdu 4281 Judges' response(状态压缩+01背包+MTSP问题)

　　题意：有n-1个参赛者，给出裁判和n-1个人的位置坐标、裁判和n-1个人的提问时间（裁判为0）。裁判有最长回答时间。

　　　　问：

　　　　　　①最少需要多少个裁判？

　　　　　　②当裁判数目无穷多时，问从初始点出发去解答参赛者提问后回到初始点的走过的最少距离。

　　思路：第一问可以用状态压缩+01背包解决；第二问MTSP问题

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>

using namespace std;
const int maxn = 16;
const int maxm = 100010;
const int INF = 0x3f3f3f3f;
int n, m,maxtot;
int mp[maxn][maxn];//记录两两之间距离
int st[1 << maxn];//记录可行状态
bool ok[1 << maxn];//标记可行状态
int dp[1 << maxn];//记录当前状态下所需最少的裁判
int x[maxn],y[maxn];//记录坐标
int w[maxn];//记录提问时间
int tdis[maxn][1 << maxn];//tdis[i][j]表示在j状态下最后停在i处时的最小花费
int mdis[1 << maxn];//表示i这种状态下回到起点的最小花费


bool check(int cst)
{
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        if (cst&(1 << i)) sum += w[i];
    }
    return sum <= m;
}

void Init()
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            mp[i][j] = ceil(sqrt(1.0*(x[i] - x[j])*(x[i] - x[j]) + (y[i] - y[j])*(y[i] - y[j])));
        }
    }
    memset(tdis, INF, sizeof(tdis));
    memset(mdis, INF, sizeof(mdis));
    tdis[0][1] = 0;//从起点到起点距离为0
}

int MTSP()
{
    //得到每一条可行路径的最优解
    for (int i = 1; i <= maxtot; i++)
    {
        if (ok[i])
        {
            for (int j = 0; j < n; j++)
            {
                if (i&(1 << j))
                {
                    mdis[i] = min(mdis[i], tdis[j][i]+mp[j][0]);//i这种状态最后回到原点0的最小值={min(tdis[j][i]+mp[j][0])|0<=j<n}
                    for (int k = 0; k < n; k++)
                    {
                        if ((i&(1 << k))==0&&ok[i|(1<<k)])//如果i这种状态到不了位置k,则更新i|(1<<k)状态下到k处的最短距离
                        {
                            tdis[k][i | (1 << k)] = min(tdis[k][i | (1 << k)],tdis[j][i]+mp[j][k]);
                        }
                    }
                }
            }
        }
    }
    //合并操作
    for (int i = 0; i <= maxtot; i++)
    {
        if (i & 1)//如果回到原点（不要求ok[i],因为即使一个人不能完成，多个人一起可以完成）
        {
            for (int j = (i - 1)&i; j; j = (j - 1)&i)//枚举子集
            {
                mdis[i] = min(mdis[i], mdis[j | 1] + mdis[(i - j) | 1]);
            }
        }
    }
    return mdis[maxtot];
}


int main()
{
    while (~scanf("%d%d", &n, &m))
    {
        for (int i = 0; i < n; i++) scanf("%d%d", x + i, y + i);
        for (int i = 0; i < n; i++) scanf("%d", w + i);
        maxtot = (1 << n) - 1;
        int tot = 0;
        memset(ok, 0, sizeof(ok));
        for (int i = 1; i <= maxtot; i++)
        {
            if (check(i))
            {
                ok[i] = true;
                st[tot++] = i;
            }
        }
        //dp求解最小裁判数目
        memset(dp, INF, sizeof(dp));
        dp[0] = 0;
        for (int i = 0; i < tot; i++)
        {
            for (int j = maxtot; j >= 0; j--)
            {
                if (dp[j] != INF && (j&st[i]) == 0)
                {
                    dp[st[i] | j] = min(dp[j] + 1, dp[st[i] | j]);
                }
            }
        }
        int ans1 = 0, ans2 = 0;
        if (dp[maxtot] == INF)
        {
            ans1 = ans2 = -1;
        }
        else
        {
            ans1 = dp[maxtot];
            //求解多旅行商（MTSP）问题
            Init();
            ans2 = MTSP();
        }
        printf("%d %d\n", ans1, ans2);
    }
    return 0;
}

 3、uva 674 Coin Change

　　题意：有5中面值的硬币，需要凑成n元，有多少种方案。

　　思路：完全背包+记录方案数

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 8000;
int dp[maxn];
int cnt[maxn];
int v[] = {1, 5, 10, 25, 50};
int main()
{
    int n;
    while (~scanf("%d", &n))
    {
        memset(dp, 0, sizeof(dp));
        memset(cnt, 0, sizeof(cnt));
        cnt[0] = 1;
        for (int i = 0; i < 5; i++)
        {
            for (int tv = v[i]; tv <= n; tv++)
            {
                if (dp[tv] == dp[tv - v[i]] + v[i]) cnt[tv] += cnt[tv - v[i]];
                else if (dp[tv] < dp[tv - v[i]] + v[i])
                {
                    dp[tv] = dp[tv - v[i]] + v[i];
                    cnt[tv] = cnt[tv - v[i]];
                }
            }
        }
        printf("%d\n", cnt[n]);
    }
    return 0;
}

 4、uva 147 Dollars

　　题意：有11中面值，求凑成n元的方案数

　　思路：先把n转换成整数，然后完全背包

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 30010;
int dp[maxn];
long long cnt[maxn];//爆int
int v[] = { 10000,5000,2000,1000,500,200,100,50,20,10,5 };
//另一种方法：用dp[i][j]表示用前i种硬币，组成j分的种类数，
//状态转移方程：dp[i][j] += DP(i - 1, j - k*d[i])
int main()
{
    double n;
    while (~scanf("%lf", &n))
    {
        int N = int(n * 100+0.5);//精度问题
        if (N == 0)break;
        memset(dp, 0, sizeof(dp));
        memset(cnt, 0, sizeof(cnt));
        cnt[0] = 1;
        for (int i = 0; i < 11; i++)
        {
            for (int tv = v[i]; tv <= N; tv++)
            {
                if (dp[tv] == dp[tv - v[i]] + v[i]) cnt[tv] += cnt[tv - v[i]];
                else if (dp[tv] < dp[tv - v[i]] + v[i])
                {
                    dp[tv] = dp[tv - v[i]] + v[i];
                    cnt[tv] = cnt[tv - v[i]];
                }
            }
        }
        printf("%6.2lf%17lld\n",n, cnt[N]);
    }
    return 0;
}

 5、poj 3181 Dollar Dayz

　　题意：有1~k中面值，凑成n元的方案数。

　　思路：会爆long long,用大数+完全背包。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int maxn = 1010;
int dp[maxn];
long long cnt1[maxn],cnt2[maxn];
const long long MAX = 1e18;
int main()
{
    int n,k;
    while (~scanf("%d%d", &n,&k))
    {
        memset(dp, 0, sizeof(dp));
        memset(cnt1, 0, sizeof(cnt2));
        memset(cnt2, 0, sizeof(cnt2));

        cnt1[0] = 1;
        for (int i = 1; i <=k; i++)
        {
            for (int tv = i; tv <= n; tv++)
            {
                if (dp[tv] == dp[tv - i] + i)
                {
                    cnt2[tv] +=cnt2[tv-i]+(cnt1[tv]+cnt1[tv - i])/MAX;
                    cnt1[tv] = (cnt1[tv] + cnt1[tv - i]) % MAX;
                }
                else if (dp[tv] < dp[tv -i] + i)
                {
                    dp[tv] = dp[tv - i] + i;
                    cnt1[tv] = cnt1[tv - i];
                    cnt2[tv] = cnt2[tv - i];
                }
            }
        }
        if (cnt2[n])printf("%lld%lld\n", cnt2[n], cnt1[n]);
        else printf("%lld\n", cnt1[n]);
    }
    return 0;
}

 6、poj 3260 The Fewest Coins

　　题意：有n种面值的硬币，一位农夫带着每种硬币各ci个去买价值为T的商品，售货员可以找零任意多个硬币。问，农夫交给售货员的硬币和售货员找回的硬币之和最小为多少？

　　思路：对农夫多重背包(二进制优化)，对售货员完全背包，找当前价格tv下的最小硬币数目。确定上限：前者为T+max(vi)*max(vi);后者为max(vi)*max(vi)。（鸽巢原理）（假设存在一种最优支付方案，给了多于t + max_v * max_v的钱，那么商店就会找回多于max_v * max_v的钱，这些硬币的个数大于max_v。设这些硬币的面值分别为a_i，根据鸽笼原理的应用，硬币序列中存在至少两个子序列，这两个子序列的和分别都能被max_v整除。如果我们直接用长度更小的那个子序列换算为面值为max_v的硬币某整数个，再去替换母序列就能用更少的硬币买到商品，形成矛盾。）

鸽巢原理（抽屉原理或狄利克雷原理）的应用：

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

using namespace std;

const int maxv1 = 10000 + 120 * 120 + 10;
const int maxv2 = 120 * 120 + 10;
const int maxn = 110;
const int INF = 0x3f3f3f3f;
int val[maxn];
int num[maxn];
int n, t;
int dp1[maxv1];
int dp2[maxv2];
int main()
{
    while (~scanf("%d%d", &n, &t))
    {
        int maxv = 0;
        for (int i = 0; i < n; i++) scanf("%d", val + i),maxv=max(maxv,val[i]);
        for (int i = 0; i < n; i++) scanf("%d", num + i);
        //农夫多重背包，找tv下最小硬币数
        int maxsum = t + maxv*maxv;
        memset(dp1, INF, sizeof(dp1));
        dp1[0] = 0;
        for (int i = 0; i < n; i++)
        {
            int k = 1;
            bool flag = true;
            while (flag)
            {
                if (k>num[i])
                {
                    k = num[i] - k / 2;
                    flag = false;
                }
                for (int tv = maxsum; tv >= k*val[i]; tv--)
                {
                    dp1[tv] = min(dp1[tv], dp1[tv - k*val[i]] + k);
                }
                k *= 2;
            }
        }
        //销售员完全背包，找tv下最少硬币数
        int maxsum2 = maxv*maxv;
        memset(dp2, INF, sizeof(dp2));
        dp2[0] = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = val[i]; j <= maxsum2; j++)
            {
                dp2[j] = min(dp2[j], dp2[j - val[i]] + 1);
            }
        }

        int ans = INF;
        for (int i = t; i <= maxsum; i++) ans = min(ans, dp1[i] + dp2[i - t]);
        if(ans!=INF)printf("%d\n", ans);
        else printf("-1\n");
    }
    return 0;
}

 7、poj 2063 Investment

　　题意：有若干基金可以选择，初始有一定的资金，问过一定年数后最大的本息？

　　思路：对每一年用完全背包求当前本金下所能获得的最多利润，累加本息。由于题目保证本金和基金的价格都是1000的倍数，dp时可以/1000.

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

using namespace std;

const int maxv = 50100;
const int maxn = 15;
int val[maxn];
int itst[maxn];
int dp[maxv];

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int st, year;
        scanf("%d%d", &st, &year);
        int n;
        scanf("%d", &n);
        for (int i = 0; i < n; i++) scanf("%d%d", val + i, itst + i),val[i]/=1000;
        int ans = st;
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < year; i++)
        {
            int tot = ans / 1000;
            for (int j = 0; j < n; j++)
            {
                for (int tv = val[j]; tv <= tot; tv++)
                {
                    dp[tv] = max(dp[tv], dp[tv - val[j]] + itst[j]);
                }
            }
            ans += dp[tot];
        }
        printf("%d\n", ans);
    }
    return 0;
}

 8、zoj 3623 Battle Ships

　　题意：有一个塔楼，有L点血。有n种船，每时刻在建造的船最多只有一艘。问最少的时间。

　　思路：dp[i]表示前i秒所能造成的最大伤害。dp[i+cost[j]]=max(dp[i+cost[j]],dp[i]+i*dps[j]).可以这么理解，在第i+1到i+cost[j]内建造船j,有i秒可以让其输出。

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

const int maxt = 350;
const int maxn = 35;
int dp[maxt];//dp[i]表示前i秒能造成的最大伤害
int dps[maxn];
int cost[maxn];

int main()
{
    int n, l;
    while (~scanf("%d%d", &n, &l))
    {
        for (int i = 0; i < n; i++) scanf("%d%d", cost + i, dps + i);
        memset(dp, 0, sizeof(dp));
        int ans = maxt;
        for (int i = 0; i < n; i++)
        {
            for (int j =0; j < maxt-cost[i]; j++)
            {
                dp[j + cost[i]] = max(dp[j + cost[i]], dp[j] + j*dps[i]);
                if (dp[j + cost[i]] >= l) ans = min(ans, j + cost[i]);
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

 9、zoj 3524 Crazy Shopping

　　题意：有一个有向无环图，图上有n个点，每个地点有一种占用V空间，价值为W的物品，现在一个人从某点出发，如果背包有C重量的物品，走过路程为K，会消耗C*K的体力，那么在背包容量一定的情况下，我要得到最大的价值需要消耗的最少体力是多少。

　　思路：拓扑排序+完全背包+记录耗能

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

int N, M, W,X;//景点数目、道路条数、背包容量、起始点
const int maxn = 610;
const int maxm = 60010;
const int maxw = 2010;

long long dp[maxn][maxw],mcost[maxn][maxw];//[i][j],表示走到i时，背包装有质量为j的最大价值及其最小耗能

struct node
{
    int to, len;
    node(int tt=0,int ll=0):to(tt),len(ll){ }
};
vector<node>mp[maxn];

int tw[maxn], tv[maxn];//重量及其价值

int TPOrder[maxn];//记录拓扑排序
bool ok[maxn];//表示能否从起点X到达该点
int indgree[maxn];//记录入度

void Init()
{
    X--;
    for (int i = 0; i <= N; i++) mp[i].clear();
    memset(ok, 0, sizeof(ok));
    memset(dp, 0, sizeof(dp));
    memset(mcost, -1, sizeof(mcost));
    memset(indgree, 0, sizeof(indgree));
}

void GetWV()
{
    for (int i = 0; i < N; i++) scanf("%d%d", tw + i, tv + i);
}

void GetMP()
{
    for (int i = 0; i < M; i++)
    {
        int from, to, len;
        scanf("%d%d%d", &from, &to, &len);
        from--, to--;
        mp[from].push_back(node(to, len));//有向边
        indgree[to]++;
    }
}

void GetTP()
{
    queue<int>q;
    int index = 0;
    for (int i = 0; i < N; i++) if (indgree[i] == 0) q.push(i);
    while (!q.empty())
    {
        int u = q.front();
        q.pop();
        TPOrder[index++] = u;
        int sz = mp[u].size();
        for (int i = 0; i < sz; i++)
        {
            int v = mp[u][i].to;
            if (indgree[v])
            {
                indgree[v]--;
                if (indgree[v] == 0) q.push(v);
            }
        }
    }
}

long long Solve()
{
    long long maxv = 0, mindis = 0;
    for (int i = 0; i <= W; i++) mcost[X][i] = 0;
    for (int w = tw[X]; w <= W; w++)
    {
        dp[X][w] = max(dp[X][w], dp[X][w - tw[X]] + tv[X]);
        if (dp[X][w] > maxv) maxv = dp[X][w], mindis = 0;
    }
    ok[X] = true;
    for (int j = 0; j < N; j++)
    {
        int u = TPOrder[j];
        if (!ok[u])continue;
        int sz = mp[u].size();
        for (int k = 0; k < sz; k++)
        {
            int v = mp[u][k].to, len = mp[u][k].len;
            ok[v] = true;
            //先到达
            for (int i = 0; i <= W; i++)
            {
                if (dp[v][i] < dp[u][i])
                {
                    dp[v][i] = dp[u][i];
                    mcost[v][i] = mcost[u][i] + len*i;
                }
                else if (dp[v][i] == dp[u][i])
                {
                    if (mcost[v][i] == -1) mcost[v][i] = mcost[u][i] + len*i;
                    else mcost[v][i] = min(mcost[v][i], mcost[u][i] + len*i);
                }
                if (i>0&&dp[v][i] == dp[v][i - 1]) mcost[v][i] = min(mcost[v][i], mcost[v][i - 1]);
            }
            //再购买
            for (int i = tw[v]; i <= W; i++)
            {
                if (dp[v][i] < dp[v][i - tw[v]] + tv[v])
                {
                    dp[v][i] = dp[v][i - tw[v]] + tv[v];
                    mcost[v][i] = mcost[v][i - tw[v]];
                }
                else if (dp[v][i] == dp[v][i - tw[v]] + tv[v]) mcost[v][i] = min(mcost[v][i], mcost[v][i - tw[v]]);
            }
            //更新ans
            for (int i = 0; i <= W; i++)
            {
                if (dp[v][i] > maxv) maxv = dp[v][i], mindis = mcost[v][i];
                else if (dp[v][i] == maxv) mindis = min(mindis, mcost[v][i]);
            }
        }
    }
    return mindis;
}

int main()
{
    while (~scanf("%d%d%d%d", &N, &M, &W, &X))
    {
        Init();
        GetWV();
        GetMP();
        GetTP();//拓扑排序
        long long ans=Solve();
        printf("%lld\n", ans);
    }
    return 0;
}

 10、zoj 3662 Math Magic

　　题意：定义k个数和为N，k个数的最小公倍数为M，求k个数的方案？

　　思路：滚动数组dp[now][j][k]表示选当前个数的数，和为j，最小公倍数为k的方案数，dp[now][sv + val][LCM[tlcm][ind]] = dp[now][sv + val][LCM[tlcm][ind]] + dp[now ^ 1][sv][tlcm]。所选择的数必须是M的因子。

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
using namespace std;
int N, M, K;
const int maxn = 1010;
const int maxm = 1010;
const int maxk = 110;
const int maxfac = 40;
const int MOD = 1e9 + 7;
int factor[maxm];
int pos[maxm];
int LCM[maxm][maxm];

int dp[2][maxn][maxfac];//滚动数组dp[now][j][k]表示选当前个数的数，和为j，最小公倍数为k的方案数

int Gcd(int a, int b)
{
    if (a < b) a = a^b, b = a^b, a = a^b;
    while (a%b)
    {
        int t = a % b;
        a = b;
        b = t;
    }
    return b;
}
int Lcm(int a, int b)
{
    return a*b / Gcd(a, b);
}
int main()
{
    while (~scanf("%d%d%d", &N, &M, &K))
    {
        int cnt = 0;
        //找到所有因子(1000以内因子最多只有32个)
        for (int i = 1; i <= M; i++)
        {
            if (M%i == 0) factor[++cnt] = i,pos[i]=cnt;
        }
        //得到所有因子两两的最小公倍数(该最小公倍数一定是其他某个因子)
        memset(LCM, 0, sizeof(LCM));
        for (int i = 1; i <= cnt; i++)
        {
            for (int j = i; j <= cnt; j++)
            {
                int lcm = Lcm(factor[i], factor[j]);
                LCM[i][j] = LCM[j][i] = pos[lcm];
            }
        }
        //dp-完全背包
        memset(dp, 0, sizeof(dp));
        int now = 0;
        for (int i = 1; i <= cnt; i++) dp[now][factor[i]][i] = 1;
        for (int t = 2; t <= K; t++)
        {//选第t个数
            now ^= 1;
            memset(dp[now], 0, sizeof(dp[now]));//注意清零
            for (int sv = t - 1; sv <= N; sv++)
            {//和为sv
                for (int tlcm = 1; tlcm <= cnt; tlcm++)
                {//前一层的LCM
                    if (dp[now ^ 1][sv][tlcm] == 0) continue;
                    for (int ind = 1; ind <= cnt; ind++)
                    {//枚举所加的数
                        
                        int val = factor[ind];
                        if (sv + val > N)continue;
                        dp[now][sv + val][LCM[tlcm][ind]] = (dp[now][sv + val][LCM[tlcm][ind]] + dp[now ^ 1][sv][tlcm]) % MOD;
                    }
                }
            }
        }
        printf("%d\n", dp[now][N][cnt]);
    }
    return 0;
}

 11、zoj 3956 Course Selection System

　　题意：有n门课程，每门课有Hi、Ci值。现在需要选若干门课程，使得SumH^2-SumH*SumC-SumC^2值最大。

　　思路：01背包，把C看成体积，H看成价值。当C固定时，求出最大的SumH.最后遍历dp数组得到最大值（如果一个i值不能有Ci值组成，其SumH肯定和小于i的某一个值相同，而那个值的算式结果肯定比其大）

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXC = 50010;
long long dp[MAXC];
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 510;
int h[maxn], c[maxn];
int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        int n;
        scanf("%d", &n);
        int sumc = 0;
        for (int i = 0; i < n; i++) scanf("%d%d", h + i, c + i),sumc+=c[i];
        memset(dp, 0, sizeof(dp));
        long long ans = 0;
        for (int i = 0; i < n; i++)
        {
            for (int j = sumc; j >= c[i]; j--)
            {
                dp[j] = max(dp[j], dp[j - c[i]] + h[i]);
            }
        }
        for (int i = 0; i <= sumc; i++) ans = max(ans, 1ll*dp[i] * dp[i] - dp[i] * i - i * i);
        printf("%lld\n", ans);
    }
    return 0;
}