《算法笔记》8.2小节——搜索专题->广度优先搜索（BFS）

最新推荐文章于 2021-09-03 16:30:51 发布
最新推荐文章于 2021-09-03 16:30:51 发布
阅读量269 收藏
点赞数
分类专栏： 算法笔记 文章标签： BFS 算法笔记 codeup
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20679687/article/details/89599960
版权

模板

问题 : 走迷宫（BFS）

时间限制: 1 Sec  内存限制: 128 MB
提交: 639  解决: 207
[提交][状态][讨论版][命题人:外部导入]

题目描述
　　有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这n*m个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-l表示无路)。
　　请统一用 左上右下的顺序拓展，也就是 (0,-1),(-1,0),(0,1),(1,0)

输入

第一行是两个数n，m( 1 < n ， m < 15 )，接下来是m行n列由1和0组成的数据，最后两行是起始点和结束点。 

输出

　　所有可行的路径，描述一个点时用(x，y)的形式，除开始点外，其他的都要用“->”表示方向。 
　　如果没有一条可行的路则输出-1。

样例输入

5 6
1 0 0 1 0 1
1 1 1 1 1 1
0 0 1 1 1 0
1 1 1 1 1 0
1 1 1 0 1 1
1 1
5 6

样例输出

(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(2,4)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,4)->(4,4)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(2,4)->(2,5)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(3,4)->(3,5)->(4,5)->(5,5)->(5,6)
(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(4,3)->(4,4)->(4,5)->(5,5)->(5,6)

AC代码及思路

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
struct node{
    int x, y;
    int step;
};
node s, e;
const int maxn=20;
int maze[maxn][maxn];
int inq[maxn][maxn];
int dx[]={0,-1,0,1};
int dy[]={-1,0,1,0};
int BFS(){
    queue<node> q;
    q.push(s);
    inq[1][1]=1;
    while(!q.empty()){
        node now=q.front();
        q.pop();
        if(now.x==e.x && now.y==e.y){
            return now.step;
        }
        for(int i=0; i<4; i++){
            node next={now.x+dx[i], now.y+dy[i], now.step+1};
            if(maze[next.x][next.y] && !inq[next.x][next.y]) {
                q.push(next);
                inq[next.x][next.y]=1;
            }
        }
    }
    return -1;
}
int main(){
    int m, n;
    while(~scanf("%d%d", &m, &n)){
        memset(maze, 0, sizeof(maze));
        memset(inq, 0, sizeof(inq));
        for(int i=1; i<=m; i++){
            for(int j=1; j<=n; j++){
                scanf("%d", &maze[i][j]);
            }
        }
        scanf("%d%d%d%d", &s.x, &s.y, &e.x, &e.y);
        s.step=0;
        printf("%d\n", BFS());
    }
    return 0;
}

问题 A: Jugs 倒水问题

时间限制: 1 Sec  内存限制: 32 MB
提交: 222  解决: 0
[提交][状态][讨论版][命题人:外部导入]

题目描述

In the movie "Die Hard 3", Bruce Willis and Samuel L. Jackson were confronted with the following puzzle. They were given a 3-gallon jug and a 5-gallon jug and were asked to fill the 5-gallon jug with exactly 4 gallons. This problem generalizes that puzzle.

    You have two jugs, A and B, and an infinite supply of water. There are three types of actions that you can use: (1) you can fill a jug, (2) you can empty a jug, and (3) you can pour from one jug to the other. Pouring from one jug to the other stops when the first jug is empty or the second jug is full, whichever comes first. For example, if A has 5 gallons and B has 6 gallons and a capacity of 8, then pouring from A to B leaves B full and 3 gallons in A.

    A problem is given by a triple (Ca,Cb,N), where Ca and Cb are the capacities of the jugs A and B, respectively, and N is the goal. A solution is a sequence of steps that leaves exactly N gallons in jug B. The possible steps are

    fill A 
    fill B 
    empty A 
    empty B 
    pour A B 
    pour B A 
    success

    where "pour A B" means "pour the contents of jug A into jug B", and "success" means that the goal has been accomplished.

    You may assume that the input you are given does have a solution.

 

输入

Input to your program consists of a series of input lines each defining one puzzle. Input for each puzzle is a single line of three positive integers: Ca, Cb, and N. Ca and Cb are the capacities of jugs A and B, and N is the goal. You can assume 0 < Ca <= Cb and N <= Cb <=1000 and that A and B are relatively prime to one another. 

输出

Output from your program will consist of a series of instructions from the list of the potential output lines which will result in either of the jugs containing exactly N gallons of water. The last line of output for each puzzle should be the line "success". Output lines start in column 1 and there should be no empty lines nor any trailing spaces.

样例输入

3 7 1
9 32 6

样例输出

fill B
pour B A
empty A
pour B A
success
fill B
pour B A
empty A
pour B A
empty A
pour B A
empty A
pour B A
fill B
pour B A
empty A
pour B A
empty A
pour B A
empty A
pour B A
empty A
pour B A
fill B
pour B A
empty A
pour B A
empty A
pour B A
success

AC代码及思路

  1. BFS适用于求解本题。因为BFS求解出的第一个解必是最短路径（最优解），DFS则不然。
  2. 本题具有马尔科夫性质，当前状态仅与上一状态和倒水动作有关。利用此特性，当碰到重复状态，不必入队列（相当于搜索中进行剪枝），大大降低计算时空复杂度。原本的计算复杂度时随着路径的长度指数增长的。
  3. BFS中，队列的使用是关键，保证搜索的有序性。但在此题中，我们还需输出最优路径，需保存路径信息，而STL队列没有此功能，一旦出列，路径结点就消失了。故笔者采用数组和队首队尾指针来构造队列（模拟pop(), front(), end()），这般的话，入队过的结点通通存储在数组里了，方便我们还原链表存储形式的路径。

坑

这两行代码 要保持严格的顺序，调换顺序后的计算结果不同。

a=a+b-cb; 
b=cb;

AC代码

#include<cstdio>
#include<cstring>
#include<cmath>
#include<stack>
#include<vector>
#include<queue>
using namespace std;
const int maxn = 1e5+10;
const int smaxn = 1010;
int table[smaxn][smaxn];
int front=0, last=0;
struct node{
    int a, b;
    int op;
    int pre;	//上一个状态
}tree[maxn];	//用数组的，线性存储结构来构造队列。
node manipulate(node now, int way, int ca, int cb){
    int a = now.a;
    int b = now.b;
    node next;
    switch(way){
        case 1: a=ca; break;	//fill A 
        case 2: b=cb; break;	//fill B
        case 3: a=0; break;	//empty A 
        case 4: b=0; break;	//empty B
        case 5:if(a+b-cb>=0) {a=a+b-cb; b=cb;} //pour A B 判断溢出
            else {b=a+b; a=0;} break;
        case 6: if(a+b-ca>=0) {b=a+b-ca; a=ca;} //pour B A 判断溢出
            else {a=a+b; b=0;} break;
    }
    next.a = a;
    next.b = b;
	next.op = way;
    return next;
}
int BFS(int ca, int cb, int n){
	//初始化
	node ans[100];
	memset(table, 0, sizeof(table));
	front=last=0;
    node S={0};
	//在tree的基础上，添加两个指针，实现队列的操作。采用线性存储结构来构造队列。
	//last指向队尾，front指向队首；
	//S入队列
	tree[last++] = S;
	//当队列为空时中断循环，即队首指针与队尾指针 重合。
	while(front != last){
		node now = tree[front];
		if(now.b == n) {
			return front;
		}
		table[now.a][now.b] =1; //标记当前状态 为 访问过,入队过。
		//对当前状态 执行6种操作，得到6个下一状态。
		for(int i=1; i<=6; i++){
			node next = manipulate(now, i, ca, cb);
			next.pre = front;
			if(table[next.a][next.b] == 0){
				tree[last++] = next;
				table[next.a][next.b] = 1; //标记当前状态 为 访问过。
			}//当前状态，如果不曾访问，曾入队列 待阅兵。反之跳过。
		} 
		//队首出列类比于pop()，以便得到队列的下一队首。
		front++;
	}
    return -1;
}
char strs[7][20]={"", "fill A\n", "fill B\n", "empty A\n", "empty B\n", "pour A B\n", "pour B A\n"};
void print(int index){
	if(index == -1) {
		//printf("FAIL\n"); 
		return;
	}
	stack<int> st;
	//遍历操作序列，并入栈
	while(index != 0){st.push(tree[index].op);index = tree[index].pre;}
	while(!st.empty()){printf("%s", strs[st.top()]); st.pop();}
	printf("success\n");
}
int main(){
	int ca, cb, n;
	while(~scanf("%d%d%d", &ca, &cb, &n)){
		print(BFS(ca, cb, n));
	}
	return 0;
}

问题 B: DFS or BFS?

时间限制: 1 Sec  内存限制: 128 MB
提交: 552  解决: 113
[提交][状态][讨论版][命题人:外部导入]

题目描述

说好了，题目不黑人。

给你一个8*8的矩阵，你的初始位置是左下角方格（用'U’表示），你的目标位置是右上角的方格(用'A'表示），其余的62个方格，如果是'.'，表示这个方格为空，如果是'S'，表示这个方格有一块大石头。好了现在你开始从左下角出发，每次可以往上，下，左，右，左上，右上，左下，右下移动一个方格，或者你可以原地不动，一共九个动作方式，在你做完一个动作后，所有的大石头会往下掉一个方格（如果一个大石头的位置是（x，y）,那下一秒是（x+1，y）,不过如果它已经在最下面的一排了，那它就会掉出矩阵，不再出现），请注意，任一时刻，你不能和某一个大石头处在同一个方格，否则石头会把你XX掉。

现在的问题就是：你能从左下角安全抵达右上角么？ 如果能，输出“Yes”，反之，“No”。

输入

T->测试数据组数(T)。

对于每组数据，输入一个8*8的矩阵，其后有一空行。描述如上。

输出

对于第i组数据，请输出

Case #i: s(s是一个字符串，如果可以到达，则s为“Yes”，反之“No”)

样例输入

<span style="color:#333333">2
.......A
........
........
........
........
........
........
U.......

.......A
........
........
........
........
.S......
S.......
US......
</span>

样例输出

<span style="color:#333333">Case #1: Yes
Case #2: No
</span>

[提交][状态]

AC代码及思路

AC代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<sstream>
using namespace std;
struct node{
    int x, y;
    int step;
};
const int maxn=10;
const int step_max=100;
const int m=8, n=8;
const int dx[]={0,-1,0,1,0,1,1,-1,-1};
const int dy[]={-1,0,1,0,0,1,-1,1,-1};
void drop(int maze[][maxn]){
    for(int i=m; i>=1; i--){
        for(int j=1; j<=n; j++){
            if(!maze[i][j]) {
                maze[i][j]=1;
                if(j<=m) maze[i+1][j]=0;
            }
        }
    }
}
int BFS(node s, node e, int maze[][maxn], int inq[][maxn][step_max]){
    //drop(maze);
    queue<node> q;
    q.push(s);
    inq[1][1][0]=1;
    int pre_step=0;
    do{
        //队首元素出队
        node now=q.front();
        q.pop();
        //石头下坠
        if(pre_step != now.step) drop(maze);
        pre_step=now.step;
        //判断是否撞墙
        if(maze[now.x][now.y]==0) continue;
        //判断是否到达终点。若是 则返回结束循环。
        if(now.x==e.x && now.y==e.y) return now.step;
        //遍历九种动作。可行动作的状态转移入队，反之跳过；
        for(int i=0; i<9; i++){
            node next={now.x+dx[i], now.y+dy[i], now.step+1};
            if(maze[next.x][next.y] && !inq[next.x][next.y][next.step]) {
                q.push(next);
                inq[next.x][next.y][next.step]=1;
            }
        }
    }while(!q.empty());
    return -1;
}
int main(){
    int p;
    while(~scanf("%d", &p)){
        getchar();
        //遍历每个测试用例
        for(int cnt=1; cnt<=p; cnt++){
            //初始化、置零，设置初始状态，统一初始状态
            node s, e;
            int maze[maxn][maxn]={0}, inq[maxn][maxn][step_max]={0};
            // memset(maze, 0, sizeof(maze));
            // memset(inq, 0, sizeof(inq));
            //格式控制，吸收xishou吸收吸收huanhangfu
            if(cnt!=1) {getchar();}
            //扫描迷宫，对迷宫进行编码
            for(int i=1; i<=m; i++){
                for(int j=1; j<=n; j++){
                    char c=getchar();
                    switch(c){
                        case 'U': s.x=i,s.y=j,maze[i][j]=1;break;
                        case 'A': e.x=i,e.y=j,maze[i][j]=1;break;
                        case '.': maze[i][j]=1;break;
                        case 'S': maze[i][j]=0;break;
                    }
                }
                getchar();
            }
            // //输出迷宫
            // for(int i=1; i<=m; i++){
            //     for(int j=1; j<=n; j++){
            //         cout<<maze[i][j]<<" ";
            //     }
            //     cout<<endl;
            // }
            //BFS搜索
            int re=BFS(s, e, maze, inq);
            //输出测试结果
            if(re==-1) printf("Case #%d: No\n", cnt);
            else printf("Case #%d: Yes\n", cnt);
            
        }
    }
    return 0;
}

问题 C: 【宽搜入门】8数码难题

时间限制: 20 Sec  内存限制: 128 MB
提交: 195  解决: 71
[提交][状态][讨论版][命题人:外部导入]

题目描述

初始状态的步数就算1，哈哈

输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。
输出：移动所用最少的步数

 

Input

2 8 3
1 6 4
7 0 5
1 2 3
8 0 4
7 6 5

Output

6

[提交][状态]

AC代码及思路

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<string>
#include<map>
using namespace std;
// char Table[400000000]={0};
map<string, int> mp;
const int maxn=4;
const int dx[]={0,-1,0,1};
const int dy[]={-1,0,1,0};
struct node{
    int x, y;
    int a[maxn][maxn];
    int step;
};
void copyM(int a[][maxn], int b[][maxn]){
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            a[i][j] = b[i][j];
        }
    }   
}
//散列映射，a[]映射为string
string hashM(int a[][maxn]){
    string str;
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            str.push_back(a[i][j]+'0');
        }
    }
    return str;
}
int findM(int a[][maxn]){
    
}
int equalM(int a[][maxn], int b[][maxn]){
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            if(a[i][j] != b[i][j]) return 0;
        }
    }
    return 1;
}
void printM(int a[][maxn]){
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
}
int BFS(node s, int b[][maxn]){
    queue<node> q;
    q.push(s);
    do{
        node now = q.front();
        q.pop();
        if(equalM(now.a, b)) return now.step;
        for(int i=0; i<4; i++){
            //构造，搜索下一结点
            node next = now;
            next.x = now.x + dx[i];
            next.y = now.y + dy[i];
            if(next.x>3 || next.x<1 || next.y>3 || next.y<1) continue;
            swap(next.a[now.x][now.y], next.a[next.x][next.y]);
            next.step++;
            //判断结点是否入队过。用Table记录结点的入队信息
            if(mp.find(hashM(next.a)) == mp.end()) {
                q.push(next);
                mp[hashM(next.a)]=1;
            }
            // printf("%d\n", hashM(next.a));
            // printM(next.a);
        }
    } while(!q.empty());
    return -1;
}
int main(){
    int b[maxn][maxn]={0};
    node s;
    int x, y;
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            scanf("%d", &s.a[i][j]);
            if(s.a[i][j] == 0) s.x=i, s.y=j, s.step=1;
        }
    }
    for(int i=1; i<=3; i++){
        for(int j=1; j<=3; j++){
            scanf("%d", &b[i][j]);
        }
    }
    // printM(s.a);
    // printM(b);
    printf("%d\n", BFS(s, b));
    return 0;
}

