UVa 10603 - Fill，经典倒水问题+隐式图搜索+dfs - D_Double's Journey - 博客频道 - CSDN.NET

UVa 10603 - Fill，经典倒水问题+隐式图搜索+dfs - D_Double's Journey - 博客频道 - CSDN.NET
类型： 隐式图搜索
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=110&page=show_problem&problem=1544
原题：
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.


样例输入：
2
2 3 4 2
96 97 199 62

样例输出：
2 2
9859 62


题目大意：
有三个杯子它们的容量分别是a,b,c, 并且初始状态下第一个和第二个是空的， 第三个杯子是满水的。可以把一个杯子的水倒入另一个杯子，当然，当被倒的杯子满了或者倒的杯子水完了，就不能继续倒了。
你的任务是写一个程序计算出用最少的倒水量，使得其中一个杯子里有d升水。如果不能倒出d升水的话，那么找到一个d' < d ，使得d' 最接近d。

分析与总结：

因为共有3个水杯， 根据每一杯的水量v1,v2,v3, 可以得到一个状态state(v1,v2,v3); 

为了方便进行dfs搜索的状态转移，可以用两个三维数组volume[3], state[3]分别表示三个杯子的容量和状态。然后会有倒水的动作，可以从第1个杯子倒入第2，3个，从第2个倒入第1，3个等等……所以用两个for循环，可以遍历出所有的倒水方案。

然后注意一些不能倒水的条件，比如要倒的杯子是空的，目标杯子是满的，则不进行倒水的动作。

X. BFS
http://acm.lilingfei.com/uva-10603-fill-%EF%BC%88%E4%BE%8B%E9%A2%987-8%EF%BC%89_41

、vis数组只用开两维

看到讨论中大家都是用的三维数组vis[201][201][201]，其实有了两杯水的数据，第三杯水可以用总量减去两杯水的量得到，所以不需要维护3维数组

2、解的存储

因为题目说如果取不到d，就要打印出比d小的最大的可能解d’以及倒水的量，所以bfs就把所有可能的d以及倒水量都存了下来，如果之前取到过这个d，则判断倒水量是否比之前的少，如果满足要求的话就更新数据。最后从d开始往下减小，遇到第一个取到过的解就打印并返回

3、优先队列

首先要注意这道题问的是倒水量最少，而不是倒水次数最少，而这两者没有必然关系。所以在bfs的时候，就不能用普通queue存储需要遍历的节点，而应该用一个优先队列，让倒水量少的排在前头。

另外在讨论中看到很多人用的是dfs，并且很多人得了TLE。然后大家比较推荐的解法是dijkstra。

1. struct Node {
2. int v[3], dist;
3. bool operator < (const Node& n) const {
4. return dist > n.dist;
5. }
6. };
8. //Global Variables.
9. int vis[maxn][maxn];
10. int ans[maxn];
11. /////
14. void update_ans(Node& u) {
15. for(int i = 0; i < 3; i ++) {
16. int d = u.v[i];
17. if(ans[d] < 0 || u.dist < ans[d]) ans[d] = u.dist;
18. }
19. }
21. void solve(int a, int b, int c, int d) {
22. int cap[3] = {a,b,c};
23. memset(vis, 0, sizeof(vis));
24. memset(ans, -1, sizeof(ans));
26. Node startN;
27. startN.v[0] = startN.v[1] = 0;
28. startN.v[2] = c;
29. startN.dist = 0;
30. priority_queue<Node> q;
31. q.push(startN);
32. vis[0][0] = 1;
33. while(!q.empty()) {
34. Node u = q.top(); q.pop();
35. update_ans(u);
36. for(int i = 0; i < 3; i ++) {
37. for(int j = 0; j < 3; j ++) if(i != j) {
38. if(u.v[j] == cap[j] || u.v[i] == 0) continue; //Empty / Full
39. int amount = min(cap[j] - u.v[j], u.v[i]); //Amount of water to fill
40. Node newN;
41. memcpy(&newN, &u, sizeof(u));
42. newN.v[i] = u.v[i] - amount;
43. newN.v[j] = u.v[j] + amount;
44. newN.dist = u.dist + amount;
45. if(!vis[newN.v[0]][newN.v[1]]) {
46. q.push(newN);
47. vis[newN.v[0]][newN.v[1]] = 1;
48. }
49. }
50. }
51. }
53. while(d>=0) { //print ans
54. if(ans[d] >= 0) {
55. printf("%d %d\n", ans[d], d);
56. return;
57. }
58. d--;
59. }
60. }

http://blog.csdn.net/murmured/article/details/18771149

把能达到的状态看成图上的点，进行BFS。

然后我用的是优先队列，能保证最少倒的条件。（按当前倒的水量维护好了）

bool vis[MAXN][MAXN][MAXN];
int state[3],d,ans;
struct node
{
 int state[3];
 int val;
 node(){}
 node(int aa,int bb,int cc,int dd){ state[0]=aa;state[1]=bb;state[2]=cc;val=dd;}
 bool operator <(const node & x)const
 {
  return val>x.val;
 }
};
void bfs()
{
 memset(vis,0,sizeof(vis));
 priority_queue<node> q;
 q.push(node(0,0,state[2],0));
 vis[0][0][state[2]]=true;
 while(!q.empty())
 {
  node cur=q.top();
  q.pop();

  if(cur.state[0]==d || cur.state[1]==d || cur.state[2]==d)
  {
   ans=cur.val;
   return;
  }

  for(int i=0;i<3;i++)
  {
   for(int j=0;j<3;j++)        //j往i倒水
   {
    if(i==j) continue;     //不能自己给自己倒水
    if(!cur.state[j]) continue; //为空不行
    node temp;
    int *t=temp.state;   //用指针优化下可读性  就是说t和temp.state是一个数组
    if(cur.state[j] + cur.state[i] > state[i]) //超过了容量，只能倒满
    {
     t[i]=state[i];
     t[j]=cur.state[j] + cur.state[i] -state[i];
     t[3-i-j]=cur.state[3-i-j];       //3=0+1+2 所以减去代表剩下的那个
     temp.val=cur.val+state[i] - cur.state[i];
    }
    else
    {
     t[i]=cur.state[j] + cur.state[i];
     t[j]=0;
     t[3-i-j]=cur.state[3-i-j];  
     temp.val=cur.val+cur.state[j];
    }
    if(!vis[ t[0] ][ t[1] ][ t[2] ])  //没访问过才加入队列
    {
     vis[ t[0] ][ t[1] ][ t[2] ]=true;
     q.push(temp);
    }
   }
  }

 }
}

  ans=INF;
  scanf("%d%d%d%d",&state[0],&state[1],&state[2],&d);
  bfs();
  while(ans==INF)
  {
   d--;   
   bfs();
  }
  printf("%d %d\n",ans,d);

Same solution: http://blog.csdn.net/chenguolinblog/article/details/7829360
http://morris821028.github.io/2014/05/05/oj/uva/uva-10603/
http://ng1091.com/blog/archives/291
Read full article from UVa 10603 - Fill，经典倒水问题+隐式图搜索+dfs - D_Double's Journey - 博客频道 - CSDN.NET