HDU 1401 双向状态搜索

最新推荐文章于 2024-08-02 21:48:33 发布
最新推荐文章于 2024-08-02 21:48:33 发布
阅读量834 收藏
点赞数
分类专栏： 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/math_coder/article/details/8784990
版权

第一次写双向状态搜索，输得这么惨，控制不了时间，有很多浪费的时间，不知道如何去控制，代码拍过三遍，最后一遍算是成功的，可是肯定超时，不知道如何优化它。。

只有等以后实力提高了再来搞定它。。

我得理解，每种状态有16种后继状态，可是当跳跃到下一步的时候，却写不出o（1）的判断，最后就成16*o(4) = 64；这样写不超时才叫怪事。。。搞了我三天了。。

贴上神牛的代码：

#pragma warning (disable:4786)
#include<stdio.h>
#include<queue>
#include<map>
using namespace std;
typedef struct p{
    int x,y;
}Point;
//共有四颗棋子,棋盘大小为64,采用位棋盘表示
typedef struct Map{
    unsigned __int64 value;
    Point p[4];
    int steps,which;
	void getvalue()
	{//棋盘对应键值
		value=0;
		for(short i=0;i<4;i++)
			value+=(unsigned __int64)1<<((p[i].x-1)*8+(p[i].y-1));
	}
}Map;
struct Cmp{
	bool operator () (const Map &a,const Map &b) const
	{
		return a.value<b.value;
	}
};
map<Map,int,Cmp>m;
queue<Map>q;
Map start,end;
int dir[][2]={{0,1},{0,-1},{1,0},{-1,0}};

bool Next(Map cur,Map &next,int ith,int d)
{//获取第ith个棋子d方向上的下一个棋面状态
    int i,j;
	
    next.p[ith].x=cur.p[ith].x+dir[d][0];
    next.p[ith].y=cur.p[ith].y+dir[d][1];
    
    if(next.p[ith].x<1||next.p[ith].x>8||next.p[ith].y<1||next.p[ith].y>8)
        return false;
    for(i=1;i<4;i++){
        if(next.p[ith].x==cur.p[(ith+i)%4].x&&next.p[ith].y==cur.p[(ith+i)%4].y){
            next.p[ith].x+=dir[d][0];
            next.p[ith].y+=dir[d][1];
            if(next.p[ith].x<1||next.p[ith].x>8||next.p[ith].y<1||next.p[ith].y>8)
                return false;
            for(j=1;j<4;j++){
                if(next.p[ith].x==cur.p[(ith+j)%4].x
                    &&next.p[ith].y==cur.p[(ith+j)%4].y)
                    return false;
            }
            return true;
        }
    }
    return true;
}
bool bfs()
{//双向搜索
    Map cur,next;
    int i,d,k,v;
    m.clear();
	while(!q.empty()) q.pop();
	start.steps=end.steps=0;
	start.which=1;end.which=2;
	start.getvalue();end.getvalue();
	m[start]=1;m[end]=2;
	q.push(start);q.push(end);
	
    while(!q.empty()){
        cur=q.front(); q.pop();
		v=m[cur];
		if(cur.steps>4)	break;
		if(v!=0&&v!=cur.which)	return true;
        for(i=0;i<4;i++){//每一颗棋子
            for(d=0;d<4;d++){//每一个方向
                if(Next(cur,next,i,d)){
                    for(k=1;k<4;k++)
                        next.p[(i+k)%4]=cur.p[(i+k)%4];
                    next.steps=cur.steps+1;
					next.which=cur.which;
                    next.getvalue();
					if(next.steps>4) continue;
					v=m[next];
                    if(v==next.which) continue;
					if(v&&v!=next.which) return true;
                    m[next]=next.which;
                    q.push(next);
                }
            }
        }
    }
    return false;
}
int main()
{
    int i;
	while(1){
		for(i=0;i<4;i++){
			if(scanf("%d%d",&start.p[i].x,&start.p[i].y)==EOF)
				return 0;
		}
		for(i=0;i<4;i++)
			scanf("%d%d",&end.p[i].x,&end.p[i].y);
		printf(bfs()?"YES/n":"NO/n");
	}
    return 0;
}