问题 D: 【宽搜入门】魔板

时间限制: 1 Sec  内存限制: 128 MB
提交: 205  解决: 51
[提交][状态][讨论版][命题人:外部导入]

题目描述

在成功地发明了魔方之后，鲁比克先生发明了它的二维版本，称作魔板。这是一张有8个大小相同的格子的魔板：
1 2 3 4
8 7 6 5
我们知道魔板的每一个方格都有一种颜色。这8种颜色用前8个正整数来表示。可以用颜色的序列来表示一种魔板状态，规定从魔板的左上角开始，沿顺时针方向依次取出整数，构成一个颜色序列。对于上图的魔板状态，我们用序列（1，2，3，4，5，6，7，8）来表示。这是基本状态。
这里提供三种基本操作，分别用大写字母“A”，“B”，“C”来表示（可以通过这些操作改变魔板的状态）：
“A”：交换上下两行；
“B”：将最右边的一列插入最左边；
“C”：魔板中央四格作顺时针旋转。
下面是对基本状态进行操作的示范：
A:
8 7 6 5
1 2 3 4
B:
4 1 2 3
5 8 7 6
C:
1 7 2 4
8 6 3 5
对于每种可能的状态，这三种基本操作都可以使用。
你要编程计算用最少的基本操作完成基本状态到目标状态的转换，输出基本操作序列。
【输入格式】
输入有多组测试数据
只有一行，包括8个整数，用空格分开（这些整数在范围 1——8 之间），表示目标状态。
【输出格式】
Line 1: 包括一个整数，表示最短操作序列的长度。
Line 2: 在字典序中最早出现的操作序列，用字符串表示，除最后一行外，每行输出60个字符。

