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

long long ago

暴力bfs

  1. #include <iostream>
  2. #include <cstdio>
  3. #include <algorithm>
  4. #include <map>
  5. #include <queue>
  6. #include <cstring>
  7. #include <string>
  8.  
  9. using namespace std;
  10. const string s_end = "";
  11.  
  12. struct Node {
  13.     string s;
  14.     int step;
  15. };
  16. queue <Node> Q1;
  17. map <string, bool> mp;
  18. string s_start;
  19. int Step;
  20.  
  21. inline void pd(string ss, int answer) {
  22.     if(ss == s_end) {
  23.         printf("%d",answer);
  24.         exit();
  25.     }
  26. }
  27.  
  28. inline void bfs() {
  29.     while(!Q1.empty()) {
  30.         Node topp = Q1.front();
  31.         Q1.pop();
  32.         string s1 = topp.s;
  33.         Step = topp.step;
  34.         int f = s1.find('');
  35.         Node nxt;
  36.         if(f == ) {
  37.             swap(s1[], s1[]);
  38.             pd(s1, topp.step + );
  39.             if(!mp[s1]) {
  40.                 nxt.s = s1;
  41.                 nxt.step = topp.step + ;
  42.                 Q1.push(nxt);
  43.                 mp[s1] = ;
  44.             }
  45.             swap(s1[], s1[]);
  46.             swap(s1[], s1[]);
  47.             pd(s1, topp.step + );
  48.             if(!mp[s1]) {
  49.                 nxt.s = s1;
  50.                 nxt.step = topp.step + ;
  51.                 Q1.push(nxt);
  52.                 mp[s1] = ;
  53.             }
  54.             continue;
  55.         }
  56.         if(f == ) {
  57.             swap(s1[], s1[]);
  58.             pd(s1, topp.step + );
  59.             if(!mp[s1]) {
  60.                 nxt.s = s1;
  61.                 nxt.step = topp.step + ;
  62.                 Q1.push(nxt);
  63.                 mp[s1] = ;
  64.             }
  65.             swap(s1[], s1[]);
  66.             swap(s1[], s1[]);
  67.             pd(s1, topp.step + );
  68.             if(!mp[s1]) {
  69.                 nxt.s = s1;
  70.                 nxt.step = topp.step + ;
  71.                 Q1.push(nxt);
  72.                 mp[s1] = ;
  73.             }
  74.             swap(s1[], s1[]);
  75.             swap(s1[], s1[]);
  76.             pd(s1, topp.step + );
  77.             if(!mp[s1]) {
  78.                 nxt.s = s1;
  79.                 nxt.step = topp.step + ;
  80.                 Q1.push(nxt);
  81.                 mp[s1] = ;
  82.             }
  83.             continue;
  84.         }
  85.         if(f == ) {
  86.             swap(s1[], s1[]);
  87.             pd(s1, topp.step + );
  88.             if(!mp[s1]) {
  89.                 nxt.s = s1;
  90.                 nxt.step = topp.step + ;
  91.                 Q1.push(nxt);
  92.                 mp[s1] = ;
  93.             }
  94.             swap(s1[], s1[]);
  95.             swap(s1[], s1[]);
  96.             pd(s1, topp.step + );
  97.             if(!mp[s1]) {
  98.                 nxt.s = s1;
  99.                 nxt.step = topp.step + ;
  100.                 Q1.push(nxt);
  101.                 mp[s1] = ;
  102.             }
  103.             continue;
  104.         }
  105.         if(f == ) {
  106.             swap(s1[], s1[]);
  107.             pd(s1, topp.step + );
  108.             if(!mp[s1]) {
  109.                 nxt.s = s1;
  110.                 nxt.step = topp.step + ;
  111.                 Q1.push(nxt);
  112.                 mp[s1] = ;
  113.             }
  114.             swap(s1[], s1[]);
  115.             swap(s1[], s1[]);
  116.             pd(s1, topp.step + );
  117.             if(!mp[s1]) {
  118.                 nxt.s = s1;
  119.                 nxt.step = topp.step + ;
  120.                 Q1.push(nxt);
  121.                 mp[s1] = ;
  122.             }
  123.             swap(s1[], s1[]);
  124.             swap(s1[], s1[]);
  125.             pd(s1, topp.step + );
  126.             if(!mp[s1]) {
  127.                 nxt.s = s1;
  128.                 nxt.step = topp.step + ;
  129.                 Q1.push(nxt);
  130.                 mp[s1] = ;
  131.             }
  132.             continue;
  133.         }
  134.         if(f == ) {
  135.             swap(s1[], s1[]);
  136.             pd(s1, topp.step + );
  137.             if(!mp[s1]) {
  138.                 nxt.s = s1;
  139.                 nxt.step = topp.step + ;
  140.                 Q1.push(nxt);
  141.                 mp[s1] = ;
  142.             }
  143.             swap(s1[], s1[]);
  144.             swap(s1[], s1[]);
  145.             pd(s1, topp.step + );
  146.             if(!mp[s1]) {
  147.                 nxt.s = s1;
  148.                 nxt.step = topp.step + ;
  149.                 Q1.push(nxt);
  150.                 mp[s1] = ;
  151.             }
  152.             swap(s1[], s1[]);
  153.             swap(s1[], s1[]);
  154.             pd(s1, topp.step + );
  155.             if(!mp[s1]) {
  156.                 nxt.s = s1;
  157.                 nxt.step = topp.step + ;
  158.                 Q1.push(nxt);
  159.                 mp[s1] = ;
  160.             }
  161.             swap(s1[], s1[]);
  162.             swap(s1[], s1[]);
  163.             pd(s1, topp.step + );
  164.             if(!mp[s1]) {
  165.                 nxt.s = s1;
  166.                 nxt.step = topp.step + ;
  167.                 Q1.push(nxt);
  168.                 mp[s1] = ;
  169.             }
  170.             continue;
  171.         }
  172.         if(f == ) {
  173.             swap(s1[], s1[]);
  174.             pd(s1, topp.step + );
  175.             if(!mp[s1]) {
  176.                 nxt.s = s1;
  177.                 nxt.step = topp.step + ;
  178.                 Q1.push(nxt);
  179.                 mp[s1] = ;
  180.             }
  181.             swap(s1[], s1[]);
  182.             swap(s1[], s1[]);
  183.             pd(s1, topp.step + );
  184.             if(!mp[s1]) {
  185.                 nxt.s = s1;
  186.                 nxt.step = topp.step + ;
  187.                 Q1.push(nxt);
  188.                 mp[s1] = ;
  189.             }
  190.             swap(s1[], s1[]);
  191.             swap(s1[], s1[]);
  192.             pd(s1, topp.step + );
  193.             if(!mp[s1]) {
  194.                 nxt.s = s1;
  195.                 nxt.step = topp.step + ;
  196.                 Q1.push(nxt);
  197.                 mp[s1] = ;
  198.             }
  199.             continue;
  200.         }
  201.         if(f == ) {
  202.             swap(s1[], s1[]);
  203.             pd(s1, topp.step + );
  204.             if(!mp[s1]) {
  205.                 nxt.s = s1;
  206.                 nxt.step = topp.step + ;
  207.                 Q1.push(nxt);
  208.                 mp[s1] = ;
  209.             }
  210.             swap(s1[], s1[]);
  211.             swap(s1[], s1[]);
  212.             pd(s1, topp.step + );
  213.             if(!mp[s1]) {
  214.                 nxt.s = s1;
  215.                 nxt.step = topp.step + ;
  216.                 Q1.push(nxt);
  217.                 mp[s1] = ;
  218.             }
  219.             continue;
  220.         }
  221.         if(f == ) {
  222.             //4 7    6 7    8 7
  223.             swap(s1[], s1[]);
  224.             pd(s1, topp.step + );
  225.             if(!mp[s1]) {
  226.                 nxt.s = s1;
  227.                 nxt.step = topp.step + ;
  228.                 Q1.push(nxt);
  229.                 mp[s1] = ;
  230.             }
  231.             swap(s1[], s1[]);
  232.             swap(s1[], s1[]);
  233.             pd(s1, topp.step + );
  234.             if(!mp[s1]) {
  235.                 nxt.s = s1;
  236.                 nxt.step = topp.step + ;
  237.                 Q1.push(nxt);
  238.                 mp[s1] = ;
  239.             }
  240.             swap(s1[], s1[]);
  241.             swap(s1[], s1[]);
  242.             pd(s1, topp.step + );
  243.             if(!mp[s1]) {
  244.                 nxt.s = s1;
  245.                 nxt.step = topp.step + ;
  246.                 Q1.push(nxt);
  247.                 mp[s1] = ;
  248.             }
  249.             continue;
  250.         }
  251.         if(f == ) {
  252.             //58   78
  253.             swap(s1[], s1[]);
  254.             pd(s1, topp.step + );
  255.             if(!mp[s1]) {
  256.                 nxt.s = s1;
  257.                 nxt.step = topp.step + ;
  258.                 Q1.push(nxt);
  259.                 mp[s1] = ;
  260.             }
  261.             swap(s1[], s1[]);
  262.             swap(s1[], s1[]);
  263.             pd(s1, topp.step + );
  264.             if(!mp[s1]) {
  265.                 nxt.s = s1;
  266.                 nxt.step = topp.step + ;
  267.                 Q1.push(nxt);
  268.                 mp[s1] = ;
  269.             }
  270.             continue;
  271.         }
  272.     }
  273. }
  274.  
  275. int main() {
  276.     cin >> s_start;
  277.     Node now;
  278.     now.s = s_start;
  279.     now.step = ;
  280.     Q1.push(now);
  281.     bfs();
  282.     return ;
  283. }
  284. //

