HDU 1495 非常可乐 (BFS)

非常可乐

                                                                        Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
                                                                                                 Total Submission(s): 7859    Accepted Submission(s): 3141

Problem Description

大家一定觉的运动以后喝可乐是一件很惬意的事情，但是seeyou却不这么认为。因为每次当seeyou买了可乐以后，阿牛就要求和seeyou一起分享这一瓶可乐，而且一定要喝的和seeyou一样多。但seeyou的手中只有两个杯子，它们的容量分别是N 毫升和M 毫升 可乐的体积为S （S<101）毫升　(正好装满一瓶) ，它们三个之间可以相互倒可乐 (都是没有刻度的，且 S==N+M，101＞S＞0，N＞0，M＞0) 。聪明的ACMER你们说他们能平分吗？如果能请输出倒可乐的最少的次数，如果不能输出"NO"。

 

Input

三个整数 : S 可乐的体积 , N 和 M是两个杯子的容量，以"0 0 0"结束。

 

Output

如果能平分的话请输出最少要倒的次数，否则输出"NO"。

 

Sample Input

  
  

   
   7 4 3
4 1 3
0 0 0
  
  

 

Sample Output

  
  

   
   NO
3
  
  

 

               倒水问题，乍一看不知该如何入手，其实自己找三个杯子倒过以后你就会发现，倒水的时候每次就是将一个杯子的水往另外一个杯子里面到，因此也就只有两种情况，一种是一个杯子的水能全部倒入另外一个杯子里面，另一种就是该杯子中的水能将另外一个杯子倒满（可能有剩余，可能没剩余），因此，就用光搜搜索完倒水的所有情况，对判断所有的情况中有没有符合的

          倒水的总的情况的个数并不多，因为所有的情况都是由于各个杯子的容量的差值引起的，只有利用差值才能在没有刻度的情况下倒出不同体积的水

附上代码：

/*
  	a     	  A杯子的总容量
	b     	  B杯子的总容量
	c    	  C杯子的总容量
	t.a(s.a)  A杯子中现有水的体积
	t.b(s.b)  B杯子中现有水的体积
	t.c(s.c)  C杯子中现有水的体积
	t.n(s.n)  倒水的次数 
	a - t.a    A杯子中剩余的体积
	b - t.b    B杯子中剩余的体积
	c - t.c    C杯子中剩余的体积
	t.a - (b - t.b)   把a杯子中的水往b杯子里面倒，且把b杯子倒满（前提是 t.a > (b - t.b)）
	t.b - (c - t.c)            ...
	t.c - (a - t.a)            ...
	v[][][]     数组，用来标记的数组，标记某种状态是否出现过，如果出现过就不再二次判断这种状态
	
	
*/
#include<iostream>
#include <algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct node
{
	int a,b,c,n;
};

int v[103][103][103];

