洛谷p1379 八数码问题的5种解决方法

于 2023-07-29 12:27:23 发布
阅读量89 收藏
点赞数
文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wansanxun/article/details/131993432
版权

1.全排列 + bfs


#include<stdio.h>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 4e5 + 8;
int num[N], v[N], len;
int res = 123804765;
int changelo[9][4] = { {-1,-1,3,1},{-1,0,4,2},{-1,1,5,-1},
                    {0,-1,6,4},{1,3,7,5},{2,4,8,-1},
                    {3,-1,-1,7},{4,6,-1,8},{5,7,-1,-1}
};
bool vn[9];
char ans[11];
int s;
void pailie(int k)
{
    for (int i = 0; i < 9; i++)
    {
        if (!vn[i])
        {
            ans[k] = i + '0';
            vn[i] = 1;
            if (k == 8)
            {
                sscanf(ans, "%d", &num[len++]);
            }
            else
                pailie(k + 1);
            vn[i] = 0;
        }
    }
}
void swapch(char* a, int p1, int p2)
{
    char b = a[p1];
    a[p1] = a[p2];
    a[p2] = b;
}

struct node
{
    int numn;
    int pos;
    int val;
};
bool flag;
void bfs(int n, int p)
{
    queue<node> q;
    q.push({ n, p, 0 });
    int p1 = lower_bound(num, num + len, n) - num;
    v[p1] = 1;
    while (!q.empty())
    {
        node no = q.front();
        q.pop();
        char cur[11];
        sprintf(cur, "%09d", no.numn);
        int p2 = no.pos;
        for (int i = 0; i < 4; i++)
        {
            if (changelo[p2][i] != -1)
            {
                swapch(cur, p2, changelo[p2][i]);
                int n1;  sscanf(cur, "%d", &n1);
                if (n1 == res)
                {
                    printf("%d", no.val + 1);
                    flag = true;
                    return;
                }
                int k = lower_bound(num, num + len, n1) - num;
                if (!v[k])
                {
                    v[k] = 1;
                    q.push({ n1, changelo[p2][i], no.val + 1 });
                }
                swapch(cur, p2, changelo[p2][i]);
            }
        }
    }
}

int main()
{
    char a[11]; int sp;
    cin >> a;
    for (int i = 0; i < 9; i++)
        if (a[i] == '0')
        {
            sp = i;
            break;
        }
    sscanf(a, "%d", &s);
     if (s == res)
    {
        printf("0"); return 0;
    }
    pailie(0);
    bfs(s, sp);
    if (!flag) printf("unsolvable");
    return 0;
}

​

2.map + bfs

#include<stdio.h>
#include<queue>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
const int N = 4e5 + 8;
map<string, int> num;
string res = "123804765";
int changelo[9][4] = { {-1,-1,3,1},{-1,0,4,2},{-1,1,5,-1},
                    {0,-1,6,4},{1,3,7,5},{2,4,8,-1},
                    {3,-1,-1,7},{4,6,-1,8},{5,7,-1,-1}
};
string s;
void swapch(string& a, int p1, int p2)
{
    char b = a[p1];
    a[p1] = a[p2];
    a[p2] = b;
}

struct node
{
    string numn;
    int pos;
    int val;
};
bool flag;
void bfs(string n, int p)
{
    queue<node> q;
    q.push({ n, p, 0 });
    num[n] = 1;
    while (!q.empty())
    {
        node no = q.front();
        q.pop();
        string cur = no.numn;
        int p2 = no.pos;
        for (int i = 0; i < 4; i++)
        {
            if (changelo[p2][i] != -1)
            {
                swapch(cur, p2, changelo[p2][i]);
                if (cur == res)
                {
                    printf("%d", no.val + 1);
                    flag = true;
                    return;
                }
                if (!num[cur])
                {
                    num[cur] = 1;
                    q.push({ cur, changelo[p2][i], no.val + 1 });
                }
                swapch(cur, p2, changelo[p2][i]);
            }
        }
    }
}

int main()
{
    int sp;
    cin >> s;
    for (int i = 0; i < 9; i++)
        if (s[i] == '0')
        {
            sp = i;
            break;
        }
    if (s == res)
    {
        printf("0"); return 0;
    }
    bfs(s, sp);
    if (!flag) printf("unsolvable");
    return 0;
}

3.双向广搜 + map