也附上我自己超时的代码： 

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;

struct node {
    int x[4],y[4];
};
queue<node>que;
int temp[8][8][8][8][8][8][8][8];
int s[8][8][8][8][8][8][8][8];
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};

void init(){
    while(!que.empty()) que.pop();
    memset(temp,0,sizeof(temp));
    memset(s,0,sizeof(s));
}

int judge(node te){
    if(s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]>=6){
        if(temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]>8){ 
            cout<<"NO"<<endl;
            return 1;
        }    
        else { cout<<"YES"<<endl; return 1; }
    }
    if(temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]>4) {
        cout<<"NO"<<endl; return 1;
    }
    return 0;
} 

int fan(node te){
    for(int i=0;i<4;i++){ 枚举每个棋子
        for(int j=0;j<4;j++){ 枚举四个方向 
            node p=te;
            p.x[i] += dir[j][0];
            p.y[i] += dir[j][1];
            if(p.x[i]<0 || p.y[i]>=8) continue;
            int flag=0;
            for(int r=0;r<4;r++){判断是否有棋子和它重合？？？？超时根源 
                if(p.x[i]==p.x[r] && p.y[i]==p.y[r] && i!=r){
                    p.x[i]+=dir[j][0];再向前移一个位置 
                    p.y[i]+=dir[j][1];
                    if(p.x[i]<0 || p.y[i]>=8){ flag=1; break; }
                    for(int k=0;k<4;k++) ///判断是否还有棋子和它重合  ？？？？超时根源
                        if(p.x[i]==p.x[k] && p.y[i]==p.y[k] && i!=k) flag=1;
                    if(flag) break; 
                    if(s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]///状态重合了 
                       ==s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]) {
                       flag=1; break;
                    }    
                    if(!s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]){///状态没有重合 
                       s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]= 标记传递 
                       s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]];   
                       temp[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]=步数叠加 
                       temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]+1;
                       int ss = judge(p);
                       if(ss) return 1; 
                       que.push(p);
                       flag=1; break;
                    }
                    if(s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]///状态不同 
                       !=s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]) {
                       s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]] *=
                       s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]];
                       temp[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]=步数叠加 
                       temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]+1;
                       int ss = judge(p); 
                       if(ss) return 1;
                       flag=1; break;
                    } 
                }
            }
            if(flag) continue; 
            if(s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]///状态重合了 
                ==s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]) {
                continue;
            }    
            if(!s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]){///状态没有重合 
                s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]= 标记传递 
                    s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]];   
                    temp[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]=步数叠加 
                    temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]+1;
                    int ss = judge(p);
                    if(ss) return 1; 
                    que.push(p);
                    continue;
            }
            if(s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]///状态不同 
                !=s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]) {
                    s[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]] *=
                    s[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]];
                    temp[p.x[0]][p.y[0]][p.x[1]][p.y[1]][p.x[2]][p.y[2]][p.x[3]][p.y[3]]=步数叠加 
                    temp[te.x[0]][te.y[0]][te.x[1]][te.y[1]][te.x[2]][te.y[2]][te.x[3]][te.y[3]]+1;
                    int ss = judge(p); 
                    if(ss) return 1;
                    continue;
            } 
        }
    }
    return 0;
}

void BFS(){
    while(!que.empty()){
        node te=que.front();
        que.pop();
        if(judge(te)) break;
        int flag = fan(te);
        if(flag) break;
    }
}

