luoguP1379 八数码难题（bfs）

最新推荐文章于 2024-04-20 08:00:00 发布
最新推荐文章于 2024-04-20 08:00:00 发布
阅读量195 收藏
点赞数
分类专栏： 搜索 知识储备 文章标签： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_tongtong/article/details/79233375
版权

题目链接

分析：
没什么可说的，bfs
方便起见，我们需要把矩阵转化成一个数，代码中我使用的是康托展开

康托展开的公式： X=an∗(n−1)!+an−1∗(n−2)!+...+ai∗(i−1)!+..+a2∗1!+a1∗0! X = a n ∗ ( n − 1 ) ! + a n − 1 ∗ ( n − 2 ) ! + . . . + a i ∗ ( i − 1 ) ! + . . + a 2 ∗ 1 ! + a 1 ∗ 0 !
其中， ai a i 在当前未出现的元素中排第几（从0开始）

举个例子：
s=DBAC s = D B A C

a4=′D′ a 4 = ′ D ′ 这个元素在数组 [′D′,′B′,′A′,′C′] [ ′ D ′ , ′ B ′ , ′ A ′ , ′ C ′ ] 中是第几大的元素
′A′ ′ A ′ 是第0大的元素， ′B′ ′ B ′ 是第1大的元素， ′C′ ′ C ′ 是第2大的元素， ′D′ ′ D ′ 是第3大的元素，所以 a4=3 a 4 = 3
我们删除 ′D′ ′ D ′ ，继续↓

a3=′B′ a 3 = ′ B ′ 这个元素在数组 [′B′,′A′,′C′] [ ′ B ′ , ′ A ′ , ′ C ′ ] 中是第几大的元素
′A′ ′ A ′ 是第0大的元素， ′B′ ′ B ′ 是第1大的元素， ′C′ ′ C ′ 是第2大的元素，所以 a3=1 a 3 = 1
我们删除 ′B′ ′ B ′ ，继续↓

a2=′A′ a 2 = ′ A ′ 这个元素在数组 [′A′,′C′] [ ′ A ′ , ′ C ′ ] 中是第几大的元素
′A′ ′ A ′ 是第0大的元素， ′C′ ′ C ′ 是第1大的元素，所以 a2=0 a 2 = 0
我们删除 ′A′ ′ A ′ ，继续↓

a1=′C′ a 1 = ′ C ′ 这个元素在数组 [′C′] [ ′ C ′ ] 中是第几大的元素
′C′ ′ C ′ 是第0大的元素，所以 a1=0 a 1 = 0
（因为子数组只有1个元素，所以 a1 a 1 总是为0）

所以， X(s)=3∗3!+1∗2!+0∗1!+0∗0!=20 X ( s ) = 3 ∗ 3 ! + 1 ∗ 2 ! + 0 ∗ 1 ! + 0 ∗ 0 ! = 20

这道题中的数组比较小，我们直接暴力计算康托展开值即可

tip

平生最长代码
胆大心细
特此纪念

#include<cstdio>  //广搜+康托展开
#include<iostream>
#include<cstring>
#include<algorithm>

using namespace std;

const int jc[9]={1,1,2,6,24,120,720,5040,40320};
char chu[10];
int num[362881][10],tou,wei;
int da[9]={1,2,3,8,0,4,7,6,5};
bool p[362881];
int deep[362881];

int cl(int bh)
{
    int i,j;
    int ans,sum=0;
    for (i=0;i<=8;i++)
    {
        ans=0;
        for (j=i+1;j<=8;j++)
           if (num[bh][j]<num[bh][i])
              ans++;
        sum+=ans*jc[8-i];
    }
    return sum;
}

bool pd(int bh)
{
    int i;
    for (i=0;i<=8;i++)
      if (num[bh][i]!=da[i])
        return 0;
    return 1;
}