#include<stdio.h>
#include<queue>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
const int N = 4e5 + 8;
map<string, int> num;
map<string, int> val;
string res = "123804765";
int changelo[9][4] = { {-1,-1,3,1},{-1,0,4,2},{-1,1,5,-1},
                    {0,-1,6,4},{1,3,7,5},{2,4,8,-1},
                    {3,-1,-1,7},{4,6,-1,8},{5,7,-1,-1}
};
string s;
void swapch(string& a, int p1, int p2)
{
    char b = a[p1];
    a[p1] = a[p2];
    a[p2] = b;
}

struct node
{
    string numn;
    int pos;
};
bool flag;
void dbfs(string n, int p)
{
    queue<node> q;
    q.push({ n, p});
    q.push({ res, 4});
    num[n] = 1; num[res] = 2;
    while (!q.empty())
    {
        node no = q.front();
        q.pop();
        string cur = no.numn;
        int p2 = no.pos;
        string now = cur;
        for (int i = 0; i < 4; i++)
        {
            if (changelo[p2][i] != -1)
            {
                swapch(cur, p2, changelo[p2][i]);
                if (num[cur] + num[now] == 3)
                {
                    printf("%d", val[now] + 1 + val[cur]);
                    flag = true;
                    return;
                }
                if (!num[cur])
                {
                    num[cur] = num[now];
                    q.push({ cur, changelo[p2][i]});
                    val[cur] = val[now] + 1;
                }
                swapch(cur, p2, changelo[p2][i]);
            }
        }
    }
}

int main()
{
    int sp;
    cin >> s;
    for (int i = 0; i < 9; i++)
        if (s[i] == '0')
        {
            sp = i;
            break;
        }
    if (s == res)
    {
        printf("0"); return 0;
    }
    dbfs(s, sp);
    if (!flag) printf("unsolvable");
    return 0;
}

4.A* + map

#include<stdio.h>
#include<queue>
#include<iostream>
#include<algorithm>
#include<map>
#include<cmath>
using namespace std;
const int N = 4e5 + 8;
map<string, int> num;
string des = "123804765";
int dpos[10] = { 4,0,1,2,5,8,7,6,3,0 };
int changelo[9][4] = { {-1,-1,3,1},{-1,0,4,2},{-1,1,5,-1},
                    {0,-1,6,4},{1,3,7,5},{2,4,8,-1},
                    {3,-1,-1,7},{4,6,-1,8},{5,7,-1,-1}
};
string s;
void swapch(string& a, int p1, int p2)
{
    char b = a[p1];
    a[p1] = a[p2];
    a[p2] = b;
}

struct node
{
    string numn;
    int pos;
    int step;
    int cost;
    bool operator < (const node& other) const
    {
        return cost > other.cost;
    }
    node(string n, int p, int s)
    {
        numn = n, pos = p, step = s;
        setCost();
    }

    void setCost()
    {
        int c = 0;
        for (int i = 0; i < 9; i++)
            c += abs(i % 3 - dpos[numn[i]] % 3) + abs(i / 3 - dpos[numn[i]] / 3);
        cost = step + c;
    }
};
bool flag;
void bfs(string n, int p)
{
    priority_queue<node> q;
    q.push({ n, p, 0 });
    num[n] = 1;
    while (!q.empty())
    {
        node no = q.top();
        q.pop();
        string cur = no.numn;
        int p2 = no.pos;
        for (int i = 0; i < 4; i++)
        {
            if (changelo[p2][i] != -1)
            {
                swapch(cur, p2, changelo[p2][i]);
                if (cur == des)
                {
                    printf("%d", no.step + 1);
                    flag = true;
                    return;
                }
                if (!num[cur])
                {
                    num[cur] = 1;
                    q.push({ cur, changelo[p2][i], no.step + 1 });
                }
                swapch(cur, p2, changelo[p2][i]);
            }
        }
    }
}

int main()
{
    int sp;
    cin >> s;
    for (int i = 0; i < 9; i++)
        if (s[i] == '0')
        {
            sp = i;
            break;
        }
    if (s == des)
    {
        printf("0"); return 0;
    }
    bfs(s, sp);
    if (!flag) printf("unsolvable");
    return 0;
}

