双向广搜 Solitaire——hdu1401

已于 2024-10-12 21:44:04 修改
阅读量1.2k 收藏 19
点赞数 39
文章标签： 算法 c++ 数据结构 广度优先 剪枝
于 2024-10-12 21:41:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80093604/article/details/142863948
版权

目录

前言

   字符数字的转换

   bfs or double dfs

  棋局的编号

Solitaire

   问题描述

   输入

   输出

问题分析

   判重

   棋子走动逻辑

单向搜索代码

   双向搜索退出条件

   双向广搜代码

前言

        交代一下我写这题的感受，被自己气笑了，本来以为是我字符串没弄好，就总盯着字符串，结果发现连最基本的变量赋值逻辑都弄错了，服了

   字符数字的转换

                                   字符-'0' 字符变数字，数字+'0' 数字变字符

   bfs or double dfs

        这题为什么不能用bfs，其实用bfs还是用double bfs很好判断，就看一下每次入队的状态数量为多少即可

        本题总共有四个棋子，每个棋子都有上下左右四个方向，就意味着单个节点入队最多为4*4=16，种方案，不难发现，这个还是以指数形增长的，如果连续八步那么就会拓展出，16^{8}>1500万种状态，非常恐怖。

        所以要用double bfs减少状态数大约2*16^{4}=131072种棋局，具体关于double bfs分析在这里双向广搜

  棋局的编号

        本题为了方便判重，我对该棋盘的所有格子都进行了编号

12345678
910111213141516
1718192021222324
2526272829303132
3334353637383940
4142434445464748
4950515253545556
5758596061626464

例如四个棋子如果为（1，1），（1，2），（1，3），（1，4）那么我就用string s="1234"代表它

Solitaire

   问题描述

        在一个8*8的棋盘中放入四个棋子，要求八步之内四颗棋子到达指定位置，现给出四颗棋子的初始位置，和最终位置，判断是否可以到达终点

   输入

        总共两行，第一行用八个整数代表四颗棋子的初始位置，第二行用八个整数代表四颗棋子的终止位置

   输出

        如果可以到达终点，那么输出"YES"，否则输出"NO"

问题分析

        前面已经说过，本题需要用到双向广搜，我们不妨先实现单向搜索

   判重

        其实这才是我想发这题的题解的原因，本题最重要的就是判重的操作，首先明确一点：绝对不能用int vis[][][][][][][][]判重，这个八位数组占用空间太大，算一下等于32^{8}=104.8576GB，会爆掉

所以次优先的方法就是改用char数组那么就可以减到8^{8}=16MB，勉强可以接受。但如果把这个八位数砍成一个字符串，用map压缩无效空间，那么这个内存占用将会减少到几kb

   棋子走动逻辑

        题目说棋子可以上下左右移动，如果碰到该方向有棋子，那么就往该方向再移动一格（这个操作最多一次），根据代码逻辑就可以编写代码

nx += dir[k][0];
ny += dir[k][1];
if (!check(nx, ny, i,now.s)) {
    nx +=dir[k][0];
    ny +=dir[k][1];
    if (!check(nx, ny, i,now.s)) { //如果还有棋子，continue
        continue;
    }
}

        check函数：

//这个字符串索引逻辑可以参考上图
bool check(int x,int y,int i,string s) {
    for(int k=0;k<4;k++){
        if (k != i) {
            if (x == (s[2*k]-'0') && y == (s[2*k + 1]-'0') ) {
                return false;
            }
        }
    }
    return true;
}

        translate函数

                这个是将棋子位置转化为一个独一无二的字符串（方便判重）的代码

string Translate(string s) {

    vector<int> pos(4);
    for (int i = 0; i < 4; i++) {
        // 将每两位字符转换为一个十进制数
        // 注意：这里假设输入字符串只包含'0'和'1'，且长度至少为8
        pos[i] = ((s[2 * i] - '0')-1) * 8 + (s[2 * i + 1] - '0');
    }

    sort(pos.begin(), pos.end());

    string a;
    for (int i = 0; i < 4; i++) {
        // 将排序后的十进制数转换回字符串，并拼接到结果字符串中
        a += to_string(pos[i]);
    }

    return a;
}

   单向搜索代码

