bzoj1021 循环的债务 dp + 暴力

1021: [SHOI2008]Debt 循环的债务

Time Limit: 1 Sec   Memory Limit: 162 MB
Submit: 957   Solved: 503
[ Submit][ Status][ Discuss]

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|。

Source

题目思路：      这个问题的思考方式应该是这样的：乍一看，可能会考虑到要暴力一下，其中一种比较合理的暴力方式是对于每一种面值的钱，枚举这种钱在三个人手中的分配数量，比如说100块的钱，一开始三个人分别拥有x1，x2，x3张，我用两层for枚举出结束时可能的分配，设为y1，y2 , y3（枚举y1,y2即可，y3 = x1 + x2 + x3 - y1 - y2）,那么，从

x1、x2、x3到y1、y2、y3最少交换多少张100元呢？设ca = x1 - y1 , cb = x2 - y2，那么最少交换（abs(ca) + abs(cb) + abs(ca + cb)） / 2张100元（为什么除以2？因为一张被交换的纸币在两个人那里各算一次）

        继续观察问题，我们发现其实每个人手里最后所拥有的纸币总金额是确定的，即 初始拥有金额 - 欠别人的金额 + 别人欠他的金额，比如对第一个人来说，他最后手里的钱就是 初始拥有金额 - a + c；也就是说，我们枚举了每种纸币的分配方式，最后如果在这种分配方式下三个人的钱都满足这个人最终手里应该有的纸币总金额，那么这种分配方式就有望成为答案，我们现在需要的就是满足这个条件的分配方案中最好的一个，那么就可以dp解决。

      设dp[i][j][k]表示当前操作到第i种钱币，第一个人有j元，第二个人有k元时的最少交换次数，初始条件是dp[0][第一个人初始金额][第二个人初始金额] = 0，要求的是

dp[6][第一个人结束时应有金额][第二个人结束时应有金额]，有了上面两段的分析，转移方式应该是比较清晰的了，可以看代码。

      综上，dp的含义和方程不是凭空出现的，从想到以暴力枚举分配方式作为切入点才是关键。

#pragma warning(disable:4786)
#pragma comment(linker, "/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<cmath>
#include<string>
#include<sstream>
#include<bitset>
#define LL long long
#define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;++i)
#define mem(a,x) memset(a,x,sizeof(a))
#define lson l,m,x<<1
#define rson m+1,r,x<<1|1
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double PI = acos(-1.0);
const double eps=1e-6;
const int maxn = 1000 + 5;
int dp[7][maxn][maxn] , money[10][10] , tot[10] , val[10] , eval[10];
void init()
{
    mem(dp , INF);
    mem(tot , 0);       mem(eval , 0);
    val[1] = 100;   val[2] = 50 ;   val[3] = 20;
    val[4] = 10;    val[5] = 5;      val[6] = 1;
}
int main()
{
    int a , b , c ;
    while(scanf("%d %d %d" , &a , &b , &c) != EOF){
            init();
            int sum = 0;
            for(int i = 1 ; i <= 3 ; i++){
                for(int j =1 ; j <= 6 ; j++){
                    scanf("%d" , &money[i][j]);
                    tot[j] += money[i][j];
                    sum += val[j] * money[i][j];
                    eval[i] += val[j] * money[i][j];
                }
            }
            dp[0][eval[1]][eval[2]] = 0;
            eval[1] = eval[1] - a + c;      eval[2] = eval[2] - b + a;      eval[3] = eval[3] - c + b;
            if(eval[1] < 0 || eval[2] < 0 || eval[3] < 0){
                puts("impossible");     continue;
            }
            for(int i = 1 ; i <= 6 ; i++){
                for(int j = 0 ; j <= sum ; j++){
                    int remain = sum - j;
                    for(int k = 0 ; k <= remain ; k++){
                        if(dp[i - 1][j][k] == INF)      continue;
                        for(int cnt1 = 0 ; cnt1 <= tot[i] ; ++cnt1){
                            for(int cnt2 = 0 ; cnt2 <= tot[i] - cnt1; ++cnt2){
                                int ca = cnt1 - money[1][i] , cb = cnt2 - money[2][i];
                                int nsuma = j + val[i] * ca , nsumb = k + val[i] * cb;
                                dp[i][nsuma][nsumb] = min(dp[i][nsuma][nsumb] , dp[i - 1][j][k] + (abs(ca) + abs(cb) + abs(cb + ca)) / 2 );
                            }
                        }
                    }
                }
            }
            if(dp[6][eval[1]][eval[2]] == INF)          puts("impossible");
            else                                                   printf("%d\n" , dp[6][eval[1]][eval[2]]);
    }
    return 0;
}