调酒壶里的酸奶

最近小w学了一手调酒的技巧，这么帅的操作，说不定能靠这个俘获女神的芳心，为了在女神面前露一手，他想在学校里建一个"pub"，但是显然学校不可能让他真的建一个"pub"，那么他退而求次，想建一个"Yogurt shop"，不能用酒，那用酸奶也行啊！
今天女神终于来光顾小w的酸奶店了！兴奋的小w拿出自己准备已久每天都仔细擦干净的装备——调酒壶、果汁机、隔冰器和计量杯、砧板、小刀....准备露一手给女神看看
但是女神却没有那么多耐心，女神只是觉得，自己买一瓶大酸奶喝不完，小瓶酸奶不够喝，所以在小w的酸奶店，说不定她可以想买多少就买多少。
于是女神告诉了小w她想要多少体积的酸奶，而小w却依旧想秀一下自己的操作，于是他决定用仅有的两个调酒壶为女神倒出女神想要的酸奶....
小w的两个调酒壶体积是不同的(一开始都是空的)，小w每次可以选择一个调酒壶倒入另一个调酒壶（若A倒入B，A倒完或B倒满则停止），或者选择一个调酒壶倒光，或者选择一个调酒壶去接满酸奶.....
满心失望的小w想找一朵花，一瓣一瓣的撕下来，问问花朵女神到底喜不喜欢他...虽然这个答案是显而易见的，但是他还是想找一朵花...然而找花未果，反正花瓣不是偶数就是奇数，那他索性就用自己的操作次数作为花瓣个数吧！（找不到花我还不能脑补一朵吗...）
但是小w已经没有心情去想答案了...那么你能告诉他，需要多少步操作才能倒出女神想要的酸奶吗？

 

输入

输入包含多组数据，每行三个正整数a,b,c分别表示两个调酒壶的容量以及女神想要的酸奶体积,a,b的范围都在[0,100]，c<=max(a,b)   

 

输出

一行包含一个整数表示完成要求的最少操作次数，若达不到则输出"impossible"（没有双引号）

 

样例输入

复制样例数据

10 15 11
6 5 4

样例输出

impossible
4

 

 

DFS写法：

#include<bits/stdc++.h>

using namespace std;
int sum;
int a, b, c;
int zz[105][105];
int gcd(int x,int y){
    if(x<y){
        swap(x,y);
    }
    int t = x%y;
    while(t!=0){
        x = y;
        y = t;
        t = x%y;
    }
    return y;
}
void dfs(int a1,int b1,int step){
    //printf("%d %d %d\n",a1,b1,step);
    if(a1==c||b1==c){
        if(sum>=step){
            sum = step;
            return;
        }
    }
    zz[a1][b1] = 1;
    if(a1+b1>=a){
        if(!zz[a][a1+b1-a]){
            dfs(a,a1+b1-a,step+1);
            zz[a][a1+b1-a] = 0;
        }
    }
    else{
        if(!zz[a1+b1][0]){
            dfs(a1+b1,0,step+1);
            zz[a1+b1][0] = 0;
        }
    }
    if(a1+b1>=b){
        if(!zz[a1+b1-b][b]){
            dfs(a1+b1-b,b,step+1);
            zz[a1+b1-b][b] = 0;
        }
    }
    else{
        if(a1+b1<b){
            if(!zz[0][a1+b1]){
                dfs(0,a1+b1,step+1);
                zz[0][a1+b1] = 0;
            }
        }
    }
    if(!zz[a][b1]){
        dfs(a,b1,step+1);
        zz[a][b1] = 0;
    }
    if(!zz[a1][b]){
        dfs(a1,b,step+1);
        zz[a1][b] = 0;
    }
    if(!zz[0][b1]){
        dfs(0,b1,step+1);
        zz[0][b1] = 0;
    }
    if(!zz[a1][0]){
        dfs(a1,0,step+1);
        zz[a1][0] = 0;
    }
}
int main()
{
    while(cin>>a>>b>>c){
        if(c%gcd(a,b)!=0){
            cout<<"impossible"<<endl;
        }
        else{
            memset(zz,0,sizeof(zz));
            sum = 100000000;
            dfs(0,0,0);
            cout<<sum<<endl;
        }
    }
    return 0;
}