#include<string>
#include<iostream>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
int dir[4][2] = { {0,-1},{0,1},{1,0},{-1,0} };
struct node {
    string s;
    int step;
    node() {}
    node(string ss,int ste):s(ss),step(ste){}
};
map<string, bool>vis;
queue<node>que;
int pos[4];
string m;
string st, ed;
string ed_s;
string st_s;
node now, nxt;
bool flag=false;

string Translate(string s) {

    vector<int> pos(4);
    for (int i = 0; i < 4; i++) {
        // 将每两位字符转换为一个十进制数
        // 注意：这里假设输入字符串只包含'0'和'1'，且长度至少为8
        pos[i] = ((s[2 * i] - '0')-1) * 8 + (s[2 * i + 1] - '0');
    }

    sort(pos.begin(), pos.end());

    string a;
    for (int i = 0; i < 4; i++) {
        // 将排序后的十进制数转换回字符串，并拼接到结果字符串中
        a += to_string(pos[i]);
    }

    return a;
}

bool check(int x,int y,int i,string s) {
    for(int k=0;k<4;k++){
        if (k != i) {
            if (x == (s[2*k]-'0') && y == (s[2*k + 1]-'0') ) {
                return false;
            }
        }
    }
    return true;
}

void bfs() {
    que.push(node(st, 0));
    m=Translate(st);
    vis[m] = true;
    while (!que.empty()) {
        now = que.front();
        que.pop();
        for(int i=0;i<4;i++){
            //一开始把这行放这了，我是真的服了
            //int nx = int(now.s[2*i] - '0'), ny = int(now.s[2*i + 1] - '0');
            for (int k = 0; k < 4; k++) {
                int nx = int(now.s[2*i] - '0'), ny = int(now.s[2*i + 1] - '0');
                nx += dir[k][0];
                ny += dir[k][1];
                if (!check(nx, ny, i,now.s)) {
                    nx +=dir[k][0];
                    ny +=dir[k][1];
                    if (!check(nx, ny, i,now.s)) {
                        continue;
                    }
                }
                if (nx < 1 || nx > 8 || ny < 1 || ny > 8) continue;
                nxt.s = now.s;
                nxt.s[2*i] = '0'+nx;
                nxt.s[2*i + 1] = '0'+ny;
                nxt.step = now.step + 1;        
                if (nxt.step > 8) continue;
                m = Translate(nxt.s);
                if (nxt.step <= 8 && m == ed_s) {
                    flag = true;
                    return;
                }
                if (!vis[m]) {
                    vis[m] = true;
                    que.push(nxt);
                }
            }
        }
    }
}

//注：字符-'0' 字符变数字，数字+'0' 数字变字符
int main() {
    int i, j;
    for (int k = 1; k <= 8; k++) {
        cin >> i;
        st += '0'+i;
    }
    for (int k = 1; k <= 8; k++) {
        cin >> j;
        ed += '0'+j;
    }
    st_s = Translate(st);
    ed_s = Translate(ed);
    if (st_s == ed_s) {
        cout << "YES" << endl;
        return 0;
    }
    bfs();
    if (flag) {
        cout << "YES" << endl;
    }
    else {
        cout << "NO" << endl;
    }
    return 0;
}

        接下来我们就把它改为双向搜索代码

   双向搜索退出条件

        双向搜索是起点和终点同时同速度出发搜索，那么他们相遇的时候所走的路程一定相同，要求总步数不大于8，那么每个人走的步数也要不大于4，此外我们定义了一个visa判重1代表起点搜过，2代表终点搜过，如果每一个队列搜到了另一个队列的标记，那么也代表他们相遇了

        顺嘴提一句，那个if (nxt.step > 8) continue;的剪枝8也要改成4

   双向广搜代码