[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. PHP的 parse_ini_file 解析配置文件

    解析配置文件: parse_ini_file 类似解析php.ini文件样 配置文件内容如下: Example #1 sample.ini 的内容 ; This is a sample configu ...

  2. poj 2406 求最短重复字串

    题解: KMP中next数组的巧妙运用.在这里我们假设这个字符串的长度是len,那么如果len可以被len-next[len]整除的话,我们就可以说len-next[len]就是那个最短子串的长度为什 ...

  3. （八）Redis之持久化之AOF方式

    一.概念 AOF方式:将以日志,记录每一个操作 优势:安全性相对RDB方式高很多: 劣势:效率相对RDB方式低很多: 二.案例 appendonly no默认关闭aof方式 我们修改成yes 就开启 ...

  4. c#基础知识梳理（二）

    上期回顾 - https://www.cnblogs.com/liu-jinxin/p/10818256.html 一.变量 一个变量只不过是一个供程序操作的存储区的名字.在 C# 中,每个变量都有一 ...

  5. JAVA文件IO总结

    文件流的操作有两种:字节流.字符流 字节流:FileInputStream,FileInputStream 字符流:InputStreamReader,OutputStreamReader 这两种流对 ...

  6. ajax对数据删除、查看详情功能

    运用bootstrap,jquery和ajax显示一些数据,附加删除功能并且点击能弹出模态框详情功能 主页面main.php <!DOCTYPE html PUBLIC "-//W3C ...

  7. vue的$nextTick使用后的js代码执行顺序问题

    一.问题产生背景: 父组件已经获得子组件实例,并能直接触发子组件的方法,在父组件中调用了子组件的两个方法 // 父组件调用子组件,this.picker是获取的子组件整个实例,先调用update,再调 ...

  8. BeginInvoke异步线程

    this.BeginInvoke(new Action(() => { dataGridView1.DataSource = BLLBillConsume.BllGetClearMarketLo ...

  9. bash shell的ANSI控制

    格式: echo -e "\033[字背景颜色;字体颜色m字符串\033[0m" 例如:  echo -e "\033[41;36m something here \03 ...

  10. linux /etc/shadow文件详解

    struct spwd { char *sp_namp; /* user login name */ char *sp_pwdp; /* encrypted password */ long int ...