void bfs(int a,int b,int c)
{
	node t,s;
	queue<node> q;
	t.a = a;
	t.b = 0;
	t.c = 0;
	t.n = 0;
	q.push(t);
	while(!q.empty())
	{
		t = q.front();
		v[t.a][t.b][t.c]= 1;     // 在某一种状况下进行倒水，分别分别把a、b、c杯子中的水往外倒的情况 
		if((t.a == a/2 && t.b == a/2)||(t.a == a/2 && t.c == a/2)||(t.b == a/2 && t.c == a/2))
		{
			break;
		}
		q.pop();
		//  将a杯子的水往外倒 
		if(t.a != 0)            // 如果b杯子没有被装满，还剩下t.b的体积可以装 
		{
			if(t.a > b - t.b)             // b杯子中的剩余的体积比a杯子中的水的体积小，
			                              // 将b杯子装满 
			{
				s.a = t.a - (b - t.b);
				s.b = b;
				s.c = t.c;
				s.n = t.n+1;
			}
			else               // 如果b杯子中剩余的体积比a杯子中的水的体积大 
			                   // 则用a杯子中的水把b杯子装满， 
			{
				s.a = 0;
				s.b = t.a + t.b;
				s.c = t.c;
				s.n = t.n+1;
			}
			if(!v[s.a][s.b][s.c])        //如果这种状态没有出现过，进入队列，否则不进入队列 
			{
				v[s.a][s.b][s.c] = 1;   //  进入队列以后将这种状态标记为 1  说明这种状态一出现过了 
				q.push(s);
			}
			 
			if(t.a > c - t.c)    // a杯子中的水杯大于c子中的剩余体积
			                     // 将c杯子全部装满 
			{
				s.a=t.a-(c-t.c);
				s.c=c;
				s.b=t.b;
				s.n=t.n + 1;
			}
			else                 // 在这一点会出现两种情况，（1）：a杯子已经没水了 ，                   
			{                    //这种情况跟原来情况相同，忽略 
				s.a = 0;         // （2）：a杯子有水，但是a杯子中水的体积比c杯子剩余的体积的小 
				s.b = t.b;       //   用a杯子中的水将c杯子装满， 
				s.c = t.a + t.c;
				s.n = t.n + 1;	
			}
			if(!v[s.a][s.b][s.c])
			{
				v[s.a][s.b][s.c] = 1;
				q.push(s);
			}
		}
		//  将b杯子的水往外倒 
		if(t.b != 0)
		{
			if(t.b > a-t.a)
			{
				s.b=t.b-(a-t.a);
				s.a=a;
				s.c=t.c;
				s.n=t.n+1;
			}
			else
			{
				s.a = t.a + t.b;
				s.b = 0;
				s.c = t.c;
				s.n = t.n + 1;
			}
			if(!v[s.a][s.b][s.c])
			{
				v[s.a][s.b][s.c] = 1;
				q.push(s);
			}
			if(t.b > c - t.c)
			{
				s.a = t.a;
				s.b = t.b - (c - t.c);
				s.c = c;
				s.n = t.n + 1;
			}
			else
			{
				s.a = t.a;
				s.b = 0;
				s.c = t.b + t.c;
				s.n = t.n + 1;
			}
			if(!v[s.a][s.b][s.c])
			{
				v[s.a][s.b][s.c] = 1;
				q.push(s);
			}
		}
		//  将c杯子的水往外倒 
		if(t.c != 0)
		{
			if(t.c > a - t.a)
			{
				s.a = a;
				s.b = t.b;
				s.c = t.c - (a - t.a);
				s.n = t.n + 1;
			}
			else
			{
				s.a = t.a + t.c;
				s.b = t.b;
				s.c = 0;
				s.n = t.n + 1;
			}
			if(!v[s.a][s.b][s.c])
			{
				v[s.a][s.b][s.c] = 1;
				q.push(s);
			}
			if(t.c > b - t.b)
			{
				s.a = t.a;
				s.c = t.c - (b - t.b);
				s.b = b;
				s.n = t.n + 1;
			}
			else
			{
				s.c = 0; s.a = t.a;
				s.b = t.b + t.c;
				s.n = t.n + 1;
			}
			if(!v[s.a][s.b][s.c])
			{
				v[s.a][s.b][s.c] = 1;
				q.push(s);
			}
		}
	}
	if(q.empty())
		printf("NO\n");
	else
	{
		while(!q.empty())
		q.pop();
		printf("%d\n",t.n);
	}
	return;
}
int main()
{
	int a,b,c;
	while(scanf("%d%d%d",&a,&b,&c)!=EOF)
	{
	    memset(v,0,sizeof(v));
		if((a + b + c) == 0) break;
		// 只有偶数是才有可能被平分 
		if(a & 1)   //  位运算 与 的关系，奇数的二进制末尾都为1，与 1 位运算 与 结果是 0 ，偶数与 1 进行位运算为 1； 
			printf("NO\n");
		else
			bfs(a,b,c);
	}
	return 0;
}