#include<string>
#include<iostream>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
int dir[4][2] = { {0,-1},{0,1},{1,0},{-1,0} };
struct node {
    string s;
    int step;
    node() {}
    node(string ss,int ste):s(ss),step(ste){}
};
map<string, int>vis;
queue<node>qa;
queue<node>qb;
int pos[4];
string m;
string st, ed;
string ed_s;
string st_s;
node now, nxt;
bool flag=false;

string Translate(string s) {
    vector<int> pos(4);
    for (int i = 0; i < 4; i++) {
        pos[i] = ((s[2 * i] - '0')-1) * 8 + (s[2 * i + 1] - '0');
    }
    sort(pos.begin(), pos.end());
    string a;
    for (int i = 0; i < 4; i++) {
        // 将排序后的十进制数转换回字符串，并拼接到结果字符串中
        a += to_string(pos[i]);
    }
    return a;
}

bool check(int x,int y,int i,string s) {
    for(int k=0;k<4;k++){
        if (k != i) {
            if (x == (s[2*k]-'0') && y == (s[2*k + 1]-'0') ) {
                return false;
            }
        }
    }
    return true;
}

void dul_bfs() {
    qa.push(node(st, 0));
    qb.push(node(ed, 0));
    vis[st_s] = 1;
    vis[ed_s] = 2;
    while (!qa.empty() && !qb.empty()) {
        if (qa.size() < qb.size()) {
            now = qa.front();
            qa.pop();
            for(int i=0;i<4;i++){
                for (int k = 0; k < 4; k++) {
                    int nx = now.s[2*i] - '0', ny = now.s[2*i + 1] - '0';
                    nx += dir[k][0];
                    ny += dir[k][1];
                    if (!check(nx, ny, i,now.s)) {
                        nx +=dir[k][0];
                        ny +=dir[k][1];
                        if (!check(nx, ny, i,now.s)) {
                            continue;
                        }
                    }
                    if (nx < 1 || nx > 8 || ny < 1 || ny > 8) continue;
                    nxt.s = now.s;
                    nxt.s[2*i] = '0'+nx;
                    nxt.s[2*i + 1] = '0'+ny;
                    nxt.step = now.step + 1;        
                    if (nxt.step > 4) continue;
                    m = Translate(nxt.s);
                    if (nxt.step <= 4 && vis[m]==2) {
                        flag = true;
                        return;
                    }
                    if (!vis[m]) {
                        vis[m] = 1;
                        qa.push(nxt);
                    }
                }
            }
        }
        else {
            now = qb.front();
            qb.pop();
            for (int i = 0; i < 4; i++) {
                for (int k = 0; k < 4; k++) {
                    int nx = now.s[2 * i] - '0', ny = now.s[2 * i + 1] - '0';
                    nx += dir[k][0];
                    ny += dir[k][1];
                    if (!check(nx, ny, i, now.s)) {
                        nx += dir[k][0];
                        ny += dir[k][1];
                        if (!check(nx, ny, i, now.s)) {
                            continue;
                        }
                    }
                    if (nx < 1 || nx > 8 || ny < 1 || ny > 8) continue;
                    nxt.s = now.s;
                    nxt.s[2 * i] = '0' + nx;
                    nxt.s[2 * i + 1] = '0' + ny;
                    nxt.step = now.step + 1;
                    if (nxt.step > 4) continue;
                    m = Translate(nxt.s);
                    if (nxt.step <= 4 && vis[m]==1) {
                        flag = true;
                        return;
                    }
                    if (!vis[m]) {
                        vis[m] = 2;
                        qb.push(nxt);
                    }
                }
            }
        }
        
    }
}

//注：字符-'0' 字符变数字，数字+'0' 数字变字符
int main() {
    int i, j;
    for (int k = 1; k <= 8; k++) {
        cin >> i;
        st += '0'+i;
    }
    for (int k = 1; k <= 8; k++) {
        cin >> j;
        ed += '0'+j;
    }
    st_s = Translate(st);
    ed_s = Translate(ed);
    if (st_s == ed_s) {
        cout << "YES" << endl;
        return 0;
    }
    dul_bfs();
    if (flag) {
        cout << "YES" << endl;
    }
    else {
        cout << "NO" << endl;
    }
    return 0;
}

