hdu 1195 Open the Lock（BFS && DBFS）

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

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1195


推荐一个个人感觉讲解得比较好的DBFS的博客

http://blog.sina.com.cn/s/blog_8627bf080100ticx.html


        所谓双向广搜，就是初始结点向目标结点和目标结点向初始结点同时扩展，直至在两个扩展方向上出现同一个结点，搜索结束。它适用的问题是，扩展结点较多，而目标结点又处在深沉，如果采用单纯的广搜解题，搜索量巨大，搜索速度慢是可想而知的，同时往往也会出现内存空间不够用的情况，这时双向广搜的作用就体现出来了。双向广搜对单纯的广搜进行了改良或改造，加入了一定的“智能因数”，使搜索能尽快接近目标结点，减少了在空间和时间上的复杂度。


思路：

这道题不是很难，主要是用来练习一下搜索。


用基础的BFS就可以过，时间46ms，不明白为什么discuss里会有超时的现象。

每次搜索遍历11个方向，每个数位加减一或者交换相邻数位。


用DBFS，时间0ms，用两个队列，从起始两个方向开始搜索，开标记数组，若第一个队列访问过标记为1，第二个队列访问过标记为2。

若都放访问过，说明在两个扩展方向上出现同一个节点，搜索结束。


BFS：

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <set>
//#define ONLINE_JUDGE
#define eps 1e-6
#define INF 0x7fffffff                                          //INT_MAX
#define inf 0x3f3f3f3f                                          //int??????????????????
#define FOR(i,a) for((i)=0;i<(a);(i)++)                          //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define MEM3(a) memset(a,0x3f,sizeof(a))
#define MEMS(a) memset(a,'\0',sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> inline T Min(T a, T b) { return a < b ? a : b; }
template<class T> inline T Max(T a, T b) { return a > b ? a : b; }
using namespace std;
template<class T>
T Mint(T a, T b, T c) {
    if (a>b) {
        if (c>b)
            return b;
        return c;
    }
    if (c>a)
        return a;
    return c;
}
template<class T>
T Maxt(T a, T b, T c) {
    if (a>b) {
        if (c>a)
            return c;
        return a;
    }
    else if (c > b)
        return c;
    return b;
}

const int maxn=10005;
int T,n,m,k;
int init[4],ans[4],dis[2]={-1,1};
int f[9]={9,1,2,3,4,5,6,7,8};//数表
bool vis[maxn];//标记数组

struct node{
    int a[4];
    int step;
};

int fun(node p){//计算该数大小
    int ans=0;
    for1(i,0,4)
        ans=ans*10+p.a[i];
    return ans;
}

int bfs(){
    MEM1(vis);
    queue<node>q;
    node s,e,t;
    for1(i,0,4)
        s.a[i]=init[i];
    s.step=0;
    int sum=fun(s);
    vis[sum]=1;
    q.push(s);
    while(!q.empty()){
        s=q.front();
        q.pop();
        if(fun(s)==k) return s.step;
        for1(i,0,4){// // 每位数 加1或减1（若相应位置与答案不同）
            if(s.a[i]!=ans[i]){
                for1(j,0,2){
                    t=s;
                    t.a[i]=f[(s.a[i]+dis[j])%9];
                    sum=fun(t);
                    if(vis[sum])  continue;
                    t.step=s.step+1;
                    vis[sum]=1;
                    q.push(t);
                }
            }
        }
        for1(i,0,3){//交换相邻位
            t=s;
            swap(t.a[i],t.a[i+1]);
            sum=fun(t);
            if(vis[sum])  continue;
            t.step=t.step+1;
            vis[sum]=1;
            q.push(t);
        }
    }
    return -1;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("test.in","r",stdin);
    freopen("test.out","w",stdout);
#endif
    sf(T);
    while(T--){
        k=0;
        char c;
        for1(i,0,4){
            cin>>c;
            init[i]=c-'0';
        }
        for1(i,0,4){
            cin>>c;
            ans[i]=c-'0';
            k=k*10+ans[i];
        }
        int res=bfs();
        pf(res);
    }
    return 0;
}


DBFS：

