水杯倒水问题

#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 /*下面定义结点的类型*/
 #define Min(a,b) ((a>b)?b:a)
 //宏定义的操作符Min作用 取最小值; 
 const int MAX=1010;
 //解答树的结点最多 
 typedef struct Node
 {
     int v[3];//三个杯子的剩余水量;
     int fa;//第一次访问到这个结点是的前一个结点的下标；
     //通过下标可以随机访问真不错; 
      int last_op;//记录从上个结点到这个结点的变化方式
      //last_op认为是两位数字,第一位表示往外倒水的杯子
      //的编号,第二位表示被倒入水的杯子; 
     int  deepth;
     //记录从原始状态到这个状态变化的最少的步数;也就是解答树的深度； 
 }Node; 
 int cup_capacity[3];//存储三个杯子的容量； 
 int water_to_get; //存储要量出的水量; 
 Node  q[MAX*MAX]; //定义这么多个状态组成的数组; 用这个数组来表示队列真不错; 
 int vis[MAX][MAX];//两个下标分别是中杯的余量和小杯的余量; 
 void print_path(int destination);//函数的作用是输出从下标为0到下标为destination的结点的路径; 
 void bfs();//breath-first-search;广度优先遍历 ;
 int main()
 {
     /*首先读入三个杯子的容量和要量出的水量*/
     scanf("%d%d%d%d",&cup_capacity[0],&cup_capacity[1],&cup_capacity[2],&water_to_get);
     /*进行遍历搜索*/
     memset(vis,0,sizeof vis);//sizeof 对于变量名可以不用括号 表明 它并不是一个函数 ;
     /*
     memset()起初是为字符数组赋值的所以需要包含头文件string.h，
     但是它可以为结构体，一维数组，二维数组等赋值了 ;
     这里其实并不需要赋值，因为全局变量已经被初始化了; 
     */ 
     bfs();
     return 0; 
 } 
 void bfs()
 {
     q[0].v[0]=cup_capacity[0];
     q[0].v[1]=q[0].v[2]=0;
     q[0].fa=0;//因为第一个结点没有父节点了; 
     q[0].deepth=0;//也可以不写这些0;因为全局变量会自动初始化; 
     q[0].last_op=0;//因为是第一个结点 ;
     vis[q[0].v[1]][q[0].v[2]]=1;//表示这个结点已经在队列里了
     //如果在遇到它就不再将它放进队列了; 
     //上个句子也可以这么写vis[0][0]=1; 
     int front=0,rear=1;//模拟队列;可以实现广度优先遍历; 
     while(front<rear)
     {
         Node N=q[front];//当前队列中将要访问的变量;
         if(N.v[0]==water_to_get||N.v[1]==water_to_get||N.v[2]==water_to_get)
         {//如果当前结点正好就是要访问的,那么就来输出它的路径; 
             //首先输出需要的步数;
             printf("%d\n",N.deepth);
             //然后调用递归函数依次输出各个中间状态;
             print_path(front); 
             return;
         }
         for(int i=0;i<3;i++)//往外倒水的杯子进行枚举;
         {
             
             for(int j=0;j<3;j++)//被倒入水的杯子的枚举;
             {//i！=j;是避免了那些自己往自己里面倒水的情况发生; 
                 Node &IN=q[rear];
                 if(i==j)continue;
                 int amount=Min(N.v[i],cup_capacity[j]-N.v[j]);//这个是用来决定倒出水的多少
                 //要么倒水的杯子倒完；要么被倒入的杯子被倒满; 
                 for (int k=0;k<3;k++)
                 {
                     IN.v[k]=N.v[k];
                 }
                 IN.v[i]=N.v[i]-amount;//从i杯倒出amount量的水； 
                 IN.v[j]=N.v[j]+amount;//倒入j杯amou量的水;
                 //至此就产生了一个状态；然后就要看它是否已经存在于队列里面了; 
                 if(!vis[IN.v[1]][IN.v[2]])
                 {
                     vis[IN.v[1]][IN.v[2]]=1;
                     IN.fa=front;//设置父节点的下标；
                     IN.deepth=N.deepth+1;//设置最少步骤数；
                     IN.last_op=10*i+j;//记录变换的方法;
                     
                     rear++; 
                 }//if
             } //for(j)
         } //for(i)
         front++;//从队列的下一个结点向下一次考察; 
          
     }//while
 }
 void print_path(int destination)
 {
     if(q[destination].fa!=destination)
     {
         print_path(q[destination].fa);//先找到原始的元素;递归栈机制可以记得路径 
         int from=q[destination].last_op/10,to=q[destination].last_op%10;
         int num=q[q[destination].fa].v[from]-q[destination].v[from];
         printf("cup %d (-%d)->cup %d\n",from,num,to); 
     }
     printf("(%d,%d,%d)\n",q[destination].v[0],q[destination].v[1],q[destination].v[2]);
     
 }