Sample Input

2 6 8 4 5 7 3 1

Sample Output

7

BCABCCB

[提交][状态]

AC代码及思路

AC代码

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<string>
#include<set>
using namespace std;
struct node{
    int cube[3][5];
    int pre_cube;
    int step;       
	string ops;     //记录操作序列
};
// 状态转移函数；
node action(node now, int act){
    switch(act){
        case 0: 
            for(int i=1; i<=4; i++){
                swap(now.cube[1][i], now.cube[2][i]);
            }
            break;
        case 1: 
            for(int i=4; i>=2; i--){
                swap(now.cube[1][i-1], now.cube[1][i]);
                swap(now.cube[2][i-1], now.cube[2][i]);
            }
            break;
        case 2: 
            swap(now.cube[1][2], now.cube[1][3]);
            swap(now.cube[1][2], now.cube[2][2]);
            swap(now.cube[2][2], now.cube[2][3]);
            break;
    }
    now.step ++;
    now.ops.push_back(act+'A');
	return now;
}
//二维数组的比较
int equalCube(int now[][5], int endC[][5]){
    for (int i=1; i<=2; i++){
        for(int j=1; j<=4; j++){
            if(now[i][j] != endC[i][j]) return 0;
        }
    }
    return 1;
}
// 二维数组的输出
void printCube(int a[][5]){
    for(int i=1; i<=2; i++){
		for(int j=1; j<=4; j++){
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}
// 结点合法性与重复性的检验
int judgeC(node now, set<int>& st){
    int hash=0;
    int product=1;
    for(int i=1; i<=2; i++){
		for(int j=1; j<=4; j++){
			hash += (now.cube[i][j]-1)*product;
			product *= 8;
		}
	}
	if(st.find(hash) != st.end()) {
	    return 0;
	}
	else {
	    st.insert(hash);
	    return 1;
	}
}
//广度优先搜索
node BFS(node b, node e){
    set<int> st;    //记录结点入队信息；
    queue<node> q;  //等待阅兵的队列
    q.push(b);
    do{
        node now = q.front();
        q.pop();
        if( equalCube(now.cube, e.cube) ) return now;
        for(int i=0; i<3; i++){
            node next = action(now, i);
            if(judgeC(next, st)){
                q.push(next);
                //next.op = now.op + str;
            }
        }
    }while(!q.empty());
    return {0};
}
//主程序
int main(){
    node b;
    //初始化起点状态
    int beginCube[3][5]={{0},{0,1,2,3,4},{0,8,7,6,5}};
    for(int i=1; i<=2; i++){
        for(int j=1; j<=4; j++){
            b.cube[i][j] = beginCube[i][j];
        }
    }
    b.step = 0;
	b.ops="";
    //初始化目标状态
    node e;
    for(int i=1; i<=1; i++){
        for(int j=1; j<=4; j++){
            scanf("%d", &e.cube[i][j]);
        }
    }
    for(int i=2; i<=2; i++){
        for(int j=4; j>=1; j--){
            scanf("%d", &e.cube[i][j]);
        }
    }
    //搜索
    node ans = BFS(b, e);
    cout<<ans.step<<endl;
	cout<<ans.ops<<endl;
    return 0;
}

问题 E: 【宽搜入门】巧妙取量

时间限制: 2 Sec  内存限制: 128 MB
提交: 264  解决: 84
[提交][状态][讨论版][命题人:外部导入]

题目描述

【题目描述】
　　有三个容器，容量分别为 a,b,c（a> b > c ),一开始a装满油，现在问是否只靠abc三个容器量出k升油。如果能就输出“yes”，并且说明最少倒几次，否则输出“no”。例如：10升油在10升的容器中，另有两个7升和3升的空容器，要求用这三个容器倒油，使得最后在abc三个容器中有一个刚好存有5升油，问最少的倒油次数是多少？（每次倒油，A容器倒到B容器，或者A内的油倒完，或者B容器倒满。
　10 7 3
（10 0 0）
（3 7 0） : 第一次
（3 4 3）：第二次
（6 4 0）：第三次
（6 1 3）：第四次
（9 1 0）：第五次
（9 0 1）：第六次
（2 7 1）：第七次
（2 5 3）：第八次，出现5了。

Input

【输入格式】
　　有多组测试数据。
　　输入a，b，c, k四个正整数( 100 ≥ a > b > c≥1 , 1≤k< 100 )

Output

【输出格式】
　　如果能得到k就输出两行。
　　第一行“yes”，第二行为最少的次数
　　否则输出“no”

Sample Input

10 7 3 5

Sample Output

yes
8

[提交][状态]

AC代码及思路

采用set来记录入队信息，较好地平衡了 查找效率与内存消耗。

AC代码

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<string>
#include<set>
using namespace std;
int k;
int c[3];
const int num_s=3;    // 状态的数量
const int num_a=6;    // 行动的数量
struct node{
    int state[num_s];
    int step;       
	string ops;     //记录操作序列
};
// a->b
void pour(int s[], int a, int b){ 
    if(s[a]+s[b]>c[b]){
        s[a] = s[a]+s[b]-c[b];
        s[b] = c[b];
    }else{
        s[b] = s[a]+s[b];
        s[a] = 0;
    }
}
// 状态转移函数；
node generate_NextState(node now, int action){
    switch(action){
        case 0:     //a->b
            pour(now.state, 0, 1);
            break;
        case 1:     //b->a
            pour(now.state, 1, 0);
            break;
        case 2:      //a->c
            pour(now.state, 0, 2);
            break;
        case 3:      //c->a
            pour(now.state, 2, 0);
            break;
        case 4:      //b->c
            pour(now.state, 1, 2);
            break;
        case 5:      //c->b
            pour(now.state, 2, 1);
            break;
    }
    now.step ++;
    now.ops.push_back(action +'0');
	return now;
}
//状态向量的比较
int equalState(int state[], int endS[]){
    for (int i=0; i<num_s; i++){
        if(state[i] != endS[i]) return 0;
    }
    return 1;
}
// 是否完成目标。当前状态与终止状态的比较
int reachEnd(int state[]){
    for (int i=0; i<3; i++){
        if(state[i] == k) return 1;
    }
    return 0;
}
// 状态向量的输出
void printState(int a[]){
    for(int i=0; i<num_s; i++){
		printf("%d ", a[i]);
	}
	printf("\n");
}
// 结点合法性与重复性的检验
int inq(node now, set<int>& st){
    int hash=0;
    int product=1;
    //构造对应的散列
    for(int i=0; i<num_s; i++){
		hash += now.state[i]* product;
		product *= 110;
	}
	if(st.find(hash) == st.end()) {
	    st.insert(hash);
	    return 0;
	}else return 1;
}
//广度优先搜索
int BFS(node b, node& ans){
    set<int> st;    //记录结点入队信息；
    queue<node> q;  //等待阅兵的队列
    q.push(b);
    inq(b, st);
    do{
        node now = q.front();
        q.pop();
        if( reachEnd(now.state) ) {
            ans = now;
            return now.step;
        }
        for(int i=0; i<num_a; i++){
            node next = generate_NextState(now, i);
            if( !inq(next, st) ){
                // printState(next.state);
                q.push(next);
            }
        }
    }while(!q.empty());
    return -1;
}
//主程序
int main(){
    while(~scanf("%d%d%d%d", &c[0], &c[1], &c[2], &k)){
        //初始化起点状态
        node b={0};
        b.state[0] = c[0];
        //初始化目标状态（终止状态）
        //检验
        // printState(b.state);
        // printState(e[0]);
        //搜索
        node ans;
        if(~BFS(b, ans)) cout<<"yes"<<endl<<ans.step<<endl;
        else cout<<"no"<<endl;
        // cout<<ans.ops<<endl;
        // string str = ans.ops;
        // for(int i=0; i<str.length(); i++){
        //     b = generate_NextState(b, str[i]-'0');
        //     printState(b.state);
        // }
    }
    return 0;
}

 

 

秋千无闻
关注
专栏目录
MATLAB源码集锦-基于BFS广度优先搜索算法代码
02-14
本资源“MATLAB源码集锦-基于BFS广度优先搜索算法代码”是专门为MATLAB用户提供的，旨在帮助他们理解和实现BFS算法。 BFS算法的基本思想是从起点开始，首先访问其所有邻居，然后访问这些邻居的邻居，以此类推，直到...
蓝桥训练 1021-1025（python)
Hanzoe的博客
07-31 361
题目 1021: [编程入门]迭代法求平方根 时间限制: 1Sec 内存限制: 128MB 提交: 10226 解决: 5922 题目描述 用迭代法求 平方根 公式：求a的平方根的迭代公式为： X[n+1]=(X[n]+a/X[n])/2 要求前后两次求出的差的绝对值少于0.00001。 输出保留3位小数 输入 X 输出 X的平方根 样例输入 4 样例输出 2.000 a = eval(input()) b = a/2 c = (b+a/b)/2 while b-c>=0.00001: b =
题目1109：连通图
ych19871020的专栏
09-24 807
一道简单的并查集 #include #include #include #include using namespace std; int fa[10000]; int find(int x) { if(x==fa[x])return x; fa[x]=find(fa[x]); } void merge(int a,int b) { a=find(a); b=find(b); fa
BFS（广度优先搜索）笔记
Dunk.Wan
02-13 128
计数n×m 型01矩阵中1块数： #include&lt;cstdio&gt; #include&lt;queue&gt; using namespace std; const int maxn = 100; struct node{ int x,y; }Node; int n,m; int matrix[maxn][maxn]; bool inq[maxn][maxn]={false};...
经典BFS以及奇特的做法。。
qq_40716114的博客
05-25 374
概念：宽度优先搜索（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。Dijkstra算法和Prim算法都采用了和宽度优先搜索类似的思想。BFS属于一种盲目搜寻法（所以才叫搜索啊），用队列实现，目的是系统地展开并检查图中的所有节点，以找寻结果。（不要怪我扯上图论）换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。相信对BFS大家都不陌生，下面...
100000609 - 《算法笔记》8.2小节——搜索专题->广度优先搜索（BFS）
李霁明的博客
02-10 612
文章目录8.2 BFS处理BFS概念BFS例一矩阵“块”BFS例二走迷宫最小步数Codeup习题2078-ProblemA-Jugs4054-ProblemB-DFS or BFS?5997-ProblemC-【宽搜入门】8数码难题5998-ProblemD-【宽搜入门】魔板5999-ProblemE-【宽搜入门】巧妙取量BFS小结 罪过，好长时间没刷题了，宽搜也很难，先把一些贴上来，回头来填坑 ...
BFS.rar_Bfs算法_bfs_广度优先_广度搜索算法_搜索算法
09-24
**广度优先搜索（BFS）算法详解** 广度优先搜索（BFS）是一种用于遍历或搜索树或图的算法。它从根节点开始，然后遍历所有相邻的节点，然后再对每个相邻节点进行相同的操作，直到遍历完所有节点。在图中，BFS算法...
PHP实现广度优先搜索算法(BFS,Broad First Search)详解
12-20
广度优先搜索(Breadth-First Search, BFS)是一种在图或树中寻找路径的算法，它按照从起点开始逐层探索的顺序来遍历节点。BFS算法适用于寻找最短路径问题，尤其是在无权图中寻找最短路径到所有其他节点的情况。 ### ...
python双向广度优先搜索算法（Bidirectional Breadth-First Search, BBFS），寻路算法
最新发布
05-22
双向广度优先搜索（Bidirectional Breadth-First Search, BBFS）是广度优先搜索的一种变体，它在搜索图中同时从起始节点和目标节点展开搜索。当两个搜索前沿相遇时，算法成功找到一条从起始节点到目标节点的路径。...
算法-搜索- 广度优先搜索（BFS）.rar
09-16
广度优先搜索（BFS）是一种在图或树中寻找路径的算法，它的基本思想是从起始节点开始，沿着树或图的宽度进行扩展，优先遍历所有相邻的节点，然后再遍历下一层次的节点。这种策略确保了最近的节点总是先被访问，因此...
BFS(广搜)算法与模板 bfs求最短路
summit2017的博客
02-10 4011
BFS(广搜)日有所思，日有所得 内含例题bfs找最短路
算法笔记练习 8.2 广度优先搜索（BFS） 问题 A: Jugs
Gorgeoustray
04-30 456
算法笔记练习 题解合集 本题链接 题目 In the movie “Die Hard 3”, Bruce Willis and Samuel L. Jackson were confronted with the following puzzle. They were given a 3-gallon jug and a 5-gallon jug and were asked to fill th...
BFS练习
qq_52051345的博客
08-18 156
问题 A: Jugs #include <iostream> using namespace std; int main() { int Ca, Cb, n; while (cin >> Ca >> Cb >> n) { int t = 0; while (t != n) { //3 5 4 //5 7 3 co...
codeupContest100000608 - 《算法笔记》8.1小节——搜索专题->深度优先搜索（DFS）总结（持续更新
qiyueliuhuo_A的博客
01-25 363
#Problem A【递归入门】全排列 题目描述 排列与组合是常用的数学方法。 先给一个正整数 ( 1 &amp;amp;amp;amp;amp;amp;lt; = n &amp;amp;amp;amp;amp;amp;lt; = 10 ) 例如n＝3，所有组合,并且按字典序输出： 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1 输入输入一个整数n( 1&amp;amp;amp;amp;amp;amp;lt;=n&amp;
算法笔记BFS专题 问题 E: 【宽搜入门】巧妙取量
weixin_43739958的博客
09-03 83
【题目描述】 　　有三个容器，容量分别为 a,b,c（a> b > c ),一开始a装满油，现在问是否只靠abc三个容器量出k升油。如果能就输出“yes”，并且说明最少倒几次，否则输出“no”。例如：10升油在10升的容器中，另有两个7升和3升的空容器，要求用这三个容器倒油，使得最后在abc三个容器中有一个刚好存有5升油，问最少的倒油次数是多少？（每次倒油，A容器倒到B容器，或者A内的油倒完，或者B容器倒满。 　10 7 3 （10 0 0） （3 7 0）:第一次 （3 4 3）：第二次 （6
BFS+康托展开（洛谷1379 八数码难题）
pianoの安心小家
07-27 382
在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入格式： 输入初试状态，一行九个数字，空格用0表示 输
Codeup广度优先搜索（BFS）：【宽搜入门】8数码难题
nanke_4869的博客
08-17 372
题目描述 初始状态的步数就算1，哈哈 输入：第一个3*3的矩阵是原始状态，第二个3*3的矩阵是目标状态。 输出：移动所用最少的步数 Input 2 8 3 1 6 4 7 0 5 1 2 3 8 0 4 7 6 5 Output 6 #include<bits/stdc++.h> using namespace std; struct Node{ ...
DFS（深搜）例题 解题与心得
Crazy_Frog的专栏
03-23 7843
走迷宫 【问题描述】 有一个m*n格的迷宫(表示有m行、n列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这m*n个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你分别编程4个程序解决以下4个问题。 问题1：找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相
Codeup 问题 B: DFS or BFS? （BFS）
qq_42819248的博客
08-14 1091
题目描述 说好了，题目不黑人。 给你一个8*8的矩阵，你的初始位置是左下角方格（用’U’表示），你的目标位置是右上角的方格(用’A’表示），其余的62个方格，如果是’.’，表示这个方格为空，如果是’S’，表示这个方格有一块大石头。好了现在你开始从左下角出发，每次可以往上，下，左，右，左上，右上，左下，右下移动一个方格，或者你可以原地不动，一共九个动作方式，在你做完一个动作后，所有的大石头会往下...
算法入门：理解广度优先搜索(BFS)
广度优先搜索（BFS，Breadth-First Search）是一种用于遍历或搜索树或图的算法，尤其适用于查找连通图中的最短路径。由郭志伟在2012年提出，该算法以“辐射状”的方式优先遍历距离起点较近的节点。 1. 前言 BFS是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值