5.IDA* + map

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<map>
#include<cmath>
using namespace std;
const int N = 4e5 + 8;
map<string, int> num;
string des = "123804765";
int changelo[9][4] = { {-1,-1,3,1},{-1,0,4,2},{-1,1,5,-1},
                    {0,-1,6,4},{1,3,7,5},{2,4,8,-1},
                    {3,-1,-1,7},{4,6,-1,8},{5,7,-1,-1}
};
string s;
bool flag;
void swapch(string& a, int p1, int p2)
{
    char b = a[p1];
    a[p1] = a[p2];
    a[p2] = b;
}
bool test(int dep, string n, int ddep)
{
    int cnt = 0;
    for (int i = 0; i < 9; i++)
        if (n[i] != des[i])
        {
            cnt++;
            if (cnt + dep > ddep)
                return false;
        }
    return true;
}
void  dfs(int dep, string n, int p, int ddep)
{
    if (!test(dep, n, ddep)) return;
    if (n == des)
    {
        printf("%d", dep);
        flag = true;
        return;
    }
    num[n] = 1; string cur = n;
    for (int i = 0; i < 4; i++)
    {
        if (changelo[p][i] != -1)
        {
            swapch(cur, p, changelo[p][i]);
            if (!num[cur])
            {
                num[cur] = 1;
                if(test(dep + 1, cur, ddep) && !flag) dfs(dep + 1, cur, changelo[p][i], ddep);
                num[cur] = 0;
            }
            swapch(cur, p, changelo[p][i]);
        }
    }
}

int main()
{
    int sp;
    cin >> s;
    for (int i = 0; i < 9; i++)
        if (s[i] == '0')
        {
            sp = i;
            break;
        }
    if (s == des)
    {
        printf("0"); return 0;
    }
    int k = 0;
    while (++k)
    {
        dfs(0, s, sp, k);
        if (flag) break;
    }
    return 0;
}

