【更新】HDOJ 1195 Open the Lock (双向BFS)

最新推荐文章于 2016-06-08 22:21:55 发布

s哒c

最新推荐文章于 2016-06-08 22:21:55 发布

阅读量1k

点赞数

分类专栏： HDOJ 【搜索】文章标签： ACM HDOJ 双向BFS 搜索

本文链接：https://blog.csdn.net/sdc1992/article/details/8644898

版权

HDOJ 同时被 2 个专栏收录

34 篇文章 0 订阅

订阅专栏

【搜索】

12 篇文章 0 订阅

订阅专栏

该博客介绍了如何使用双向BFS解决HDOJ 1195问题，即从一个4位数变换到另一个4位数的最短步骤。题目中给出了3种变换方式：加1、减1和交换相邻数字。作者通过两个队列分别进行正向和反向搜索，并利用map避免重复，当正向搜索遇到反向搜索中的数时，得出最少步数。文章强调了搜索策略的重要性，指出应优先扩展节点数量较少的一边，并提供了最初的错误代码作为参考，以展示优化过程。

摘要由CSDN通过智能技术生成

http://acm.hdu.edu.cn/showproblem.php?pid=1195

题意：要从一个4位数，变成另一个4位数。有3种变换方法：1、选择一位加1（9+1变成1）；2、选择一位减1（1-1变成9）；3、选择相邻的两位交换其数值（第一位与第四位不相邻）。求最少的步数。

思路：这是我第一次写出双向BFS~用两个队列分别记录正向的bfs和反向的back_bfs，用map进行查重，map中的第二个值记录当前关键字的步数。~~搜一层正向的~~，并判断有没有在反向中出现；~~再搜一层反向的~~，并判断有没有在正向中出现。循环上面的搜索过程，直到搜到正向和反向中有交集（即搜到相同关键字）位置，将正向和反向的步数加和即可。

注意：一定要搜完一层再搜另一层！！！！

后记：双向BFS每次扩展应该是选择结点少的一边扩展，不是想上面说的正着搜完一层再反着搜一层。所以改了一下代码。

新代码如下：

#include<iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<map>

using namespace std;

struct node
{
    string password;
    int cnt;
}now,tmp;

string beg,end;
map<string,int>back_vis;
map<string,int>vis;
queue<struct node>q;
queue<struct node>back_q;

int back_bfs(int n)//反向BFS，每次只搜一层,即第n层
{
	while(!back_q.empty()&&back_q.front().cnt==n)
    {
        now=back_q.front();
        back_q.pop();
        for(int i=0;i<4;i++)
        {
            //各个位-1
            tmp=now;
            if(tmp.password[i]!='1')
                tmp.password[i]--;
            else
                tmp.password[i]='9';
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
            //各个位+1
            tmp=now;
            if(tmp.password[i]!='9')
                tmp.password[i]++;
            else
                tmp.password[i]='1';
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
        }
        for(int i=0;i<3;i++)
        {
            tmp=now;
            swap(tmp.password[i],tmp.password[i+1]);
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
        }
    }
    return -1;
}

int bfs(int n)//反向BFS，每次只搜一层,即第n层
{
    while(!q.empty()&&q.front().cnt==n)
    {
        int n=q.front().cnt;
        while(q.front().cnt<=n)
        {
            now=q.front();
            q.pop();
            for(int i=0;i<4;i++)
            {
                //各个位-1
                tmp=now;
                if(tmp.password[i]!='1')
                    tmp.password[i]--;
                else
                    tmp.password[i]='9';
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
                //各个位+1
                tmp=now;
                if(tmp.password[i]!='9')
                    tmp.password[i]++;
                else
                    tmp.password[i]='1';
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
            }
            for(int i=0;i<3;i++)
            {
                tmp=now;
                swap(tmp.password[i],tmp.password[i+1]);
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
            }
        }
    }
	return -1;
}

int main()
{
    int t;
    while(cin>>t)
    {
        while(t--)
        {
            cin>>beg;
            cin>>end;
            vis.clear();//清空map
            back_vis.clear();//清空map
            while(!back_q.empty())
                back_q.pop();//清空反向BFS的队列
            now.password=end;
            now.cnt=0;
            back_q.push(now);
			back_vis[end]=0;//将反向BFS的起始点入队列标记
			while(!q.empty())
				q.pop();//清空正向BFS的队列
			now.password=beg;
			now.cnt=0;
			q.push(now);
			vis[beg]=0;
			int n=0;
			int ret=-1;
			while(ret==-1)
			{
				if(!q.empty()&&q.size()<=back_q.size())
					ret=bfs(q.front().cnt);
				else if(!back_q.empty())
					ret=back_bfs(back_q.front().cnt);
				else
					break;
			}
            cout<<ret<<endl;
        }
    }
    return 0;
}