int main(){
    int x[4],y[4],a[4],b[4];
    while(cin>>x[0]>>y[0]>>x[1]>>y[1]>>x[2]>>y[2]>>x[3]>>y[3]){
        for(int i=0;i<4;i++)
            cin>>a[i]>>b[i];
        for(int i=0;i<4;i++)
            x[i]--,y[i]--,a[i]--,b[i]--;
        init();
        temp[x[0]][y[0]][x[1]][y[1]][x[2]][y[2]][x[3]][y[3]]=1;
        temp[a[0]][b[0]][a[1]][b[1]][a[2]][b[2]][a[3]][b[3]]=1;
        s[x[0]][y[0]][x[1]][y[1]][x[2]][y[2]][x[3]][y[3]]=2;/第一个元素 
        if(!s[a[0]][b[0]][a[1]][b[1]][a[2]][b[2]][a[3]][b[3]])处理标记 
            s[a[0]][b[0]][a[1]][b[1]][a[2]][b[2]][a[3]][b[3]]=3;
        else s[a[0]][b[0]][a[1]][b[1]][a[2]][b[2]][a[3]][b[3]]*=3;
        node te;
        for(int i=0;i<4;i++){
            te.x[i]=x[i];
            te.y[i]=y[i];
        }
        que.push(te);
        for(int i=0;i<4;i++){
            te.x[i]=a[i];
            te.y[i]=b[i];
        }
        que.push(te);
        BFS();
    }
}
/*

4 4 4 5 5 4 6 5
4 4 4 5 5 4 6 5

4 4 4 5 5 4 6 5
2 4 3 3 3 6 4 6

*/