小骤
关注
夜深人静写算法（一）- 搜索入门
英雄哪里出来
12-20 13万+
简要介绍计算机两大图论搜索算法：深度优先搜索和广度优先搜索
HDU题目分类大全【大集合】
欢迎来到扣子不会飞的博客！
03-18 3835
基础题： 1000、1001、1004、1005、1008、1012、1013、1014、1017、1019、1021、1028、1029、 1032、1037、1040、1048、1056、1058、1061、1070、1076、1089、1090、1091、1092、1093、 1094、1095、1096、1097、1098、1106、1108、1157、1163、1164、1170、...
hdu1401
zjsru_Beginner的博客
11-14 736
hud1401纸牌 题目描述： Solitaire 是一种在 8x8 棋盘上玩的游戏。棋盘的行和列分别从1到8编号，分别从上到下和从左到右。 棋盘上有四个相同的棋子。在一次移动中，允许： ①将棋子移到空的相邻区域（向上、向下、向左或向右） ② 跳过相邻棋子到空的区域（向上、向下、向左或向右） 如图： 所以有四种走法：向上走一步；向右走一步，跳过右边相邻的；向下走一格，跳过下面那个；想左直接走一格。不过每个棋子只能走四步最多，题目的要求是给定你一个目标位置，和最初位置，在每个棋子只能最多走四步，且
HDU 1401 Solitaire 双向BFS
java开发指南博客 【转载】
07-16 264
转载请注明出处，谢谢 http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents by---cxlove 第一次写双向BFS。 双向BFS即是从起点和终点开始搜，如果出现交点，说明目标点可达。这点要求是八步之内到达，每步有16个状态，16^8的复杂度还是很高的，由于是确定了起点和终点的，十分适合双向BFS，即从起点和终点分别开始搜4步，如果出现交点则说明...
H1555
jiangjiashi的博客
04-25 740
这个分好段就行， #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; int main() { int k; int n;
hdu 1401
weixin_34221775的博客
01-28 340
hdu 1401 从昨天晚上就在做这道题了，orz，被坑了这么久，原因一直是MLE。。。。 欲哭无泪啊，改来改去，还是不能减少内存，后来，我发现其实我太二了，八维数组，我居然用的是int ，orz，难怪MLE，改成char 就不超了。。。 哎呀，得长记性了。。。。话说，这是我做的第一道DBFS，其实和BFS本质上还是一样的，就是多了一个判断，不过效率确实高了。。。orz。。。 还是直接贴代码...
HDU1401(Solitaire)
weixin_43808717的博客
06-05 1556
Solitaire Problem Description Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboard are numbered from 1 to 8, from the top to the bottom and from left to right respectively. There are four identical pieces on the board. In
搜索专题突破POJ1077 POJ1324 POJ2046 HDU2485 HDU1560 HDU1667 POJ3134 POJ1915 HDU1401 HDU1430 HDU2691
Luowaterbi的博客
08-18 449
POJ1077Eight 八数码问题，就是手机上那个智能拼图的小游戏感觉很小的时候在诺基亚上玩过。只有一个块可以上下左右移动，问能否拼好。 IDA*搜索。估值函数就是目前拼图的曼哈顿距离。这是最理想化的情况，就是只经过曼哈顿距离，所有拼图回到自己位置。因为每次只能改变一个拼图的位置。所以最少就是曼哈顿距离。 估值函数的选取，就是去想最最理想的情况需要多少步达到目标。一般最理想都是实现不了，需...
hdoj杭电问题分类
04-02 5563
杭电上的题虽然多，但是一直苦于找不到问题分类，网页都是英文的，所以平时做题也没怎么看，今天仔细一看，问题分类竟然就在主页。。。。做了那么久的题居然没发现，表示已经狗带。。不要笑，不知道有没有像我一样傻的孩子，可以参考一下。。。 点进来就是。。。
HDU 1401 Solitaire
weixin_33991727的博客
03-03 150
题意： 在一个8×8的棋盘中，给定你4个棋子A，再给你4个棋子B，问你在8步之内能不能够从A位置移动到B位置； 规则：棋子能能上下左右移动，同时能跳过相邻的棋子到达相邻棋子的空地方； 这个题要用双向搜索；同时我用一个8维的数组hash来构造一个图；当hash标记为1时表示A到过该点，标记为2时表示B到过该点； 这里要注意就是A,B同时搜索时他们分别最多只能走4步，如果多于4步，那么他...
HDU 1401 Solitaire （双向搜索）
Baoli1008的专栏
08-17 650
每一步有4*4=16个决策，单向搜索的话有16^8种状态，双向搜索只有32^4种状态，缩小了解空间。 双向搜索用来解决起点和终点确定的搜索问题。方法就是从起点和终点轮流走，分别有各自的队列和标记数组。起点每到一个新的状态，就到终点的标记数组中查询，判断是否有交点。终点也是做一样的操作。 注意：Hash时如果像我一样8进制压缩，每个数必须是0~7的，也就是输入的坐标要减1
HDU1401-Solitaire
wang_128的博客
07-12 565
Solitaire                                                                       Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)                                
HDU - 1401 Solitaire
LP_Cong
07-22 428
解题思路：简单的bfs，难点在于状态判断，这里使用了八维数组，刚好不会超空间。即把4个棋子的坐标作为状态，在这之前要先对棋子排序，因为1 1 2 2 3 3 4 4和4 4 3 3 2 2 1 1 其实是一样的状态。之后就是简单的bfs了。另外这题可以用双向bfs，即两边同时bfs，如果在4步内，状态能达到一模一样，那证明可以在8步内达到，这样可以大大优化时间。这里用的是单向bfs，直接搜到8步。
hdu 1401 Solitaire
GitHub：https://github.com/myp020301
11-29 152
Solitaire *Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7782 Accepted Submission(s): 2276 * Problem Description Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboar
HDOJ 1401 Solitaire
码代码的猿猿
02-17 1627
山寨版的双向BFS。。。 正着搜的结果存下来，反着收的结果在正着搜的结果里找。。。 Solitaire Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 2944    Accepted Submission(s): 915
hdu1401“Solitaire“
rixc_ruanzhanju的博客
02-04 399
hdu1401"Solitaire"(双向广搜） 题意 有一个8X8的棋盘，上面有4个棋子，棋子可以上下左右移动。给定一个初始状态和一个目标状态，问能否在8步之内到达。 注意点（我的错误） 移动一步，棋子落到另一个棋子上是，才可以移动两步。（容易理解为即可以移动一步，也可以移动两步。） 棋子不区分顺序，所以需要按一定规则排序后才可以确定一个状态。 思路 使用8维数组vis*标记，进行查重。 有八个方向向量vex*。 伪双向广搜：并不是真的从两个初始一起搜索，分别从目标状态、初始状态使用bfs搜索4步，
hdu1401Solitaire(dbfs)
ophunter的专栏
07-16 1087
Solitaire Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 2539    Accepted Submission(s): 826 Problem Description Solitaire is a ga
HDU1401:Solitaire(BFS)
ACM！荣耀之路！
04-02 4436
Problem Description Solitaire is a game played on a chessboard 8x8. The rows and columns of the chessboard are numbered from 1 to 8, from the top to the bottom and from left to right respectively.
经典WP7系统纸牌游戏 - Solitaire
Windows Phone 7（WP7）纸牌Solitaire（又称纸牌接龙或纸牌游戏）是微软公司为WP7平台开发的一款内置休闲游戏，属于Windows系统上的经典游戏之一。WP7作为微软推出的智能手机操作系统，承载着微软在移动市场的期望，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值