#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <set>
//#define ONLINE_JUDGE
#define eps 1e-6
#define INF 0x7fffffff                                          //INT_MAX
#define inf 0x3f3f3f3f                                          //int??????????????????
#define FOR(i,a) for((i)=0;i<(a);(i)++)                          //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define MEM3(a) memset(a,0x3f,sizeof(a))
#define MEMS(a) memset(a,'\0',sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> inline T Min(T a, T b) { return a < b ? a : b; }
template<class T> inline T Max(T a, T b) { return a > b ? a : b; }
using namespace std;
template<class T>
T Mint(T a, T b, T c) {
    if (a>b) {
        if (c>b)
            return b;
        return c;
    }
    if (c>a)
        return a;
    return c;
}
template<class T>
T Maxt(T a, T b, T c) {
    if (a>b) {
        if (c>a)
            return c;
        return a;
    }
    else if (c > b)
        return c;
    return b;
}

const int maxn=10010;
int T,n,m,k;
int init[4],ans[4],dis[2]={-1,1};
int f[9]={9,1,2,3,4,5,6,7,8};//数表
int d[maxn],vis[maxn];//标记数组
bool found;

struct node{
    int a[4];
};

node s,e,t;
int sums,sume,sumt;

int fun(node p){//计算该数大小
    int ans=0;
    for1(i,0,4)
        ans=ans*10+p.a[i];
    return ans;
}

int bfs(queue<node> &q,bool flag){
    s=q.front();
    sums=fun(s);
    q.pop();
    if(flag){
        for1(i,0,4){// // 每位数 加1或减1（若相应位置与答案不同）
            if(s.a[i]!=ans[i]){
                for1(j,0,2){
                    t=s;
                    t.a[i]=f[(s.a[i]+dis[j])%9];
                    sumt=fun(t);
                    if(vis[sumt]!=1){
                        if(vis[sumt]==2){
                            found=true;
                            return d[sumt]+d[sums]+1;
                        }
                        d[sumt]=d[sums]+1;
                        vis[sumt]=1;
                        q.push(t);
                    }
                }
            }
        }
        for1(i,0,3){//交换相邻位
            t=s;
            swap(t.a[i],t.a[i+1]);
            sumt=fun(t);
            if(vis[sumt]!=1){
                if(vis[sumt]==2){
                    found=true;
                    return d[sumt]+d[sums]+1;
                }
                d[sumt]=d[sums]+1;
                vis[sumt]=1;
                q.push(t);
            }
        }
    }
    else {
        for1(i,0,4){// // 每位数 加1或减1（若相应位置与答案不同）
            if(s.a[i]!=init[i]){
                for1(j,0,2){
                    t=s;
                    t.a[i]=f[(s.a[i]+dis[j])%9];
                    sumt=fun(t);
                    if(vis[sumt]!=2){
                        if(vis[sumt]==1){
                            found=true;
                            return d[sumt]+d[sums]+1;
                        }
                        d[sumt]=d[sums]+1;
                        vis[sumt]=2;
                        q.push(t);
                    }
                }
            }
        }
        for1(i,0,3){//交换相邻位
            t=s;
            swap(t.a[i],t.a[i+1]);
            sumt=fun(t);
            if(vis[sumt]!=2){
                if(vis[sumt]==1){
                    found=true;
                    return d[sumt]+d[sums]+1;
                }
                d[sumt]=d[sums]+1;
                vis[sumt]=2;
                q.push(t);
            }
        }
    }
    return -1;
}

int DBFS(){
    found=false;
    MEM1(vis);
    MEM1(d);
    int res;
    queue<node>q1;
    queue<node>q2;
    for1(i,0,4) s.a[i]=init[i];
    for1(i,0,4) e.a[i]=ans[i];
    sums=fun(s),sume=fun(e);
    vis[sums]=1;vis[sume]=2;
    q1.push(s);q2.push(e);
    while(!q1.empty()||!q2.empty()){
        if(!q1.empty()) res=bfs(q1,true);
        if(found) return res;
        if(!q2.empty()) res=bfs(q2,false);
        if(found) return res;
    }
    return -1;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("test.in","r",stdin);
    freopen("test.out","w",stdout);
#endif
    sf(T);
    while(T--){
        char c;
        for1(i,0,4){
            cin>>c;
            init[i]=c-'0';
        }
        for1(i,0,4){
            cin>>c;
            ans[i]=c-'0';
        }
        int res=DBFS();
        pf(res);
    }
    return 0;
}


