BZOJ1021 [SHOI2008]循环的债务

Description

　　Alice、Bob和Cynthia总是为他们之间混乱的债务而烦恼，终于有一天，他们决定坐下来一起解决这个问题。
不过，鉴别钞票的真伪是一件很麻烦的事情，于是他们决定要在清还债务的时候尽可能少的交换现金。比如说，Al
ice欠Bob 10元，而Cynthia和他俩互不相欠。现在假设Alice只有一张50元，Bob有3张10元和10张1元，Cynthia有3
张20元。一种比较直接的做法是：Alice将50元交给Bob，而Bob将他身上的钱找给Alice，这样一共就会有14张钞票
被交换。但这不是最好的做法，最好的做法是：Alice把50块给Cynthia，Cynthia再把两张20给Alice，另一张20给
Bob，而Bob把一张10块给C，此时只有5张钞票被交换过。没过多久他们就发现这是一个很棘手的问题，于是他们找
到了精通数学的你为他们解决这个难题。

Input

　　输入的第一行包括三个整数：x1、x2、x3（-1,000≤x1，x2，x3≤1,000），其中 x1代表Alice欠Bob的钱（如
果x1是负数，说明Bob欠了Alice的钱） x2代表Bob欠Cynthia的钱（如果x2是负数，说明Cynthia欠了Bob的钱） x3
代表Cynthia欠Alice的钱（如果x3是负数，说明Alice欠了Cynthia的钱）
接下来有三行
每行包括6个自然数：
a100，a50，a20，a10，a5，a1
b100，b50，b20，b10，b5，b1
c100，c50，c20，c10，c5，c1
a100表示Alice拥有的100元钞票张数，b50表示Bob拥有的50元钞票张数，以此类推。
另外，我们保证有a10+a5+a1≤30，b10+b5+b1≤30，c10+c5+c1≤30，而且三人总共拥有的钞票面值总额不会
超过1,000。

Output

　　如果债务可以还清，则输出需要交换钞票的最少张数；如果不能还清，则输出“impossible”（注意单词全部
小写，输出到文件时不要加引号）。

Sample Input

输入一
10 0 0
0 1 0 0 0 0
0 0 0 3 0 10
0 0 3 0 0 0
输入二
-10 -10 -10
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

Sample Output

输出一
5
输出二
0

HINT

对于100%的数据，x1、x2、x3 ≤ |1,000|。

题解

可以发现他们把钱还清等价于三个人最后持有的钱数为他们应该有的钱（即他们本来有的减他们欠别人的加别人欠他们的）。

设他们的目标钱数分别是$Ta,Tb,Tc$，

令$f_{k,i,j}$表示只使用第$k$种至第$5$种（种类为$0..5$）钱币，且现在A持有$i$元，B持有$j$元（C持有$S-i-j$元，其中$S$是总钱数），在此条件下要使他们达到目标状态最少需要交换多少钱币。

边界条件：

$$f_{6,i,j}=\begin{cases}
0 & i = Ta, j = Tb\\
\infty & otherwise
\end{cases}$$

转移时，由于A给B钱B再给C钱没有必要（如果B给C的比A给B的多，转化为A给C，B给C；否则，转化为A给B，A给C），所以只有6种情况，即某两个人都给另一个人，或某一个人给另外两个人（其实还有某个人不参与交换或全都不交换，只需看做给了0个，也可以当成上述六种情况之一）。

从大到小转移时由于好多状态用不到（比如A本来有103元时$f_{1,102,0}$用不到，因为只有整百地取），记忆化搜索即可。

代码中加了一个剪枝：若某人把剩下的钱还完也还不清，直接返回INF。

加了这个剪枝后运行时间少了近一半。（bzoj上1312s->764s）

附代码：

#include <algorithm>
#include <cstdio>
using std::min;
const int N = 1050;
const int INF = 100000000;
int f[6][N][N];
int a[6], b[6], c[6];
int sa[6], sb[6], sc[6], sum;
const int v[6] = {100, 50, 20, 10, 5, 1};
int Ta, Tb, Tc;
int dfs(int k, int aa, int bb) {
  if (k == 6) return aa == Ta && bb == Tb ? 0 : INF;
  int cc = sum - aa - bb;
  if (aa - Ta > sa[k] || bb - Tb > sb[k] || cc - Tc > sc[k])
    return INF;
  if (~f[k][aa][bb]) return f[k][aa][bb];
  int &ans = f[k][aa][bb];
  ans = INF;
  for (int lac = 0; lac <= a[k]; ++lac)
    for (int lbc = 0; lbc <= b[k]; ++lbc)
      ans = min(ans, dfs(k + 1, aa - lac * v[k], bb - lbc * v[k]) + lac + lbc);
  for (int lab = 0; lab <= a[k]; ++lab)
    for (int lcb = 0; lcb <= c[k]; ++lcb)
      ans = min(ans, dfs(k + 1, aa - lab * v[k], bb + (lab + lcb) * v[k]) + lab + lcb);
  for (int lba = 0; lba <= b[k]; ++lba)
    for (int lca = 0; lca <= c[k]; ++lca)
      ans = min(ans, dfs(k + 1, aa + (lba + lca) * v[k], bb - lba * v[k]) + lba + lca);
  for (int lac = 0; lac <= c[k]; ++lac)
    for (int lbc = 0; lbc + lac <= c[k]; ++lbc)
      ans = min(ans, dfs(k + 1, aa + lac * v[k], bb + lbc * v[k]) + lac + lbc);
  for (int lab = 0; lab <= b[k]; ++lab)
    for (int lcb = 0; lcb + lab <= b[k]; ++lcb)
      ans = min(ans, dfs(k + 1, aa + lab * v[k], bb - (lab + lcb) * v[k]) + lab + lcb);
  for (int lba = 0; lba <= a[k]; ++lba)
    for (int lca = 0; lca + lba <= a[k]; ++lca)
      ans = min(ans, dfs(k + 1, aa - (lba + lca) * v[k], bb + lba * v[k]) + lba + lca);
  return ans;
}
int main() {
  int gab, gbc, gca;
  scanf("%d%d%d", &gab, &gbc, &gca);
  for (int i = 0; i < 6; ++i) scanf("%d", &a[i]);
  for (int i = 0; i < 6; ++i) scanf("%d", &b[i]);
  for (int i = 0; i < 6; ++i) scanf("%d", &c[i]);
  sa[5] = a[5];
  for (int i = 4; ~i; --i) sa[i] = sa[i + 1] + a[i] * v[i];
  sb[5] = b[5];
  for (int i = 4; ~i; --i) sb[i] = sb[i + 1] + b[i] * v[i];
  sc[5] = c[5];
  for (int i = 4; ~i; --i) sc[i] = sc[i + 1] + c[i] * v[i];
  Ta = sa[0] - gab + gca;
  Tb = sb[0] - gbc + gab;
  Tc = sc[0] - gca + gbc;
  if (Ta < 0 || Tb < 0 || Tc < 0) return puts("impossible"), 0;
  std::fill(f[0][0], f[6][0], -1);
  int ans = dfs(0, sa[0], sb[0]);
  if (ans > 1000) return puts("impossible"), 0;
  printf("%d\n", ans);
  return 0;
}