*****************************************************************************************************************************************************************************************

下面这个代码是我最开始写的，是机械的正反交替搜的，不可取~

第一次写双向BFS，代码可能写得不好，仅供参考

#include<iostream>
#include<algorithm>
#include<string>
#include<queue>
#include<map>

using namespace std;

struct node
{
    string password;
    int cnt;
}now,tmp;

string beg,end;
map<string,int>back_vis;
map<string,int>vis;
queue<struct node>q;
queue<struct node>back_q;

int back_bfs(int n)//反向BFS，每次只搜一层,即第n层
{
    while(back_q.front().cnt<=n)
    {
        now=back_q.front();
        back_q.pop();
        for(int i=0;i<4;i++)
        {
            //各个位-1
            tmp=now;
            if(tmp.password[i]!='1')
                tmp.password[i]--;
            else
                tmp.password[i]='9';
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
            //各个位+1
            tmp=now;
            if(tmp.password[i]!='9')
                tmp.password[i]++;
            else
                tmp.password[i]='1';
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
        }
        for(int i=0;i<3;i++)
        {
            tmp=now;
            swap(tmp.password[i],tmp.password[i+1]);
            if(vis.find(tmp.password)!=vis.end())//判断是否在正向队列中找到
                return tmp.cnt+1+vis[tmp.password];
            if(back_vis.find(tmp.password)==back_vis.end())
            {
                tmp.cnt++;
                back_q.push(tmp);
                back_vis[tmp.password]=tmp.cnt;
            }
        }
    }
    return -1;
}

int bfs()
{
    while(!q.empty())
        q.pop();//清空正向BFS的队列
    now.password=beg;
    now.cnt=0;
    q.push(now);
    vis[beg]=0;
    while(!q.empty())
    {
        int n=q.front().cnt;
        while(q.front().cnt<=n)
        {
            now=q.front();
            q.pop();
            for(int i=0;i<4;i++)
            {
                //各个位-1
                tmp=now;
                if(tmp.password[i]!='1')
                    tmp.password[i]--;
                else
                    tmp.password[i]='9';
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
                //各个位+1
                tmp=now;
                if(tmp.password[i]!='9')
                    tmp.password[i]++;
                else
                    tmp.password[i]='1';
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
            }
            for(int i=0;i<3;i++)
            {
                tmp=now;
                swap(tmp.password[i],tmp.password[i+1]);
                if(back_vis.find(tmp.password)!=back_vis.end())//判断是否在反向队列中找到
                    return tmp.cnt+1+back_vis[tmp.password];
                if(vis.find(tmp.password)==vis.end())
                {
                    tmp.cnt++;
                    q.push(tmp);
                    vis[tmp.password]=tmp.cnt;
                }
            }
        }
        int ret=back_bfs(now.cnt);
        if(ret!=-1)
            return ret;
    }
}

int main()
{
    int t;
    while(cin>>t)
    {
        while(t--)
        {
            cin>>beg;
            cin>>end;
            vis.clear();//清空map
            back_vis.clear();//清空map
            while(!back_q.empty())
                back_q.pop();//清空反向BFS的队列
            now.password=end;
            now.cnt=0;
            back_q.push(now);
            back_vis[end]=0;//将反向BFS的起始点入队列标记
            int ret=bfs();
            cout<<ret<<endl;
        }
    }
    return 0;
}

s哒c

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【更新】HDOJ 1195 Open the Lock (双向BFS)

http://acm.hdu.edu.cn/showproblem.php?pid=1195题意：要从一个4位数，变成另一个4位数。有3种变换方法：1、选择一位加1（9+1变成1）；2、选择一位减1（1-1变成9）；3、选择相邻的两位交换其数值（第一位与第四位不相邻）。求最少的步数。思路：这是我第一次写出双向BFS~用两个队列分别记录正向的bfs和反向的back_bfs，用map进行查重，
复制链接

扫一扫

专栏目录