[Luogu] 八数码难题

最新推荐文章于 2021-06-07 21:19:38 发布
最新推荐文章于 2021-06-07 21:19:38 发布
阅读量85 收藏
点赞数
原文链接：http://www.cnblogs.com/shandongs1/p/8439131.html
版权

https://www.luogu.org/problemnew/show/P1379

long long ago

暴力bfs

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <map>
#include <queue>
#include <cstring>
#include <string>

using namespace std;
const string s_end = "123804765";

struct Node {
    string s;
    int step;
};
queue <Node> Q1;
map <string, bool> mp;
string s_start;
int Step;

inline void pd(string ss, int answer) {
    if(ss == s_end) {
        printf("%d",answer);
        exit(0);
    }
}

inline void bfs() {
    while(!Q1.empty()) {
        Node topp = Q1.front();
        Q1.pop();
        string s1 = topp.s;
        Step = topp.step;
        int f = s1.find('0');
        Node nxt;
        if(f == 0) {
            swap(s1[0], s1[1]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[0], s1[1]);
            swap(s1[0], s1[3]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 1) {
            swap(s1[0], s1[1]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[0], s1[1]);
            swap(s1[1], s1[2]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[1], s1[2]);
            swap(s1[1], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 2) {
            swap(s1[1], s1[2]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[1], s1[2]);
            swap(s1[2], s1[5]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 3) {
            swap(s1[0], s1[3]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[0], s1[3]);
            swap(s1[3], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[3], s1[4]);
            swap(s1[3], s1[6]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 4) {
            swap(s1[1], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[1], s1[4]);
            swap(s1[3], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[3], s1[4]);
            swap(s1[5], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[5], s1[4]);
            swap(s1[7], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 5) {
            swap(s1[5], s1[2]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[5], s1[2]);
            swap(s1[5], s1[4]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[5], s1[4]);
            swap(s1[5], s1[8]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 6) {
            swap(s1[6], s1[3]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[6], s1[3]);
            swap(s1[6], s1[7]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 7) {
            //4 7    6 7    8 7
            swap(s1[4], s1[7]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[4], s1[7]);
            swap(s1[6], s1[7]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[6], s1[7]);
            swap(s1[8], s1[7]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
        if(f == 8) {
            //58   78
            swap(s1[5], s1[8]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            swap(s1[5], s1[8]);
            swap(s1[7], s1[8]);
            pd(s1, topp.step + 1);
            if(!mp[s1]) {
                nxt.s = s1;
                nxt.step = topp.step + 1;
                Q1.push(nxt);
                mp[s1] = 1;
            }
            continue;
        }
    }
}

int main() {
    cin >> s_start;
    Node now;
    now.s = s_start;
    now.step = 0;
    Q1.push(now);
    bfs();
    return 0;
}
//283104765

 

转载于:https://www.cnblogs.com/shandongs1/p/8439131.html

weixin_30379911
关注
洛谷 P1379 八数码难题
Ender_Wiggin的博客
08-10 494
啊！！这一题算是BFS中的经典了，如果你不懂BFS的话，可以睡觉了~~~ 现在请大家跳转题面题目描述在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。输入
luogu1379:八数码难题（宽搜+哈希表+双向搜索）
liusu201601的博客
02-12 773
题目传送门    矩阵中经典的宽搜题，这里我主要是想讲哈希表（散列表）的应用而已。    下面几个知识点都有大神讲解过，有兴趣的同学，请认真阅读，如果你懒得看，我后面也会简单讲解。    关于sprintf（）函数的用法    关于哈希表的用法    关于双向搜索题目大意：    1、一个3*3的矩阵，给出开始状态和结束状态，请您推箱子（0是那个箱子）    2、输出推箱子的步数解题思路：    ...
八数码
u012629369的专栏
11-15 617
P1541 八数码 时间: 1000ms / 空间: 131072KiB / Java类名: Main 背景  Yours和zero在研究A*启发式算法.拿到一道经典的A*问题,但是他们不会做,请你帮他们. 描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一
1077 Eight 八数码问题
hqd_acm的专栏
09-24 1435
<br />EightTime Limit: 1000MS Memory Limit: 65536KTotal Submissions: 11425 Accepted: 5073 Special Judge<br />DescriptionThe 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 slid
八数码难题
撤云的博客
03-04 584
时间限制: 1 s 空间限制: 128000 KB 题目描述： Yours和zero在研究A*启发式算法.拿到一道经典的A*问题,但是他们不会做,请你帮他们. 问题描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,
八数码问题_启发搜索
weixin_33712987的博客
10-16 115
#include<stdio.h> #include<math.h> typedef struct { long parent; long index; int direction;//记录上一节点到当前节点空格移动方向 int Grid[9];//存储局面 int H;//启发函数值 }State;...
【luogu1379】 八数码难题
Elijahqi
02-22 380
(http://www.elijahqi.win/2017/07/05/%E3%80%90luogu1379%E3%80%91-%E5%85%AB%E6%95%B0%E7%A0%81%E9%9A%BE%E9%A2%98/) 题目描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局...
luogu-card:该项目由 https
04-10
luogu-card是一个动态生成洛谷用户数据卡片的工具，可以展示自己的做题情况。可以用于个人主页、博客、github等可以插入图片的地方。 TODO 修复获取数据错误和用户设置数据不可见的bug 增加黑暗模式 增加咕值卡片...
luogu课件.zip
09-20
"luogu课件.zip" 是一个压缩包文件，通常包含了一组与编程学习平台洛谷（Luogu）相关的教学资源。洛谷是一个面向程序员的在线编程竞赛平台，同时也提供学习资料和教程，帮助用户提升编程技能。由于没有具体的标签...
Luogu P1591 阶乘数码 普及-
evibhm的博客
06-07 174
高精度，用 Python 秒了 AC代码 from math import * t = int(input()) for _ in range(t): n, a = input().split() s = str(factorial(int(n))) cnt = 0 for i in s: if i == a: cnt += 1 print(cnt) 为了尊重下传统语言C++，我还是重新写了一遍 说明：OJ不能提交不怪我啊
八数码难题——广搜+（哈希+编码+set）
09-24 1230
八数码难题，归结为图上的最短路问题，也称路径寻找问题 因为要存储每个状态，而且每个状态是一个9位数，所以可以将其存储在数组中，但这需要开一个九位数组，9维数组每一维都有9个元素，一共有9^9=387420489，数组是开不下的，而实际的节点数是9！=362880个，9维数组中存在大量的浪费。所以有下列三种常见的方法解决这个问题。 1.把排列变成整数，设计一套对应的编码，使0~8的全排列和9!=362
八数码问题
光何
05-11 1万+
摘要：近日来，人工智能成为科技领域搜索热词，无论是从人机大战的新闻来看，还是从新提出的深度学习理论来分析，我们可以可以清晰的预见，人工智能即将腾飞。   人工智能，顾名思义，就是模拟人类思考模式的超级算法系统，学习能力和推理能力是其核心内容。举个简单的例子，“机器学习（MachineLearning）”就是人工智能领域里很有前途的课题，其主要内容是利用大数据训练程序，让它们找到一些可遵循的规
题解 P1379 【八数码难题】
dkirhf8740的博客
08-02 375
前言：对于八数码难题这道经典bfs的题目，（这是我听学长讲的），我花了不止多久的时间才过了它。 思路：首先，我们可以用bfs，在队列中存储每一步的状态，并将这一个状态取hash值，也就是众位大佬讲的康托展开，如果当某一个状态的hash值已经等于了目标状态的hash值，那么直接输出它的步数即可。（因为广搜有一个第一个搜到的目标状态必定是最优的特性） 补充——康托展开（以下内容选自度娘）：...
题解-八数码问题
Ampty36的博客
05-03 2417
八数码问题 描述 八方块移动游戏要求从一个含 8 个数字（用 1-8 表示）的方块以及一个空格方块（用 0 表示）的 3 × 3 矩阵的起始状态开始，不断移动该空格方块以使其和相邻的方块互换，直至达到所定义的目标状态。空格方块在中间位置时有上、下、左、右 4 个方向可移动，在四个角落上有 2个方向可移动，在其他位置上有 3 个方向可移动。例如，假设一个 3× 3 矩阵的初始状态为： 8 0 3 2...
洛谷题目目录
热门推荐
zqhf123的博客
02-07 25万+
#1 新手村 关卡1-1 洛谷的第一个任务 超级玛丽游戏（洛谷-P1000）：点击这里 A+B Problem（洛谷-P1001）：点击这里 小玉买文具（洛谷-P1421）：点击这里 小鱼的游泳时间（洛谷-P1425）：点击这里 关卡1-2 顺序与分支 小玉家的电费（洛谷-P1422）：点击这里 不高兴的津津（洛谷-P1085）：点击这里 津津的储蓄计划（洛谷-P1089）：点击这里 买铅笔（洛谷...
[luogu]P1379 八数码难题[广度优先搜索]
diezhen8177的博客
07-24 134
八数码难题 ——!x^n+y^n=z^n 　　我在此只说明此题的一种用BFS的方法，因为本人也是初学，勉勉强强写了一个单向的BFS，据说最快的是IDA*（然而蒟蒻我不会…） 　　各位如果想用IDA*的可以看看这位大佬的这篇文章： http://www.cnblogs.com/ZYBGMZL/p/6852733.html 　　接下来是我的方法，用luogu的跑了最慢是200ms，...
八数码问题（暴力）
Dosth_Magic
08-01 1524
紫书上的程序真是牛逼 用到了路径寻找之类，还有状态数组，bfs，按坐标寻路的数组，hash，编码解码，STL等 #include #include #include #include using namespace std; #define maxstate 1000000 typedef int State[9]; State st[maxstate] , goal; int dist[ma
八数码难题（启发式搜索）
轻尘
03-20 1万+
八数码难题---启发式搜素 1.启发式搜索：特点：重排OPEN表，选择最有希望的节点加以扩展种类：有序搜索(A算法)、A*算法等 2.估价函数用来估算节点处于最佳求解路径上的希望程度的函数f(n) = g(n) + h(n) n——搜索图中的某个当前被扩展的节点；f(n) ——从初始状态节点s, 经由节点n到达目标节点ng，估计的最小路径代价； g(n) ——从s到n 的实际路径代价；h(n)——...
vscode-luogu
最新发布
07-30
`vscode-luogu`是一个Visual Studio Code (VSCode) 扩展插件，专为参与洛谷（Luogu）在线编程平台的用户设计。这个插件旨在提供对洛谷题库、数据提交、评测结果查看以及代码高亮支持等功能，使得VSCode用户能够在该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值