这么多年、
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
洛谷—P1379 八数码难题
NCU_tanghulu的博客
10-09 571
题目链接:P1379 八数码难题 题目大意： 要求最少步骤的移动方法，实现从初始布局到目标布局的转变。 解题思路: 这道题目要用到搜索中比较难的搜索方法—迭代加深的A*算法。所谓迭代加深就是每次限制搜索深度， 这样可以在整个搜索树深度很大而答案深度又很小的情况下大大提高效率。使maxdep从1开始不断加深枚举， 作为最大步数进行迭代加深搜索判断，而对于不用移动的情况可以一开始直接特判。在这里我们的A*估价函数设置为当前状态还有多少个位置与目标状态不对应。这只是我们预估现在的状态到目标状态的距离，我们预想的距
洛谷 1379 八数码难题
weixin_30319097的博客
06-28 116
洛谷 1379 八数码难题 八数码难题，一道经典的BFS题目（反正我也不会什么康托展开...）写完后，发现众多题解中并没有几篇双向BFS，于是就来发一波题解（尽管单向的BFS也能AC，但双向BFS明显要高效许多）。 思路如下： 首先我们可以将这个3x3的矩阵转化为一个九位数字，存入队列时也会方便很多，按方向尝试0周围的数字，判重记答案时可以使用map。然后就这样进行单向的BFS，acce...
洛谷P1379【八数码问题】【九宫重排】算法优化
passerbyYSQ
10-27 1369
题目描述 洛谷P1379 八数码难题（本博客的代码和描述都是针对洛谷这题） 问题 1426: [蓝桥杯][历届试题]九宫重排（与洛谷那题 [基本] 一样，输入有所不同） 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123...
搜索例题——八数码难题 luoguP1379
KKKevinW的博客
10-01 453
八数码难题 题目描述 解法一：bfs双向搜索 同时把开始和结束状态放入队列搜索，用map去重和记录步数答案 #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<queue> #include<cmath> #in...
洛谷 P1379 八数码难题 （最小步数模型）
qq_44791484的博客
03-10 162
题面 题解 BFS经典八数码问题 ：抽象成图，每一个状态都是都与上一个点相连，且距离为1，最终状态就是终点，转化成了从开始点到最终点的距离最小，因为每个点之间的距离都是1，所以直接用BFS来做即可 代码 #include<iostream> #include<cstdio> #include<string> #include<cstring> #include<algorithm> #include<unordered_map>
洛谷 P1164 小A点菜讲解PPT
03-12
在本题目中，我们可以将每个物品的价值看作是其体积，然后用01背包问题的计数版来解决问题。该方法的基本思想是使用动态规划来记录每个物品的选择情况，然后计算出符合条件的方法数。 知识点二：记忆化搜索 记忆化...
洛谷P1422解答（C++）
08-12
洛谷P1422解答（C++）请勿在未经授权的情况下上传任何涉及著作权侵权的资源，除非该资源完全由您个人创作
洛谷P1563玩具谜题
08-26
洛谷P1563玩具谜题
洛谷 P5660 [CSP-J2019] 数字游戏 C++代码
最新发布
10-21
洛谷 P5660 [CSP-J2019] 数字游戏 C++代码 洛谷题目代码截图，如果要源代码的话私信我 有什么不懂的一定要问！！！不懂就问！！！ 我是一个小学生，没事喜欢写写代码，欢迎指出问题！
洛谷P1028.cpp
03-21
洛谷P1028.cpp
luoguP1379-八数码难题（双向bfs）
weixin_30757793的博客
07-17 105
题目链接：https://www.luogu.org/problemnew/show/P1379 题意：用字符串表示八数码，求根据给定八数码得到末状态“123804765”最少的步数。 思路：这题很方便用双向bfs来优化，用两个队列分别从起点、终点开始搜索，两个map来记录该状态的步数。要注意的是起始状态和末状态相等的情况，需要特判。 AC代码： #include<cs...
【洛谷P1379】八数码难题 状压bfs
K1385170的博客
11-06 101
对于这道题来说，每个时刻的状态是整个棋盘所有棋子的位置，即：任何一个棋子位置发生了移动，都会使得状态转移。 因此，需要采取将整个状态作为广搜的搜索对象，进行状态压缩。采用哈希得到每个状态的对应的数值，同时维护一个 map 判重即可，顺便记录走到当前状态所需的最短步数。 代码如下 #include <bits/stdc++.h> using namespace std; con...
洛谷p1379题八数码难题
weixin_59880333的博客
07-25 67
小时候在修正带上玩过的拼图游戏
【洛谷】P1379 八数码难题
数学、算法爱好者的博客
12-29 402
题目地址： https://www.luogu.com.cn/problem/P1379 题目描述： 在3×33×33×3的棋盘上，摆有八个棋子，每个棋子上标有111至888的某一数字。棋盘中留有一个空格，空格用000来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单，设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入格式： 输入初始状态，一行九个数字，空格用000表示 输出格式： 只有一行，该行只有
洛谷 P1379 八数码难题
Ender_Wiggin的博客
08-10 460
啊！！这一题算是BFS中的经典了，如果你不懂BFS的话，可以睡觉了~~~ 现在请大家跳转题面题目描述在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。输入
洛谷 P1379 八数码难题
THIS_IS_HPQ的博客
07-17 226
题目描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入输出格式 输入格式：   输入初始状态，一行九个数字，空格用0表示   输...
P1379 八数码难题（洛谷）
pingfanblog
01-28 523
题目描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为123804765），找到一种最少步骤的移动方法，实现从初始布局到目标布局的转变。 输入格式 输入初始状态，一行九个数字，空格用0表示 输出格式 只有一行，该行只有...
【洛谷P1379】八数码难题（广搜、A*）
weixin_30404405的博客
03-24 114
八数码难题 题目描述 一.广搜： 首先要考虑用什么存每一个状态 显然每个状态都用一个矩阵存是很麻烦的。 我们可以考虑将一个3*3的矩阵用一个字符串或long long 存。 每次扩展时再转化为矩阵。 另外一个问题是判重，对于已经搜过的状态，就不再扩展了。 10^9次方的bool数组会爆空间 可以考虑用hash 或者STL的map或set //map 洛谷 ...
P1379 八数码难题
ZJHY1300的博客
02-21 121
1 #include<iostream> 2 #include<bits/stdc++.h> 3 using namespace std; 4 #include<vector> 5 using std::vector; 6 bool t[1000000000]; 7 int a[4][4]; 8 int ans=10...
洛谷 P1833 樱花 多重背包 的问题解决思路
05-18
洛谷 P1833 樱花 多重背包 的问题可以使用动态规划来解决。 首先，我们可以定义一个二维的状态数组 dp[i][j]，表示前 i 种物品，恰好占用 j 的空间时，能够获得的最大价值。 那么，对于每种物品 i，我们可以枚举它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值