南阳21--三个水杯(Bfs)

三个水杯

时间限制:1000 ms  |  内存限制:65535 KB

难度:4

描述
给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子。三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算。现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数。
输入
第一行一个整数N(0<N<50)表示N组测试数据
接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的体积。
第二行给出三个整数E1 E2 E3 (体积小于等于相应水杯体积)表示我们需要的最终状态
输出
每行输出相应测试数据最少的倒水次数。如果达不到目标状态输出-1
样例输入
2 6 3 1 4 1 1 9 3 2 7 1 1
样例输出
3 -1
来源
经典题目
上传者

hzyqazasdf

编的够够的, 先放上正确代码, 话说这题也真够暴力的。

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

int va, vb, vc, ta, tb, tc;
bool visit[205][205][205];
struct state
{
    int a;
    int b;
    int c;
    int step;
};

inline bool check(state t)
{
    if(t.a == ta && t.b == tb && t.c == tc)
        return true;
    return false;
}

int BFS(int sa, int sb, int sc)
{
    queue <state> q;
    state t1, t2;
    t1.a = sa;
    t1.b = sb;
    t1.c = sc;
    t1.step = 0;
    q.push(t1);
    while(!q.empty())
    {
        t1 = q.front();
        q.pop();
        if(t1.b != vb && t1.a)               //  pour va to vb
        {
            if(t1.a <= vb - t1.b)
            {
                t2.a = 0;
                t2.b = t1.b + t1.a;
                t2.c = t1.c;
            }
            else
            {
                t2.a = t1.a - (vb - t1.b);
                t2.b = vb;
                t2.c = t1.c;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
        if(t1.c != vc && t1.a)               //  pour va to vc
        {
            if(t1.a <= vc - t1.c)
            {
                t2.a = 0;
                t2.b = t1.b;
                t2.c = t1.c + t1.a;
            }
            else
            {
                t2.a = t1.a - (vc - t1.c);
                t2.b = t1.b;
                t2.c = vc;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
        if(t1.a != va && t1.b)               //  pour vb to va
        {
            if(t1.b <= va - t1.a)
            {
                t2.b = 0;
                t2.a = t1.b + t1.a;
                t2.c = t1.c;
            }
            else
            {
                t2.b = t1.b - (va - t1.a);
                t2.a = va;
                t2.c = t1.c;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
        if(t1.a != va && t1.b)               //  pour vb to vc
        {
            if(t1.b <= vc - t1.c)
            {
                t2.b = 0;
                t2.a = t1.a;
                t2.c = t1.b + t1.c;
            }
            else
            {
                t2.b = t1.b - (vc - t1.c);
                t2.a = t1.a;
                t2.c = vc;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
        
        if(t1.b != vb && t1.c)               //  pour vc to vb
        {
            if(t1.c <= vb - t1.b)
            {
                t2.c = 0;
                t2.b = t1.b + t1.c;
                t2.a = t1.a ;
            }
            else
            {
                t2.c = t1.c - (vb - t1.b);
                t2.b = vb;
                t2.a = t1.a;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
        if(t1.a != va && t1.c)               //  pour vc to va
        {
            if(t1.c <= va - t1.a)
            {
                t2.c = 0;
                t2.a = t1.a + t1.c;
                t2.b = t1.b ;
            }
            else
            {
                t2.c = t1.c - (va - t1.a);
                t2.a = va;
                t2.b = t1.b;
            }
            if(!visit[t2.a][t2.b][t2.c])
            {
                t2.step = t1.step + 1;
                if(check(t2))
                    return t2.step;
                visit[t2.a][t2.b][t2.c] = true;
                q.push(t2);
            }
        }
    }
    return -1;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        memset(visit, false, sizeof(visit));
        scanf("%d %d %d", &va, &vb, &vc);
        scanf("%d %d %d", &ta, &tb, &tc);
        if(va == ta && 0 == tb && 0 == tc)
        {
            printf("0\n");
            continue;
        }
        visit[va][0][0] = true;
        printf("%d\n", BFS(va, 0, 0));
    }
    return 0;
}

时间: 2024-10-10 09:29:35

南阳21--三个水杯(Bfs)的相关文章

NYOJ 21 三个水杯 【暴力+BFS】

题意:不解释. 策略:广搜. 解释一下为什么会是广搜,一个水杯只能向其他两个水杯倒水,不能向他自己倒水,这样一共有三个水杯也就是有6种情况,只需要一步一步的搜索就好了(数据没多大 <100), 我们将每一次出现的水杯中的水数(就是有多少水)都标记下来,如果是以前没有出现过,那么就进队列,同时将此时的水杯数标记下来,说明该种情况已出现,一直找到想要找的状态为止,如果都找不到,就返回-1. 难点:我在下面的代码中会有详细的解释. ps:网上有说这道题是隐式图,因为BFS原来是来搜索图的,我比较认可.

Nyoj 21 三个水杯(bfs)

三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的

BFS [NYOJ 21] 三个水杯

三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的

nyist_21(三个水杯)(BFS)

描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据 接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的体积. 第二行给出三个整数E1 E2 E3 (体积小于等于相应水杯体积)表示我们

nyoj三个水杯(bfs)

三个水杯 时间限制:1000 ms  |           内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>

nyoj 21 三个水杯

三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯的

队列,广搜 nyoj 21 三个水杯

三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据 接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三个水杯

NYOJ21 三个水杯 (经典问题 bfs)

题目描述: http://acm.nyist.net/JudgeOnline/problem.php?pid=21 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据 接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100

NYOJ21.三个水杯-初始态到目标态的最少次数-经典BFS

题目传送门:biubiubiu~ 三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给出三个水杯,大小不一,并且只有最大的水杯的水是装满的,其余两个为空杯子.三个水杯之间相互倒水,并且水杯没有标识,只能根据给出的水杯体积来计算.现在要求你写出一个程序,使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组测试数据接下来每组测试数据有两行,第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<10

三个水杯(BFS)

三个水杯 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描写叙述 给出三个水杯.大小不一,而且仅仅有最大的水杯的水是装满的.其余两个为空杯子.三个水杯之间相互倒水,而且水杯没有标识,仅仅能依据给出的水杯体积来计算.如今要求你写出一个程序.使其输出使初始状态到达目标状态的最少次数. 输入 第一行一个整数N(0<N<50)表示N组測试数据 接下来每组測试数据有两行.第一行给出三个整数V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示