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

1、hdu 2126 Buy the souvenirs

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

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

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 using namespace std;
 const int maxn = ;
 const int maxw = ;
 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 = ; i < n; i++) scanf("%d", p + i);
         memset(dp, , sizeof(dp));
         memset(cnt, , sizeof(cnt));
         for (int i = ; i < n; i++)
         {
             for (int v = m; v >= p[i]; v--)
             {
                 if (dp[v - p[i]]+ > dp[v])
                 {
                     dp[v] = dp[v - p[i]]+;
                     cnt[v]=cnt[v-p[i]]==?:cnt[v-p[i]];
                 }
                 else if (dp[v - p[i]] +  == dp[v])
                 {
                     cnt[v] += cnt[v - p[i]]==?:cnt[v-p[i]];
                 }
             }
         }
         if (dp[m] != )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 ;
 }

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

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

 void Init()
 {
     for (int i = ; i < n; i++)
     {
         for (int j = ; 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
 }

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

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

3、uva 674 Coin Change

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

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

 #include<iostream>
 #include<cstring>
 using namespace std;
 const int maxn = ;
 int dp[maxn];
 int cnt[maxn];
 int v[] = {, , , , };
 int main()
 {
     int n;
     while (~scanf("%d", &n))
     {
         memset(dp, , sizeof(dp));
         memset(cnt, , sizeof(cnt));
         cnt[] = ;
         for (int i = ; i < ; 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 ;
 }

4、uva 147 Dollars

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

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

 #include<iostream>
 #include<cstring>
 using namespace std;
 const int maxn = ;
 int dp[maxn];
 long long cnt[maxn];//爆int
 int v[] = { ,,,,,,,,,, };
 //另一种方法：用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 * +0.5);//精度问题
         if (N == )break;
         memset(dp, , sizeof(dp));
         memset(cnt, , sizeof(cnt));
         cnt[] = ;
         for (int i = ; i < ; 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 ;
 }

5、poj 3181 Dollar Dayz

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

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

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 using namespace std;
 const int maxn = ;
 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, , sizeof(dp));
         memset(cnt1, , sizeof(cnt2));
         memset(cnt2, , sizeof(cnt2));

         cnt1[] = ;
         for (int i = ; 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 ;
 }

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

         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 ;
 }

7、poj 2063 Investment

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

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

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

 using namespace std;

 const int maxv = ;
 const int maxn = ;
 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 = ; i < n; i++) scanf("%d%d", val + i, itst + i),val[i]/=;
         int ans = st;
         memset(dp, , sizeof(dp));
         for (int i = ; i < year; i++)
         {
             int tot = ans / ;
             for (int j = ; 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 ;
 }

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 = ;
 const int maxn = ;
 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 = ; i < n; i++) scanf("%d%d", cost + i, dps + i);
         memset(dp, , sizeof(dp));
         int ans = maxt;
         for (int i = ; i < n; i++)
         {
             for (int j =; 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 ;
 }

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 = ;
 const int maxm = ;
 const int maxw = ;

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

 struct node
 {
     int to, len;
     node(int tt=,int ll=):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 = ; i <= N; i++) mp[i].clear();
     memset(ok, , sizeof(ok));
     memset(dp, , sizeof(dp));
     memset(mcost, -, sizeof(mcost));
     memset(indgree, , sizeof(indgree));
 }

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

 void GetMP()
 {
     for (int i = ; 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 = ;
     for (int i = ; i < N; i++) if (indgree[i] == ) q.push(i);
     while (!q.empty())
     {
         int u = q.front();
         q.pop();
         TPOrder[index++] = u;
         int sz = mp[u].size();
         for (int i = ; i < sz; i++)
         {
             int v = mp[u][i].to;
             if (indgree[v])
             {
                 indgree[v]--;
                 if (indgree[v] == ) q.push(v);
             }
         }
     }
 }

 long long Solve()
 {
     long long maxv = , mindis = ;
     for (int i = ; i <= W; i++) mcost[X][i] = ;
     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 = ;
     }
     ok[X] = true;
     for (int j = ; j < N; j++)
     {
         int u = TPOrder[j];
         if (!ok[u])continue;
         int sz = mp[u].size();
         for (int k = ; k < sz; k++)
         {
             int v = mp[u][k].to, len = mp[u][k].len;
             ok[v] = true;
             //先到达
             for (int i = ; 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] == -) mcost[v][i] = mcost[u][i] + len*i;
                     else mcost[v][i] = min(mcost[v][i], mcost[u][i] + len*i);
                 }
                 if (i>&&dp[v][i] == dp[v][i - ]) mcost[v][i] = min(mcost[v][i], mcost[v][i - ]);
             }
             //再购买
             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 = ; 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 ;
 }

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 = ;
 const int maxm = ;
 const int maxk = ;
 const int maxfac = ;
 const int MOD = 1e9 + ;
 int factor[maxm];
 int pos[maxm];
 int LCM[maxm][maxm];

 int dp[][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 = ;
         //找到所有因子(1000以内因子最多只有32个)
         for (int i = ; i <= M; i++)
         {
             if (M%i == ) factor[++cnt] = i,pos[i]=cnt;
         }
         //得到所有因子两两的最小公倍数(该最小公倍数一定是其他某个因子)
         memset(LCM, , sizeof(LCM));
         for (int i = ; 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, , sizeof(dp));
         int now = ;
         for (int i = ; i <= cnt; i++) dp[now][factor[i]][i] = ;
         for (int t = ; t <= K; t++)
         {//选第t个数
             now ^= ;
             memset(dp[now], , sizeof(dp[now]));//注意清零
             for (int sv = t - ; sv <= N; sv++)
             {//和为sv
                 for (int tlcm = ; tlcm <= cnt; tlcm++)
                 {//前一层的LCM
                     if (dp[now ^ ][sv][tlcm] == ) continue;
                     for (int ind = ; 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 ^ ][sv][tlcm]) % MOD;
                     }
                 }
             }
         }
         printf("%d\n", dp[now][N][cnt]);
     }
     return ;
 }

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 = ;
 long long dp[MAXC];
 const long long INF = 0x3f3f3f3f3f3f3f3f;
 const int maxn = ;
 int h[maxn], c[maxn];
 int main()
 {
     int t;
     scanf("%d", &t);
     while (t--)
     {
         int n;
         scanf("%d", &n);
         int sumc = ;
         for (int i = ; i < n; i++) scanf("%d%d", h + i, c + i),sumc+=c[i];
         memset(dp, , sizeof(dp));
         long long ans = ;
         for (int i = ; 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 = ; i <= sumc; i++) ans = max(ans, 1ll*dp[i] * dp[i] - dp[i] * i - i * i);
         printf("%lld\n", ans);
     }
     return ;
 }