int ss()
{
    int i,j,hh,r;
    tou=-1;
    wei=1;
    do
    {
        tou++;
        hh=wei+1;
        for (i=0;i<=8;i++)
           num[hh][i]=num[tou][i];
        for (i=0;i<=8;i++)
          if (num[tou][i]==0)
          {
             j=i;
             break;
          }
        if (j==0)  //分情况                           // 0 1 2
        {                                             // 3 4 5
            swap(num[hh][0],num[hh][1]);              // 6 7 8
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][0],num[hh][1]);
            swap(num[hh][0],num[hh][3]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][0],num[hh][3]);
        }
        else
        if (j==2)
        {
            swap(num[hh][1],num[hh][2]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][1],num[hh][2]);
            swap(num[hh][2],num[hh][5]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][2],num[hh][5]);
        }
        if (j==6)
        {
            swap(num[hh][6],num[hh][3]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][6],num[hh][3]);
            swap(num[hh][6],num[hh][7]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][6],num[hh][7]);
        }
        if (j==8)
        {
            swap(num[hh][8],num[hh][7]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][8],num[hh][7]);
            swap(num[hh][8],num[hh][5]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][8],num[hh][5]);
        }
        if (j==1)
        {
            swap(num[hh][1],num[hh][0]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][1],num[hh][0]);
            swap(num[hh][1],num[hh][2]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][1],num[hh][2]);
            swap(num[hh][1],num[hh][4]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][1],num[hh][4]);
        }
        if (j==3)
        {
            swap(num[hh][3],num[hh][0]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][3],num[hh][0]);
            swap(num[hh][3],num[hh][4]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][3],num[hh][4]);
            swap(num[hh][3],num[hh][6]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][3],num[hh][6]);
        }
        if (j==5)
        {
            swap(num[hh][5],num[hh][2]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][5],num[hh][2]);
            swap(num[hh][5],num[hh][4]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][5],num[hh][4]);
            swap(num[hh][5],num[hh][8]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][5],num[hh][8]);
        }
        if (j==7)
        {
            swap(num[hh][7],num[hh][6]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][7],num[hh][6]);
            swap(num[hh][7],num[hh][4]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][7],num[hh][4]);
            swap(num[hh][7],num[hh][8]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][7],num[hh][8]);
        }
        if (j==4)
        {
            swap(num[hh][4],num[hh][1]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][4],num[hh][1]);
            swap(num[hh][4],num[hh][3]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][3],num[hh][4]);
            swap(num[hh][4],num[hh][5]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][4],num[hh][5]);
            swap(num[hh][4],num[hh][7]);
            r=cl(hh);
            if (p[r]==1)
            {
                p[r]=0;
                wei++;
                deep[wei]=deep[tou]+1;
                if (pd(wei)==1)
                {
                   printf("%d",deep[wei]);
                   return 0;
                }
                hh++;
                for (i=0;i<=8;i++)
                   num[hh][i]=num[tou][i];
            }
            else    
              swap(num[hh][4],num[hh][7]);
        }
    }
    while (tou<wei);
    return 0;
}