BFS写法：

#include<bits/stdc++.h>

using namespace std;
int sum;
int a, b, z;
int zz[105][105];
bool vv[105][105];
struct Node
{
    int a1,b1;
};
int gcd(int x,int y){
    if(x<y){
        swap(x,y);
    }
    int t = x%y;
    while(t!=0){
        x = y;
        y = t;
        t = x%y;
    }
    return y;
}
int bfs(){
    queue<Node> r;
    Node temp;
    temp.a1 = 0;
    temp.b1 = 0;
    r.push(temp);
    while(r.empty()==false){
        temp = r.front();
        r.pop();
        int c,d;
        c = temp.a1;
        d = temp.b1;
        if(vv[a][d]==false){
            vv[a][d] = true;
            zz[a][d] = zz[c][d]+1;
            Node t1;
            t1.a1 = a;
            t1.b1 = d;
            if(a==z||d==z){
                return zz[a][d];
            }
            r.push(t1);
        }
        if(vv[c][b]==false){
            vv[c][b] = true;
            zz[c][b] = zz[c][d]+1;
            Node t1;
            t1.a1 = c;
            t1.b1 = b;
            if(c==z||b==z){
                return zz[c][b];
            }
            r.push(t1);
        }
        if(vv[c][0]==false){
            vv[c][0] = true;
            zz[c][0] = zz[c][d]+1;
            Node t1;
            t1.a1 = c;
            t1.b1 = 0;
            if(c==z||0==z){
                return zz[a][d];
            }
            r.push(t1);
        }
        if(vv[0][d]==false){
            vv[0][d] = true;
            zz[0][d] = zz[c][d]+1;
            Node t1;
            t1.a1 = 0;
            t1.b1 = d;
            if(d==z||0==z){
                return zz[0][d];
            }
            r.push(t1);
        }
        if(c+d>=a){
            if(vv[a][c+d-a]==false){
                vv[a][c+d-a] = true;
                zz[a][c+d-a] = zz[c][d]+1;
                Node t1;
                t1.a1 = a;
                t1.b1 = c+d-a;
                if(a==z||c+d-a==z){
                    return zz[a][c+d-a];
                }
                r.push(t1);
            }
        }
        else{
            if(vv[c+d][0]==false){
                vv[c+d][0]=true;
                zz[c+d][0] = zz[c][d]+1;
                Node t1;
                t1.a1 = c+d;
                t1.b1 = 0;
                if(c+d==z||0==z){
                    return zz[c+d][0];
                }
                r.push(t1);
            }
        }
        if(c+d>=b){
            if(vv[c+d-b][b]==false){
                vv[c+d-b][b] = true;
                zz[c+d-b][b] = zz[c][d]+1;
                Node t1;
                t1.a1 = c+d-b;
                t1.b1 = b;
                if(c+d-b==z||b==z){
                    return zz[c+d-b][b];
                }
                r.push(t1);
            }
        }
        else{
            if(vv[0][c+d]==false){
                vv[0][c+d]=true;
                zz[0][c+d] = zz[c][d]+1;
                Node t1;
                t1.a1 = 0;
                t1.b1 = c+d;
                if(0==z||c+d==z){
                    return zz[0][c+d];
                }
                r.push(t1);
            }
        }
    }
    return -1;
}
int main()
{
    while(cin>>a>>b>>z){
        memset(zz,0,sizeof(zz));
    memset(vv,false,sizeof(vv));
    int res = bfs();
    if(res==-1){
        cout<<"impossible"<<endl;
    }
    else{
        cout<<res<<endl;
    }
    }
    return 0;
}