UVA10603-Fill（BFS）

Problem UVA10603-Fill

Accept：1162  Submit：10693

Time Limit: 3000 mSec

 Problem Description

There are three jugs with a volume of a, b and c liters. (a, b, and c are positive integers not greater than 200). The first and the second jug are initially empty, while the third is completely filled with water. It is allowed to pour water from one jug into another until either the first one is empty or the second one is full. This operation can be performed zero, one or more times. You are to write a program that computes the least total amount of water that needs to be poured; so that at least one of the jugs contains exactly d liters of water (d is a positive integer not greater than 200). If it is not possible to measure d liters this way your program should find a smaller amount of water d ′ < d which is closest to d and for which d ′ liters could be produced. When d ′ is found, your program should compute the least total amount of poured water needed to produce d ′ liters in at least one of the jugs.

 Input

The first line of input contains the number of test cases. In the next T lines, T test cases follow. Each test case is given in one line of input containing four space separated integers — a, b, c and d.

 Output

The output consists of two integers separated by a single space. The first integer equals the least total amount (the sum of all waters you pour from one jug to another) of poured water. The second integer equals d, if d liters of water could be produced by such transformations, or equals the closest smaller value d ′ that your program has found.

 Sample Input

2

2 3 4 2

96 97 199 62

 

 Sample Ouput

2 2

9859 62

题解：倒水问题，原来只写过步数最少的，而这个题问的是倒水量最少。解决方案是将普通的队列换成优先队列，每次优先取出倒水量最少的节点。

这样做的正确性lrj表示不会证，但是可以从Dijkstra上考虑。把状态看成节点，以两个状态之间倒水量作为边权，问题就成了最短路，正确性还是有保证的。

这个题还有一个要求是如果无解，输出小于需要得到的水量并且距离需要得到水量最近的有解的情况。一开始考虑的是维护一个距离，一个最小倒水量，但是不如lrj的做法方便：直接记录所有解，最后统计答案，代码比较好写。

 #include <bits/stdc++.h>
 #define INF 0x3f3f3f3f
 using namespace std;

 const int maxn = +;

 struct Node{
     int v[];
     int dist;
     Node() {}
     bool operator < (const Node &a)const{
         return dist > a.dist;
     }
 };

 int d,cap[];
 int ans[maxn];
 bool vis[maxn][maxn];

 void update_ans(const Node &u){
     for(int i = ;i < ;i++){
         int d = u.v[i];
         if(ans[d]< || u.dist<ans[d]) ans[d] = u.dist;
     }
 }

 void bfs(){
     Node start;
     start.v[] = ,start.v[] = ,start.v[] = cap[];
     start.dist = ;
     memset(ans,-,sizeof(ans));
     memset(vis,false,sizeof(vis));
     priority_queue<Node> que;
     que.push(start);
     vis[][] = true;
     while(!que.empty()){
         Node top = que.top();que.pop();
         update_ans(top);
         if(ans[d] >= ) break;
         for(int i = ;i < ;i++){
             for(int j = ;j < ;j++){
                 if(i == j) continue;
                 if(top.v[i]== || top.v[j]==cap[j]) continue;
                 int amount = min(top.v[i],cap[j]-top.v[j]);
                 Node Next = top;
                 Next.dist += amount;
                 Next.v[i] -= amount,Next.v[j] += amount;
                 if(!vis[Next.v[]][Next.v[]]){
                     vis[Next.v[]][Next.v[]] = true;
                     que.push(Next);
                 }
             }
         }
     }
     for(int i = d;i >= ;i--){
         if(ans[i] >= ){
             printf("%d %d\n",ans[i],i);
             return;
         }
     }
 }

 int main()
 {
     //freopen("input.txt","r",stdin);
     //freopen("output.txt","w",stdout);
     int iCase;
     scanf("%d",&iCase);
     while(iCase--){
         for(int i = ;i < ;i++){
             scanf("%d",&cap[i]);
         }
         scanf("%d",&d);
         bfs();
     }
     return ;
 }