int main()
{
    memset(p,1,sizeof(p));
    cin>>chu;
    for (int i=0;i<=8;i++)
        num[0][i]=chu[i]-'0';
    p[cl(0)]=0;
    deep[0]=0;
    if (pd(0)==1)
        printf("0");
    else
        ss();
    return 0;
}
Coco_T_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
P1379 八数码难题 题解
bifanwen的博客
04-04 1695
原题链接 简要题意： 给定一个 3×33 \times 33×3 的矩阵，每次可以把空格旁边（四方向）的一个位置移到空格上。求到目标状态的最小步数。 前置知识： 深度优先搜索（dfs\texttt{dfs}dfs）. 将这题作为 宽度优先搜索（bfs\texttt{bfs}bfs） 的模板题讲解！ 首先，众所周知 dfs\texttt{dfs}dfs 的搜索树类似于这样： 其中，每个矩形都...
Java实现 蓝桥杯 算法提高 八数码（BFS）
南 墙
04-28 1万+
试题 算法提高 八数码 问题描述 　　RXY八数码 输入格式 　　输入两个33表格 　　第一个为目标表格 　　第二个为检索表格 输出格式 　　输出步数 样例输入 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 0 8 样例输出 1 数据规模和约定 　　33*2 import java.util.*; public class Main { static int[]dx = ...
八数码问题BFS算法
李子园
12-10 1771
八数码求解
BFS解决八数码问题-java
最新发布
m0_63267251的博客
04-20 1396
本文主要通过BFS广度优先搜索来解决八数码问题。提示：以下是本篇文章正文内容，下面案例可供参考上述也是通过BFS来解决最短路的问题，我们只要分清楚各个状态如何变化和存储，知道一个点是从哪个点抽象变化过来的，就可以解决这一类问题。
【题目】八数码难题（BFS）
Mashiro_ylb的博客
10-17 3084
八数码难题题
人工智能实验——八数码难题
热门推荐
weixin_51735061的博客
05-14 2万+
人工智能实验 八数码难题 利用了BFS算法DFS算法A*算法
c++八数码难题全家桶（A*算法、双向BFS、BFS、DFS）
qq_54893805的博客
10-21 3395
本文用C++实现了八数码问题，详尽四种经典算法：A*算法、双向BFS、BFS、DFS,有被八数码问题困扰的uu们，抓紧时间，进入正文，一定会对你有所帮助！
简单的BFS处理——八数码问题
AugustCat0016的博客
07-12 2046
八数码是一道极为经典的宽搜题目，在此题目如下： 3×3九宫棋盘，放置数码为1-8的8个棋牌，剩下一个空格，只能通过棋牌向空格的移动来改变棋盘的布局。要求：根据给定初始布局，问：至少移动几次才能从初始布局到达目标布局。 目标布局如下图： Input Description 3行，每行3个0-8的不重复整数，其中0表示空格所在的位置，
洛谷P1379【八数码问题】【九宫重排】算法优化
passerbyYSQ
10-27 1451
题目描述 洛谷P1379 八数码难题（本博客的代码和描述都是针对洛谷这题） 问题 1426: [蓝桥杯][历届试题]九宫重排（与洛谷那题 [基本] 一样，输入有所不同） 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123...
BFS解决八数码问题
12-29
在图1，3*3的方格棋盘上，摆放着1到8这八个数码，有1个方格是空。 如图1所示，要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态（图1左）到目标状态（图1右）。 可自行设计初始...
八数码BFS，DFS，BBFS，Astar实现
03-23
标题中的“八数码”是指经典的八数码问题，也被称为滑动拼图游戏。在这个游戏中，一个3x3的...通过比较BFS、DFS、BBFS和A*在解决八数码问题上的性能，我们可以深入理解它们的优缺点，并为实际问题选择合适的搜索策略。
八码难题BFS的实现
07-22
经典的八码难题BFS广度优先算法的源代码。
八数码难题——Python代码求解
04-14
这个压缩包提供的资源包含了解决八数码难题的多种算法实现，包括广度优先搜索（BFS）、深度优先搜索（DFS）、贪心算法、以及A*算法，并且还有一个设计了用户界面（UI）的代码，使得解题过程能够以可视化的形式展示。...
八数码 十五数码 人工智能 C语言bfs深度搜索算法实现
05-07
解决八数码（N=3）以及十五数码（N=4）等人工智能数码，使用宽度搜索算法
矩形覆盖
Coco_T的博客
01-19 1040
矩形覆盖题目描述在平面上有 n 个点（n <= 50），每个点用一对整数坐标表示。 这些点可以用 k 个矩形（1<=k<=4）全部覆盖，矩形的边平行于坐标轴。问题是当 n 个点坐标和 k 给出后，怎样才能使得覆盖所有点的 k 个矩形的面积之和为最小呢。约定：覆盖一个点的矩形面积为 0；覆盖平行于坐标轴直线上点的矩形面积也为0。各个矩形必须完全分开（边线与顶点也都不能重合）。输入输出格式输入格式：
骑士旅行问题的试探性算法研究
Coco_T的博客
02-08 513
背景介绍 骑士旅行问题想必大家都很熟悉了吧 这道题的众人向做法就是深度搜索（直接给出一个很C_T风格的代码）： #include<iostream> #include<iomanip> using namespace std; int zz[8][2]={{1,2},{2,1},{1,-2},{-2,1},{-1,2},{2,-1},{-1,-2},{-2,-1}};...
luogu1092虫食算(未AC，待续中~~~)
Coco_T的博客
05-31 463
题目描述所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子：43#9865#045 +8468#6633 ——————— 44445509678其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。现在，我们对问题做两个限制：首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中
bzoj1815 [Shoi2006]color 有色图（dfs+置换【polya论文例题）
Coco_T的博客
02-05 446
题目链接 分析： 原版题解见论文 这个问题中，置换群中的对象就是n(n−1)2" role="presentation" style="position: relative;">n(n−1)2n(n−1)2{n(n-1) \over 2}条边，k种颜色 G" role="presentation" style="position: relative;">GGG是由点的置换引起
noip胡测之8.15（没有正解）
Coco_T的博客
08-15 430
T1 约瑟夫游戏 (joseph.cpp/c/pas) 【问题描述】 YJC 很喜欢玩游戏，今天他决定和朋友们玩约瑟夫游戏。 约瑟夫游戏的规则是这样的：n 个人围成一圈，从 1 号开始依次报数，当报到 m 时，报 1、2、…、m-1 的人出局，下一个人接着从 1开始报，保证(n-1)是(m-1)的倍数。最后剩的一个人获胜。 YJC 很想赢得游戏，但他太笨了，他想让你帮他算出自己应该站在哪个
八数码难题的广度优先搜索(BFS)求解策略
"本文主要介绍了使用广度优先搜索（BFS）解决8数码问题的策略。8数码问题是在3x3的棋盘上，通过移动空格与相邻数字，目标是从给定的初始布局到达目标布局，寻找最少步数的解决方案。在搜索过程中，将每个状态视为树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值