[USACO] 从Mother’s Milk看搜索

  最近由于想锻炼小型程序编写能力，所以打算做完USACO，当然这个是比较水的题目，但对于业余ACM爱好

者的我来说还是有一定难度的，拿来练手和学习还是很不错的。

  Mother’s Milk是一个搜索的题目，总的来说难度不大，但是我在一开始的时候并没有那么轻易的看出状

态的转移方式，在状态转移那里卡了很久，一直在想怎么模拟这个倒水的过程？其实我是陷入题目的误

区，明知道是到搜索题目，就应该以搜索的方式来思考，那么怎么思考搜索题目的解法呢？

  首先，搜索的题目最重要的就是找到状态，就是怎么样一个东西算作此题的状态，亦即解空间的一个节

点，这是首要任务，如果连状态都没定义好，后续的一切都是浮云。

  然后呢，就是要思考从一个状态有几种转移方式，就是从解空间的一个节点出发有条边和其他节点相连，

这样就能够大概估计到解空间的大小，以考虑是用深搜呢，还是广搜。如果空间需求不大，解可能在离根节

点较近的地方，就果断广搜，其他就深搜吧。我广搜一般是用队列，深搜是用递归实现的，这中间要考虑几点：

•   考虑用何种方式判重？（布尔数组？）
•   考虑是否可以剪枝？（例如USACO的 The Clocks要考虑到同一种类型的旋转转3次后会回到原点，

因此果断剪掉3次以上同类型旋转）

  最后就是编码实现了，然后考虑各种优化问题，例如查找改成哈希等等。

  用这种想法思考Mother’s milk， 考虑到状态就是 (A桶中牛奶的数量,B桶中牛奶的数量)，因为牛奶的

总数量是确定的，所以上述序列足可确定一个解空间的节点。然后思考可以有几种转移方式？很明显，总共

三个桶，因此就是6种：A->B A->C B->A B->C C->A C->B。以A->B来说，这样转移之后状态是什么呢？A的

牛奶数应该是max(0, a+b-B），其中a，b是A和B桶中原来牛奶的数量，A,B是A和B桶的容量。B的牛奶数是

min(a+b, B)，其他的以此类推。

  估算一下解空间的大小吧，由于题目限制A,B,C的值是1-20之间，所以总共的状态，最多，也就

20*20=400,所以，用广搜就行。代码如下：

  1: /*
  2: ID:happyan3
  3: PROG:milk3
  4: LANG:C++
  5: */
  6: 
  7: #include <iostream>
  8: #include <fstream>
  9: #include <queue>
 10: #include <vector>
 11: #include <algorithm>
 12: #include <cstring>
 13: #include <cstdlib>
 14: #include <bitset>
 15: 
 16: using namespace std;
 17: 
 18: struct state
 19: {
 20:  int a;
 21:  int b;
 22:  int c;
 23: };
 24: 
 25: const int num=21;
 26: bool bFlag[num][num];//判重
 27: 
 28: //广搜
 29: //pre: 输入a,b,c是 桶的容量
 30: //post: 输出res，是 c的可能数，未排序
 31: void GetAnswer(int a, int b, int c, vector<int>& res)
 32: {
 33:  state init_state;
 34:  init_state.a=0;
 35:  init_state.b=0;
 36:  init_state.c=c;
 37: 
 38:  queue<state> q;
 39:  q.push(init_state);
 40:  while(!q.empty())
 41:  {
 42:   state s = q.front();
 43:   q.pop();
 44:   if(s.a>=0 && s.b>=0 && s.c>=0)
 45:   {
 46:    if(s.a==0)
 47:    {
 48:     if(res.end()==find(res.begin(),res.end(),s.c))
 49:      res.push_back(s.c);
 50:    }
 51:    bFlag[s.a][s.b]=true;
 52:    //all 6 possibilities 
 53:     
 54:    state temp = s;
 55:    //1 a->b
 56:    s.a = max(0,s.a+s.b-b);
 57:    s.b = min(temp.a+s.b,b);
 58:    if(!bFlag[s.a][s.b])
 59:     q.push(s);
 60:    s=temp;
 61: 
 62:    //2 a->c
 63:    s.a = max(0,s.a+s.c-c);
 64:    s.c = min(temp.a+s.c,c);
 65:    if(!bFlag[s.a][s.b])
 66:     q.push(s);
 67:    s=temp;
 68: 
 69:    //3 b->a
 70:    s.b = max(0,s.b+s.a-a);
 71:    s.a = min(temp.b+s.a,a);
 72:    if(!bFlag[s.a][s.b])
 73:     q.push(s);
 74:    s=temp;
 75: 
 76:    //4 b->c
 77:    s.b = max(0,s.b+s.c-c);
 78:    s.c = min(temp.b+s.c,c);
 79:    if(!bFlag[s.a][s.b])
 80:     q.push(s);
 81:    s=temp;
 82: 
 83:    //5 c->b
 84:    s.c = max(0,s.c+s.b-b);
 85:    s.b = min(temp.c+s.b,b);
 86:    if(!bFlag[s.a][s.b])
 87:     q.push(s);
 88:    s=temp;
 89: 
 90:    //6 c->a
 91:    s.c = max(0,s.c+s.a-a);
 92:    s.a = min(temp.c+s.a,a);
 93:    if(!bFlag[s.a][s.b])
 94:     q.push(s);
 95:    s=temp;
 96:   }
 97:  }
 98: }
 99: 
100: int main(void)
101: {
102:  ifstream fin;
103:  fin.open("milk3.in");
104:  ofstream fout;
105:  fout.open("milk3.out");
106: 
107:  int a=0;
108:  int b=0;
109:  int c=0;
110:  fin>>a>>b>>c;
111: 
112:  for(int i=0; i < num; i++)
113:  {
114:   for(int j=0; j < num; j++)
115:    bFlag[i][j]=false;
116:  }
117: 
118:  vector<int> res;
119: 
120:  GetAnswer(a,b,c,res);
121: 
122:  sort(res.begin(),res.end());
123:  for(vector<int>::iterator it=res.begin(); it!=res.end()-1; it++)
124:  {
125:   fout<<(*it)<<" ";
126:  }
127: 
128:  fout<<res.back()<<endl;
129: 
130:  fin.close();
131:  fout.close();
132:  //getchar();
133:  //getchar();
134:  //getchar();
135:  return 0;
136: }

/*