分红酒（广度优先搜索）

标题：分红酒

  有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升 
  开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着。

  允许把酒从一个瓶子倒入另一个瓶子，但只能把一个瓶子倒满或把一个瓶子倒空，不能有中间状态。这样的一次倒酒动作称为1次操作。

  假设瓶子的容量和初始状态不变，对于给定的目标状态，至少需要多少次操作才能实现？

  本题就是要求你编程实现最小操作次数的计算。
  输入：最终状态（逗号分隔）
  输出：最小操作次数（如无法实现，则输出-1）

例如：
输入：
9,0,0,0
应该输出：
0

输入：
6,0,0,3
应该输出：
-1

输入：
7,2,0,0
应该输出：
2

 

最初做这道题的时候，并没有任何思路。

最近准备软件大赛的时候，刚好看到这题，我便开始用刚学会的深搜来解决，结果发现不太实际，自己的代码也没有通过。

后来听同学说，遇到这种求最小次数等的问题最好用广搜，所以便开始学习广搜，结果如此奇妙，果然还是广搜的效率高很多。

通过学习大牛的思路，终于理解了这道题，通过我自己的代码和注释，希望对别人有所帮助。

 

#include<iostream>   
#include<queue>   
using namespace std;   
         
typedef struct   
{   
    int now[4];   
    int step;   
}state;   
int full[4] = {9 , 7 , 4 , 2};   
int vis[10][8][5][3];  //用来判断是否是已经记录的状态   
         
int bfs(state& temp , int i , int j)   
{   
    if(i == j) return 0;  //i中的水不能倒在i中   
    if(temp.now[i] == 0) return 0;  //i中没有水，不能操作   
    if(temp.now[j] == full[j]) return 0;  //j中水已满，不能操作   
    if(temp.now[i] + temp.now[j] <= full[j])  //进入倒水环节   
    {   
        temp.now[j] = temp.now[j] + temp.now[i];  //将i中的水全部倒入j中   ******   
        temp.now[i] = 0;   
    }   
    else                                  //将j倒满   
    {   
        temp.now[i] = temp.now[i] - (full[j] - temp.now[j]);   
        temp.now[j] = full[j];   
    }   
    if(vis[temp.now[0]][temp.now[1]][temp.now[2]][temp.now[3]])   
    {return 0;}   
    else vis[temp.now[0]][temp.now[1]][temp.now[2]][temp.now[3]] = 1;   
    temp.step++;   
    return 1;   
}   
int main()   
{   
    int end[4];   //需要输入的最后状态   
    int i , j , flag;   
    while(cin>>end[0]>>end[1]>>end[2]>>end[3])   
    {   
        queue<state>q;   
        flag = 0;   
        memset(vis , 0 , sizeof(vis));   
        if(end[0]+end[1]+end[2]+end[3]!=9)  //非法状态   
        {cout<<"-1"<<endl;flag = 1;}   
        if(end[0]>full[0]||end[1]>full[1]||end[2]>full[2]||end[3]>full[3])    
        {cout<<"-1"<<endl;flag = 1;}  //非法状态   
        state star;      //初始状态  初始化   
        star.now[0] = 9;   
        star.now[1] = 0;   
        star.now[2] = 0;   
        star.now[3] = 0;   
        star.step = 0;   
        q.push(star);    //将初始状态压入队列   
        while(!q.empty())   
        {   
            state temp = q.front();   
            q.pop();   
            if(temp.now[0]==end[0]&&temp.now[1]==end[1]&&temp.now[2]==end[2]&&temp.now[3]==end[3])   
            {   
                flag = 1;   
                printf("%d\n" , temp.step);   
                break;   
            }   
            for(i = 0; i < 4; i++)   
            {   
                for(j = 0; j < 4; j++)   
                {   
                    state temp2 = temp;   
                    if(bfs(temp2 , i , j))   
                         q.push(temp2);   
                }   
            }   
        }   
        if(!flag)  cout<<"-1"<<endl;   
    }   
    return 0;   
}