题目1457:非常可乐(广度优先遍历BFS)

题目链接:http://ac.jobdu.com/problem.php?pid=1457

详解链接:https://github.com/zpfbuaa/JobduInCPlusPlus

参考代码:

//
//  1457 非常可乐.cpp
//  Jobdu
//
//  Created by PengFei_Zheng on 22/04/2017.
//  Copyright © 2017 PengFei_Zheng. All rights reserved.
//

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <cmath>
#include <queue>
#define MAX_SIZE 101
using namespace std;

int s, n, m;

struct N{
    int a;
    int b;
    int c;
    int t;
};

queue<N> myQueue;
bool visit[MAX_SIZE][MAX_SIZE][MAX_SIZE];

void x2y(int &x,int size_x, int &y,int size_y){
    if(size_y - y >= x){
        y+=x;
        x = 0;
    }else{
        x -=(size_y-y);
        y = size_y;
    }
}

int BFS(int s, int n, int m){
    while(!myQueue.empty()){
        N nowP = myQueue.front();
        myQueue.pop();
        int a, b, c;
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(a,s,b,n);// a--->b
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(a,s,c,m);// a--->c
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(b,n,a,s);// b--->a
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(b,n,c,m);// b--->c
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(c,m,a,s);// c--->a
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
        a = nowP.a;
        b = nowP.b;
        c = nowP.c;
        x2y(c,m,b,n);// c--->b
        if(visit[a][b][c]==false){
            visit[a][b][c]=true;
            N tmp;
            tmp.a = a;
            tmp.b = b;
            tmp.c = c;
            tmp.t = nowP.t+1;
            if((a==s/2 && b==s/2) || (a==s/2 &&c==s/2) || (b==s/2 && c==s/2) ) return tmp.t;
            myQueue.push(tmp);
        }
    }
    return -1;
}

int main(){
    while(scanf("%d%d%d",&s,&n,&m)!=EOF){
        if(s==0) break;
        if(s%2==1){
            printf("NO\n");
            continue;
        }
        for(int i = 0 ; i <= s ; i++){
            for(int j = 0 ; j <= n ; j++){
                for(int k = 0 ; k <= m ; k++){
                    visit[i][j][k]=false;
                }
            }
        }
        while(!myQueue.empty()) myQueue.pop();

        N tmp;
        tmp.a = s;
        tmp.b = tmp.c = tmp.t = 0;
        myQueue.push(tmp);
        visit[s][0][0]=true;
        int ans = BFS(s,n,m);
        ans == -1 ? printf("NO\n") : printf("%d\n",ans);
    }
}
/**************************************************************
    Problem: 1457
    User: zpfbuaa
    Language: C++
    Result: Accepted
    Time:10 ms
    Memory:2528 kb
****************************************************************/
时间: 2024-10-11 20:20:59

题目1457:非常可乐(广度优先遍历BFS)的相关文章

广度优先遍历-BFS、深度优先遍历-DFS