余浩媛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 1195 Open the Lock （不一样的BFS）
AC_Dreameng
07-11 2407
Open the Lock Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6045    Accepted Submission(s): 2697 Problem Description Now an emerg
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
hdu1195 Open the Lock
愿历尽千帆，归来仍少年
02-27 141
hdu1195 Open the Lock
hdu1195 Open the Lock （bfs）
苏苏爱自由
04-16 1507
Open the Lock Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6618    Accepted Submission(s): 2979 Problem Description Now an emerg
hdu1195 Open the Lock BFS 广搜
671coder的专栏
05-06 3282
题目链接：here 题意： 给你四个数字，每次可以将其中任何一个数字 +1 或者 -1 ； 1的时候-1 等于9  ；9的时候+1 等于1；  问最少需要变换几次，才可以变到目标序列。。 分析： 我先用广搜做了一遍，随后又用双向广搜做了一遍，发现双向广搜效率的确很高！ 贴一下图： 第一个是双向广搜的，下面的是广搜。。。 晒代码： 广搜： #include #includ
Hdu 1195 Open the Lock [Bfs]
11-21 1124
题目连接：点击打开链接 对于这中不是迷宫类型的广搜，最重要的就是两点： 第一：找状态。 第二：找操作。 对于该题： 第一，每位上数字。 第二，有三种操作，加1，减1，交换。 简单的广搜，思路就是最基本的。直接代码。 #include #include #include #include using namespace std; const int L=5; const int N
HDU1195 ZOJ2416 Open the Lock【BFS】
海岛Blog
08-11 742
  Open the Lock   Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6675    Accepted Submission(s): 3014     Problem Description Now an em...
HDU1195Open the Lock(BFS)
青山绿水之辈 专栏
12-11 901
Open the Lock Description Now an emergent task for you is to open a password lock. The password is consisted of four digits. Each digit is numbered from 1 to 9.  Each time, you can add or m
hdu1195Open the Lock（BFS）
no pains,no gains
11-16 1200
题目链接：hdu1195 思路：BFS，对于每个数每次有11种操作，千位和百位交换，百位和十位交换，十位和个位交换，千位加一或减一，百位加一或减一，十位加一或减一，个位加一或减一，将每次操作得到的数与目标数进行对比，同时用数组v[]进行标记，已出现过的数不再压入队列中 #include #include #include #include #include #include #in
HDU 1195 Open the Lock (双向BFS)
NotPerfect-EOF
06-28 1411
单广，双广都用了，感觉双向BFS，太棒了，HDU的这个题双向BFS时间优化的太棒了 有图，有真相！
hdu1195 Open the Lock(BFS)
天亮说晚安
07-21 1504
http://acm.hdu.edu.cn/showproblem.php?pid=1195 BFS 三个方向：加1，减1，相邻交换，其中9+1=1，1-1=9，最左边不与最右边相邻 code: #include #include #include #include #include #include using namespace std; int visit[11][11]
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
code_hdu.rar_ACM_The First_hdu_test case example
09-23
For a positive integer n, let’s denote function f(n,m) as the m-th smallest integer x that x>n and gcd(x,n)=1. For example, f(5,1)=6 and f(5,5)=11. You are given the value of m and (f(n,m)?n)⊕n,...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
分包合同计量单.docx
07-13
分包合同计量单.docx
树莓派简介PPT课件.ppt
07-13
树莓派简介PPT课件.ppt
项目债务盘点明细表.docx
07-13
项目债务盘点明细表.docx
全网最热Python3入门+进阶 更快上手实际开发
最新发布
07-13
网最热Python3入门+进阶 更快上手实际开发 第1章 Python入门导学.mp4 239.6MB 第9章 高级部分：面向对象 第8章 Python函数 第7章 包、模块、函数与变量作用域 第6章 分支、循环、条件与枚举 第5章 变量与运算符 第4章 Python中表示“组”的概念与定义 第3章 理解什么是写代码与Python的基本类型 第2章 Python环境安装 第1章 Python入门导学 第14章 Pythonic与Python杂记 第13章 实战：原生爬虫 第12章 函数式编程： 匿名函数、高阶函数、装饰器

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值