皮卡丘来了
关注
专栏目录
hdu1401
zjsru_Beginner的博客
11-14 658
hud1401纸牌 题目描述： Solitaire 是一种在 8x8 棋盘上玩的游戏。棋盘的行和列分别从1到8编号，分别从上到下和从左到右。 棋盘上有四个相同的棋子。在一次移动中，允许： ①将棋子移到空的相邻区域（向上、向下、向左或向右） ② 跳过相邻棋子到空的区域（向上、向下、向左或向右） 如图： 所以有四种走法：向上走一步；向右走一步，跳过右边相邻的；向下走一格，跳过下面那个；想左直接走一格。不过每个棋子只能走四步最多，题目的要求是给定你一个目标位置，和最初位置，在每个棋子只能最多走四步，且
HDU1401 Solitaire 双向搜索
幸福在路上
01-05 2519
/* 很显然的BFS，没有悬念，只是实现起来有点麻烦 写完才发现，本题中，起点和终点都很明确，可以用双搜 不过我的单搜也没有超时 */ #include #include #include #include using namespace std; //状态 struct node { char ch[4];//用char类型是为了省空间 int ceil; }; //判断两个状态是
hdu 1401 双向搜索（bfs）
zxf654073270的专栏
01-21 831
双向搜索
HDU-1401
最新发布
m0_73596392的博客
08-02 211
使用双向广搜：降低时间复杂度 一个搜索4步即可 因为5 3 可以转换为4 4 不缺情况。使用sort排序：否则visited会有大量重复状态。今天两道题都没AC出来 不过还是学到很多东西的。四个点四个方向注意判断是否可以跳。使用八维数组记录坐标。
HDU 1401 Solitaire 双向BFS
java开发指南博客 【转载】
07-16 224
转载请注明出处，谢谢 http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 第一次写双向BFS。 双向BFS即是从起点和终点开始搜，如果出现交点，说明目标点可达。这点要求是八步之内到达，每步有16个状态，16^8的复杂度还是很高的，由于是确定了起点和终点的，十分适合双向BFS，即从起点和终点分别开始搜4步，如果出现交点则说明...
hdu 1401
weixin_34221775的博客
01-28 306
hdu 1401 从昨天晚上就在做这道题了，orz，被坑了这么久，原因一直是MLE。。。。 欲哭无泪啊，改来改去，还是不能减少内存，后来，我发现其实我太二了，八维数组，我居然用的是int ，orz，难怪MLE，改成char 就不超了。。。 哎呀，得长记性了。。。。话说，这是我做的第一道DBFS，其实和BFS本质上还是一样的，就是多了一个判断，不过效率确实高了。。。orz。。。 还是直接贴代码...
HDU1401 BFS
anuancong1219的博客
12-27 122
Solitaire Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4368Accepted Submission(s): 1324 Problem Description Solitaire is a game p...
HDU1401 - Solitaire - 双向bfs+哈希状态压缩
终有绿洲摇曳在沙漠
05-20 589
1.题目描述： Solitaire Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 4560    Accepted Submission(s): 1380 Problem Description Sol
HDU-1401-题解-搜索、双向bfs
CapriceH的博客
09-20 570
HDU 1401 题解 Solitaire 题目大意 每个棋子可以跳向上下左右四个方向的格子 如果格子上有棋子，可以跳过该棋子（最多跳一个） 并且保证不跳出边界 给出两个状态，每个状态包含四个棋子的坐标 问4步之内能否从第一个状态到达第二一个状态 Time: 1000 ms Memory: 32768 kB 解题思路及分析 对每个棋子四个方向进行bfs 由于过程是可逆的，故可以进行双向搜索 访问标记每个状态时，可以把状态的4个坐标转成一个8位数来标记 原来unordered_map自定义键值类.
hdu 1401 双向广搜+8进制压缩状态
跟acm say goodbye
08-30 1212
// hdu 1491.cpp : 定义控制台应用程序的入口点。 /* 题目询问能否能从一个状态到另外一个状态而少于8步移动。 每个状态为4个不同的点，即8个坐标。由于从初始状态到目标状态，和目标状态到初始状态的效果是一样，所以可以采用双向广搜。 每次选取节点比较少的队列进行扩展
搜索专题突破POJ1077 POJ1324 POJ2046 HDU2485 HDU1560 HDU1667 POJ3134 POJ1915 HDU1401 HDU1430 HDU2691
Luowaterbi的博客
08-18 373
POJ1077Eight 八数码问题，就是手机上那个智能拼图的小游戏感觉很小的时候在诺基亚上玩过。只有一个块可以上下左右移动，问能否拼好。 IDA*搜索。估值函数就是目前拼图的曼哈顿距离。这是最理想化的情况，就是只经过曼哈顿距离，所有拼图回到自己位置。因为每次只能改变一个拼图的位置。所以最少就是曼哈顿距离。 估值函数的选取，就是去想最最理想的情况需要多少步达到目标。一般最理想都是实现不了，需...
HDU 1401（Solitaire）
Intelligence1028的博客
03-30 189
#include <iostream> #include <map> #include <queue> using namespace std; struct point //棋子 { int x; int y; }; struct node //棋盘 { point p[4]; //四个棋子 int step; //移动步...
HDU 3095 哈希+双向搜索
sulisulisu的博客
07-22 341
Description Partychen invents a new game named “Eleven Puzzle” .Just like the classic game “Eight Puzzle”,but there some difference between them:The shape of the board is different and there are
HDU1401(Solitaire)
weixin_43808717的博客
06-05 1438
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
HDU 1401 Solitaire [双向BFS]
ACTerminate的博客
08-25 636
HDU 1401 Solitaire [双向BFS]
hdu1401（双广搜）
u013509299的专栏
01-30 1048
已知开始状态和目标状态，并且具有可逆性，采用双广搜； 用八维hash数组记录四个棋子的位置（要对四个棋子的坐标排序，迫使棋子一一对应）。 下面的代码是参考大神写的，自己刚学双搜。 #include #include #include #include #include #include #include #include #include #include #include #define
HDU 1401 Solitaire(棋盘状态BFS)
code
05-28 2046
HDU 1401 Solitaire(棋盘状态BFS) http://acm.hdu.edu.cn/showproblem.php?pid=1401 题意:对于一个8*8的棋牌,其中有4个棋子,每个棋子可以往上下左右各走一步,但是如果那一步不是空格而是另外一个棋子,那么就越过这个棋子再前进一步.现在给出了初始棋盘状态,和终结棋盘状态,问你在8步内( 分析:本题应该用双向BFS,单BFS容易超
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值