广度优先遍历-BFS 广度优先遍历类似与二叉树的层序遍历算法,它的基本思想是:首先访问起始顶点v,接着由v出发,依次访问v的各个未访问的顶点w1 w2 w3....wn,然后再依次访问w1 w2 w3....wn的所有未被访问的邻接顶点:再从这些访问过的顶点出发,再访问它们所有未被访问过的邻接顶点......依次类推,直到图中的所有点都被访问为止.类似的思想还将应用于Dijkstra单源最短路径算法和Prim最小生成树算法. python实现二叉树的建立以及遍历(递归前序.中序.后序遍历,队栈前

算法学习 - 图的广度优先遍历(BFS) (C++)

广度优先遍历 广度优先遍历是非经常见和普遍的一种图的遍历方法了,除了BFS还有DFS也就是深度优先遍历方法.我在我下一篇博客里面会写. 遍历过程 相信每一个看这篇博客的人,都能看懂邻接链表存储图. 不懂的人.请先学下图的存储方法.在我的之前博客里. 传送门:图表示方法 然后我们如果有一个图例如以下: 节点1->3->NULL 节点2->NULL 节点3->2->4->NULL 节点4->1->2->NULL 这样我们已经知道这是一个什么图了. 如果我们

图的深度优先遍历(DFS)和广度优先遍历(BFS)算法分析

1. 深度优先遍历 深度优先遍历(Depth First Search)的主要思想是: 1.首先以一个未被访问过的顶点作为起始顶点,沿当前顶点的边走到未访问过的顶点: 2.当没有未访问过的顶点时,则回到上一个顶点,继续试探别的顶点,直至所有的顶点都被访问过. 在此我想用一句话来形容 “不到南墙不回头”. 1.1 无向图的深度优先遍历图解 以下"无向图"为例: 对上无向图进行深度优先遍历,从A开始: 第1步:访问A. 第2步:访问B(A的邻接点). 在第1步访问A之后,接下来应该访问的是

利用广度优先遍历(BFS)计算最短路径 - Java实现

我们用字符串代表图的顶点(vertax),来模拟学校中Classroom, Square, Toilet, Canteen, South Gate, North Gate几个地点,然后计算任意两点之间的最短路径. 如,我想从North Gate去Canteen, 程序的输出结果应为: BFS: From [North Gate] to [Canteen]: North Gate Square Canteen 首先定义一个算法接口Algorithm: public interface Algori

图的广度优先遍历BFS实现--邻接矩阵p143

源程序: #include <stdio.h> #include <stdlib.h> #define MAXSIZE 9 /* 存储空间初始分配量 */ const int vnum = 20; typedef struct gp { char vexs[vnum]; /* 顶点表 */ int arc[vnum][vnum];/* 邻接矩阵,可看作边表 */ int vexnum, arcnum; /* 图中当前的顶点数和边数 */ }Graph; /* 循环队列的顺序存储结构

python实现图广度优先遍历、深度优先遍历

一.广度优先遍历-bfs 顾名思义,bfs总是先访问完同一层的结点,然后才继续访问下一层结点,它最有用的性质是可以遍历一次就生成中心结点到所遍历结点的最短路径,这一点在求无权图的最短路径时非常有用.广度优先遍历的核心思想非常简单,用python实现起来也就十来行代码.下面就是超精简的实现,用来理解核心思想足够了: 1 import queue 2 3 def bfs(adj, start): 4 visited = set() 5 q = queue.Queue() 6 q.put(start)

饥饿的小易(枚举+广度优先遍历(BFS))

题目描述 小易总是感觉饥饿,所以作为章鱼的小易经常出去寻找贝壳吃.最开始小易在一个初始位置x_0.对于小易所处的当前位置x,他只能通过神秘的力量移动到 4 * x + 3或者8 * x + 7.因为使用神秘力量要耗费太多体力,所以它只能使用神秘力量最多100,000次.贝壳总生长在能被1,000,000,007整除的位置(比如:位置0,位置1,000,000,007,位置2,000,000,014等).小易需要你帮忙计算最少需要使用多少次神秘力量就能吃到贝壳. 输入描述: 输入一个初始位置x_0

如何实现广度优先遍历(BFS)

BFS过程: 一:访问顶点V,并标记V为已经访问 二:顶点V入队列 三:如果队列非空,进行执行,否则算法结束 四:出队列取得对头顶点u,如果顶点未被访问,就访问该顶点,并标记该顶点为已经访问 五:查找u的第一个邻接节点w 六:如果w不存在,则转到步骤三,否则循环执行 a. 如果w没有被访问过,则先把w入队列 b.查找顶点u的下一个邻接节点,记为w,并转到步骤六 上图使用BFS访问顺序为: A BEDC 队列的变化过程如下: A B BE ED D C 代码如下: #include<iostrea

怎样实现广度优先遍历(BFS)

BFS过程: 一:訪问顶点V,并标记V为已经訪问 二:顶点V入队列 三:假设队列非空.进行运行,否则算法结束 四:出队列取得对头顶点u,假设顶点未被訪问,就訪问该顶点,并标记该顶点为已经訪问 五:查找u的第一个邻接节点w 六:假设w不存在.则转到步骤三,否则循环运行 a. 假设w没有被訪问过.则先把w入队列 b.查找顶点u的下一个邻接节点,记为w,并转到步骤六 上图使用BFS訪问顺序为: A BEDC 队列的变化步骤例如以下: A B BE ED D C 代码例如以下: #include<ios