三个水杯(BFS)

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

/*
    广搜
    六个方向
    a - > b
    b - > a
    c - > a
    a - > c
    b - > c
    c - > b
http://acm.nyist.edu.cn/JudgeOnline/problem.php?pid=21
*/

#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>

using namespace std;
struct LNode
{
    int v1,v2,v3;
    int step;
    LNode()
    {
        step = 0;
    }
};
int e1,e2,e3;
int v1,v2,v3;
int vis[107][107][107];//表示状态
int bfs()
{
    LNode node;
    node.v1 = v1;
    node.v2 = 0;
    node.v3 = 0;
    node.step = 0;
    queue<LNode> Q;
    Q.push(node);
    while(!Q.empty())
    {
        LNode now = Q.front();
        vis[now.v1][now.v2][now.v3] = 1;
        Q.pop();
        if(now.v1 == e1 && now.v2 == e2 && now.v3 == e3)
            return now.step;
        if(now.v1 > 0)
        {
            // a->b
            if(now.v2 < v2)
            {
                int tmp ;
                if(now.v1 >= (v2 - now.v2))
                    tmp = (v2 - now.v2);
                else
                    tmp = now.v1;
                LNode next = now;
                next.step ++;
                next.v1 -= tmp;
                next.v2 += tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
             }
             // a- > c
             if(now.v3 < v3)
             {
                int tmp ;
                if(now.v1 >= (v3 - now.v3))
                    tmp = (v3 - now.v3);
                else
                    tmp = now.v1;
                LNode next = now;
                next.step ++;
                next.v1 -= tmp;
                next.v3 += tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
             }
        }
        if(now.v2 > 0)
        {
            //b - > a
            if(now.v1 < v1)
            {
                 int tmp ;
                if(now.v2 >= (v1 - now.v1))
                    tmp = (v1 - now.v1);
                else
                    tmp = now.v2;
                LNode next = now;
                next.step ++;
                next.v1 += tmp;
                next.v2 -= tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
            }
            //b- > c
            if(now.v3 < v3)
            {
                 int tmp ;
                if(now.v2 >= (v3 - now.v3))
                    tmp = (v3 - now.v3);
                else
                    tmp = now.v2;
                LNode next = now;
                next.step ++;
                next.v3 += tmp;
                next.v2 -= tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
            }
        }
        if(now.v3 > 0)
        {
            //c - > a
            if(now.v1 < v1)
            {
                int tmp ;
                if(now.v3 >= (v1 - now.v1))
                    tmp = (v1 - now.v1);
                else
                    tmp = now.v3;
                LNode next = now;
                next.step ++;
                next.v3 -= tmp;
                next.v1 += tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
            }
            //c - > b
             if(now.v2 < v2)
            {
                int tmp ;
                if(now.v3 >= (v2 - now.v2))
                    tmp = (v2 - now.v2);
                else
                    tmp = now.v3;
                LNode next = now;
                next.step ++;
                next.v3 -= tmp;
                next.v2 += tmp;
                if(!vis[next.v1][next.v2][next.v3])
                {
                    Q.push(next);
                    vis[next.v1][next.v2][next.v3] = 1;
                }
            }
        }
    }
    return -1;
}
int main()
{
    int ncase;
    cin>>ncase;
    while(ncase--)
    {
        cin>>v1>>v2>>v3;
        cin>>e1>>e2>>e3;
        memset(vis,0,sizeof(vis));
        int num = bfs();
        cout<<num<<endl;
    }
    return 0;
}
### 三维空间中的广度优先搜索(BFS) 在二维网上,BFS 是一种常见的路径查找方法。然而,在三维空间中,BFS 的概念可以扩展到处理立方体或其他三维结构的数据集。以下是关于如何实现和理解三维 BFS 算法的解释。 #### 基本原理 类似于二维 BFS,三维 BFS 使用队列来存储待访问的节点,并逐层遍历这些节点。主要的区别在于邻居节点的数量增加——在一个三维网中,每个节点通常有六个可能的方向(上下左右前后)。因此,对于给定的一个坐标 `(x, y, z)`,其邻接点可以通过调整 `x`, `y` 和 `z` 来计算: ```python neighbors = [ (x + 1, y, z), (x - 1, y, z), (x, y + 1, z), (x, y - 1, z), (x, y, z + 1), (x, y, z - 1) ] ``` 需要注意的是,实际应用中还需要考虑边界条件以及障碍物的存在情况[^3]。 #### 实现代码 下面是一个简单的 Python 实现示例,用于演示如何在三维空间中执行 BFS 遍历: ```python from collections import deque def bfs_3d(grid, start, goal): """ Perform a breadth-first search on a 3D grid. :param grid: List[List[List[int]]], representing the 3D space. Use 0 for open cells and 1 for blocked ones. :param start: Tuple(int, int, int), coordinates of the starting point. :param goal: Tuple(int, int, int), coordinates of the target point. :return: Shortest distance to reach 'goal' from 'start', or None if unreachable. """ rows, cols, levels = len(grid), len(grid[0]), len(grid[0][0]) queue = deque([(start, 0)]) # Queue stores tuples of position and current depth/distance visited = set([start]) # Set to track already processed positions while queue: (current_x, current_y, current_z), dist = queue.popleft() # Check if we've reached our destination if (current_x, current_y, current_z) == goal: return dist # Explore all six possible neighbors in 3D space for dx, dy, dz in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)]: nx, ny, nz = current_x + dx, current_y + dy, current_z + dz # Ensure new position is within bounds and unvisited/open cell if 0 <= nx < rows and 0 <= ny < cols and 0 <= nz < levels \ and grid[nx][ny][nz] == 0 and (nx, ny, nz) not in visited: visited.add((nx, ny, nz)) queue.append(((nx, ny, nz), dist + 1)) return None # If no path found ``` 此函数接受一个三维数组作为输入参数之一 (`grid`),其中零表示开放区域而一代表不可穿越的位置;另外两个元组分别指定起点与终点位置。如果存在通往目标的有效路线,则返回最短距离;否则返回 `None` 表明无法抵达目的地[^4]。 #### 应用场景 - **机器人导航**:当需要规划移动机器人的最佳路径时,尤其是在复杂环境中操作的情况下。 - **游戏开发**:适用于许多基于方的游戏设计需求,比如迷宫生成或者角色行动范围判定等功能模块构建过程中可能会涉及到此类技术的应用实例说明等等[^1].
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值