NYOJ 21 三个水杯

bfs题，用数组模拟水杯的状态，尝试每一种可能的状态，如果找到就返回，详解见代码注释：

 
#include <cstdio>
#include <iostream>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAX = 100 + 5;
int vis[MAX][MAX][MAX];//标记每一个水杯的状态是否出现过 
typedef struct Node{
    int cur[3];//当前水杯的状态，就是每个水杯有多少水 
    int step;//由初始状态到当前状态一共需要多少次 
}Node;
Node s, e;//s是初始点，e是目标状态点 
int v[3];//保存三个水杯的容量 

bool match(Node t)
{
    //判断是否达到最后的状态 
    return (t.cur[0] == e.cur[0] && t.cur[1] == e.cur[1] && t.cur[2] == e.cur[2]); 
}
int bfs()
{
    s.cur[0] = v[0];
    s.cur[1] = s.cur[2] = s.step = 0;
    queue<Node> q;
    Node p;
    memset(vis, 0, sizeof(vis));
    q.push(s);
    vis[v[1]][0][0] = 1;//标记初始状态已经出现过 
    while (!q.empty())
    {
        p = q.front();
        q.pop();
        if (match(p))//如果找到，直接返回它的step 
            return p.step;
        //遍历六种倒水方式 
        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; ++j)
            {
                if (i != j)//自己不能倒给自己水 
                {
                    /*从i向j水杯中倒水，倒水的量是j水杯的容量将去当前水杯里的水或者是i水杯中有多少水，取他们的最小值
                    因为从i往j中倒水，首先不能倒溜出来，还有就是最多只能把i中的水倒完，就这两种情况，仔细想一下是求他们的最小值*/ 
                    int minn = min(v[j] - p.cur[j], p.cur[i]);
                    Node v = p;//新状态 
                    v.cur[j] += minn;
                    v.cur[i] -= minn;
                    v.step = p.step + 1;//次数加一 
                    if (vis[v.cur[0]][v.cur[1]][v.cur[2]] == 0)//如果以前没有出现过这种状态，就将它入队 
                    {
                        q.push(v);
                        vis[v.cur[0]][v.cur[1]][v.cur[2]] = 1;
                    }
                }
            }
        }
    }
    return -1;
}
int main()
{
    int T;
    cin >> T;
    while (T--)
    {
        cin >> v[0] >> v[1] >> v[2];
        cin >> e.cur[0] >> e.cur[1] >> e.cur[2];
        cout << bfs() << endl;
    }
    return 0;
}