nyoj21三个无标量水杯_nyoj21 三个水杯 (经典问题 bfs)

本文介绍了一个典型的三水杯问题，并采用广度优先搜索(BFS)算法解决该问题。通过三维数组记录状态，确保了算法的有效性和正确性。代码详细展示了如何通过相互倒水操作来达到目标状态。

汉字题，也就不多说了。
三个水杯，只有最大的满了，只能通过三个水杯不断地相互倒水，以致达到要求的规模。
很容易想到是BFS，最优解一般都是BFS。还有就是三维数组，第一次用三维的数组，感觉其实跟二维的差不多，就是vis函数的功能，没啥变化，要是8个水杯就用八维数组，耍无赖。

#include <iostream>
#include <stdio.h>
#include <queue>
#include <string.h>
using namespace std;
int v[5];
int vis[101][101][101];
struct node{
    int cur[5];
    int step;
};
node s,e;
bool match(node a){
    return (a.cur[1]==e.cur[1]&&a.cur[2]==e.cur[2]&&a.cur[3]==e.cur[3]);
}
int BFS(){
    s.cur[1]=v[1];
    s.cur[2]=s.cur[3]=s.step=0;
    memset(vis,0,sizeof(vis));
    queue<node>Q;
    node a;
    Q.push(s);
    vis[1][0][0]=1;
    while(!Q.empty()){
        a=Q.front();
        Q.pop();
        if(match(a))
            return a.step;
        for(int i=1;i<=3;i++){
            for(int j=1;j<=3;j++){
                if(i!=j){
                    int MIN=min(v[j]-a.cur[j],a.cur[i]);
                    /*最重要的一点，因为当你i向j倒水的时候，是有好几种情况的：j 本来有没有水？满不满？i 有没有水？能不能倒满j?所以最好是进行判断再继续。*/
                    node b=a;
                    b.cur[j]+=MIN;
                    b.cur[i]-=MIN;
                    b.step=a.step+1;
                    if(vis[b.cur[1]][b.cur[2]][b.cur[3]]==0){
                        Q.push(b);
                        vis[b.cur[1]][b.cur[2]][b.cur[3]]=1;
                    }
                }
            }
        }

    }
    return -1;
}
int main(){
    int T;
    cin >>T;
    while(T--){
        cin >>v[1]>>v[2]>>v[3];
        cin >>e.cur[1]>>e.cur[2]>>e.cur[3];
        cout <<BFS()<<endl;
    }
    return 0;
}