HDU 1495 非常可乐（BFS）

很简单的BFS，由于一个小小BUG，调了一个晚上~

再次接触搜索专题，有了一丝不一样的感觉，再看紫书，才明白其中的一些精华 。

其实，搜索和动归简直是密不可分，什么BFS啊DFS啊其实都是搜索，手段都是一样的，目的也是一样的。

对于搜索，现在逐渐重视到了一个之前忽视的东西：状态。    其实搜索的就是状态，定义的也是状态，剪枝剪掉的还是状态，记忆化搜索保存的也是状态。

对于一个搜索，你会遍历到多少状态，那就是你要花费的时间复杂度（前提是每个状态只遍历一次）。   对于DFS，他并不是每个状态只经过一次的，由于每次都从头开始搜，所以其时间复杂度很高，而BFS他已经将经历过的状态去除了，这就有点像DP，也是每个状态只经历一次。

该题的状态就是三个杯子目前水量的情况。    那么对于每一层，又6种决策，分别是对于每一个杯子，是全部到给其他某个杯子还是要留下一些。

细节参见代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
#include<vector>
#include<queue>
#include<list>
#include<set>
#include<cmath>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int INF = 1e9;
const int maxn = 100 + 5;
int n,m,T,s,t,d[maxn][maxn];
struct node{
    int a,b,c;
    node(int a=0,int b=0,int c=0):a(a),b(b),c(c) {}
    bool operator == (const node& rhs) const {
        return a == rhs.a && b == rhs.b && c == rhs.c;
    }
};
int bfs(int s) {
    queue<node> q;
    memset(d,-1,sizeof(d));
    d[s][0] = 0;
    q.push(node(s,0,0));
    while(!q.empty()) {
        node u = q.front(); q.pop();
        if((u.a == s/2 && u.b == s/2)||(u.a == s/2 && u.c == s/2)||(u.b == s/2 && u.c == s/2))
            return d[u.a][u.b];
        for(int i=1;i<=3;i++) {
            node v = u;
            if(i == 1) {
                if(v.a == 0) continue;
                if(v.a+v.b <= n) { v.b += v.a; v.a = 0; }
                else { v.a -= (n-v.b); v.b = n; }
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }   v = u;
                if(v.a+v.c <= m) { v.c += v.a; v.a = 0; }
                else { v.a -= (m-v.c); v.c = m; }
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }
            }
            else if(i == 2) {
                if(v.b == 0) continue;
                v.a += v.b; v.b = 0;
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }   v = u;
                if(v.b+v.c <= m) { v.c += v.b; v.b = 0; }
                else { v.b -= (m-v.c); v.c = m; }
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }
            }
            else {
                if(v.c == 0) continue;
                v.a += v.c; v.c = 0;
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }   v = u;
                if(v.c+v.b <= n) { v.b += v.c; v.c = 0; }
                else { v.c -= (n-v.b); v.b = n; }
                if(d[v.a][v.b] == -1) {
                    d[v.a][v.b] = d[u.a][u.b] + 1;
                    q.push(v);
                }
            }
        }
    }
    return -1;
}
int main() {
    while(~scanf("%d%d%d",&s,&n,&m)) {
        if(!s && !n && !m) return 0;
        if(s & 1) printf("NO\n");
        else {
            int ans = bfs(s);
            if(ans == -1) printf("NO\n");
            else printf("%d\n",ans);
        }
    }
    return 0;
}