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 = "";

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();

    }

}

inline void bfs() {

    while(!Q1.empty()) {

        Node topp = Q1.front();

        Q1.pop();

        string s1 = topp.s;

        Step = topp.step;

        int f = s1.find('');

        Node nxt;

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            //4 7    6 7    8 7

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

        if(f == ) {

            //58   78

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            swap(s1[], s1[]);

            swap(s1[], s1[]);

            pd(s1, topp.step + );

            if(!mp[s1]) {

                nxt.s = s1;

                nxt.step = topp.step + ;

                Q1.push(nxt);

                mp[s1] = ;

            }

            continue;

        }

    }

}

int main() {

    cin >> s_start;

    Node now;

    now.s = s_start;

    now.step = ;

    Q1.push(now);

    bfs();

    return ;

}

//

[Luogu] 八数码难题的更多相关文章

  1. [luogu]P1379 八数码难题[广度优先搜索]

    八数码难题 ——!x^n+y^n=z^n 我在此只说明此题的一种用BFS的方法,因为本人也是初学,勉勉强强写了一个单向的BFS,据说最快的是IDA*(然而蒟蒻我不会…) 各位如果想用IDA*的可以看看 ...

  2. 双向广搜+hash+康托展开 codevs 1225 八数码难题

    codevs 1225 八数码难题  时间限制: 1 s  空间限制: 128000 KB  题目等级 : 钻石 Diamond   题目描述 Description Yours和zero在研究A*启 ...

  3. Codevs 1225 八数码难题

    1225 八数码难题 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 钻石 Diamond 题目描述 Description Yours和zero在研究A*启发式算法.拿到一道经典的 ...

  4. 洛谷P1379八数码难题

    题目描述 在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字.棋盘中留有一个空格,空格用0来表示.空格周围的棋子可以移到空格中. 要求解的问题是:给出一种初始布局(初始状态)和目标布局(为 ...

  5. 洛谷 P1379 八数码难题 解题报告

    P1379 八数码难题 题目描述 在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字.棋盘中留有一个空格,空格用0来表示.空格周围的棋子可以移到空格中.要求解的问题是:给出一种初始布局(初 ...

  6. 【洛谷P1379】八数码难题（广搜、A*）

    八数码难题 题目描述 一.广搜: 首先要考虑用什么存每一个状态 显然每个状态都用一个矩阵存是很麻烦的. 我们可以考虑将一个3*3的矩阵用一个字符串或long long 存. 每次扩展时再转化为矩阵. ...

  7. 习题：八数码难题（双向BFS）

    八数码难题(wikioi1225) [题目描述] 在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字.棋盘中留有一个空格,空格用0来表示.空格周围的棋子可以移到空格中.要求解的问题是:给出 ...

  8. 「LuoguP1379」 八数码难题（迭代加深

    [P1379]八数码难题 - 洛谷 题目描述 在3×3的棋盘上,摆有八个棋子,每个棋子上标有1至8的某一数字.棋盘中留有一个空格,空格用0来表示.空格周围的棋子可以移到空格中.要求解的问题是:给出一种 ...

  9. 洛谷——P1379 八数码难题

    P1379 八数码难题 双向BFS 原来双向BFS是这样的:终止状态与起始状态同时入队,进行搜索,只不过状态标记不一样而已,本题状态使用map来存储 #include<iostream> ...

随机推荐

  1. Python开发【模块】：paramiko

    一.堡垒机前戏 开发堡垒机之前,先来学习Python的paramiko模块,该模块基于SSH用于连接远程服务器并执行相关操作 模块安装 C:\Program Files\Python 3.5\Scri ...

  2. 【数学】Prime-Factor Prime

    Prime-Factor Prime 题目描述 A positive integer is called a "prime-factor prime" when the numbe ...

  3. （四）Spring Boot之配置文件-多环境配置

    一.Properties多环境配置 1. application.properties配置激活选项 spring.profiles.active=dev 2.添加其他配置文件 3.结果 applica ...

  4. Android 自定义控件之 日期选择控件

    效果如下: 调用的代码: @OnClick(R.id.btn0) public void btn0() { final AlertDialog dialog = new AlertDialog.Bui ...

  5. JS 长按 移动端

    实质上,长按的时间不应该过长,因为这有可能与手机系统的部分长按手势产生冲突,但也不宜过短,因为长按时间过短与点击没有任何区别, 理论上,判断长按结束,在手机端上仅设置mouseup动作就可以, < ...

  6. luogu题解P1967货车运输--树链剖分

    题目链接 https://www.luogu.org/problemnew/show/P1967 分析 NOIp的一道裸题,直接在最大生成树上剖分取最小值一下就完事了,非常好写,常数也比较小,然而题解 ...

  7. 移动端自适应之flexible

    移动端自适应之flexible 作用:flexible的作用是使页面可以适配不同移动终端 原理:在页面html标签上添加style = "font-size: 36px;"样式,设 ...

  8. springboot 上传图片，地址，在页面展示图片

    package com.cxwlw.zhcs.controller.api;import org.springframework.stereotype.Controller;import org.sp ...

  9. http通讯过程

  10. 对WAF的一些认知

    WAF分为非嵌入型与嵌入型, 非嵌入型指的是硬WAF.云WAF.虚拟机WAF之类的:嵌入型指的是web容器模块类型WAF.代码层WAF.非嵌入型对WEB流量的解析完全是靠自身的,而嵌入型的WAF拿到的 ...