蓝桥杯 试题 历届试题 青蛙跳杯子 bfs+剪枝

问题描述

　　X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。
　　X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。
　　如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。


　　*WWWBBB


　　其中，W字母表示白色青蛙，B表示黑色青蛙，*表示空杯子。


　　X星的青蛙很有些癖好，它们只做3个动作之一：
　　1. 跳到相邻的空杯子里。
　　2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。
　　3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。


　　对于上图的局面，只要1步，就可跳成下图局面：


　　WWW*BBB


　　本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。


　　输入为2行，2个串，表示初始局面和目标局面。
　　输出要求为一个整数，表示至少需要多少步的青蛙跳。

样例输入

*WWBB
WWBB*

样例输出

2

样例输入

WWW*BBB
BBB*WWW

样例输出

10

---

解题思路：宽度优先搜索按照距开始状态由远及近的顺序进行搜索，因此可以很容易地来求最短路径，最小操作数之类的问题。

---

深度优先搜索(隐式地)利用了栈进行计算，而宽度优先搜索(显式地)利用队列。搜索时首先将初始状态加入队列里，然后不断从队列的最前端

取出状态，可以把该状态转移到的且未访问过的状态加入队列，如此往复，直到队列被取空或者找到了问题的解。

宽度优先搜索中，只要将已经访问过的状态用标记管理起来，就可以很好的做到由远及近搜索。

---

在此题中，因为青蛙只能跳到空杯子里，所以只要关注空杯子位置 k 的 [ k-3, k+3 ] 的青蛙。可以用一个数组保存六个向量。

对于访问过状态的标记可以用集合<set> 也可以用键值对<map>。这里我用的是集合。(集合中不允许相同的元素出现两次)

 

---

这里注意将未访问的状态加入集合的时机。

 

原本我是交换空杯子和青蛙位置后判断是否访问，接着不加入而是等着下一次弹出这个状态时再加入，结果提交时最后两个超时。

 

原来是可能有相同的状态加入队列，比如初始状态为WW*BB,这时我们关注W*WBB和*WWBB，加入时不把他们加入集合，

 

那么当W*WBB被弹出时，又会交换出*WWBB，导致超时。下面是超时和正确代码。

---

超时代码：

 

#include<iostream>
#include<string>
#include<queue>
#include<set>
#include<algorithm>
using namespace std;

struct state//当前局面 
{
    string str;    //字符串 
    int step;    //从初始到当前状态所需的最小步数 
    state(string str_,int step_)    //构造函数 
    {
        str =  str_; step = step_;
    }
};

//输入
string begin,end;//初始局面和目标局面 

int dir[] = {-3,-2,-1,1,2,3};//可能移动的六个方向 

int bfs()
{
    
    queue<state> que;    //bfs显示调用队列
    set<string> s;        //用于标记已经访问的状态 
    
    que.push(state(begin,0));//首先加入初始队列 
    
    while( que.size() )
    {
        
        state current = que.front();    que.pop();    //取出最前端局面 
        string str = current.str; int step = current.step;
 
        if( str==end ){  //如果到达目标局面 
            return step;
        }
　　
　　　　　s.insert(str); 　　//!!去重去晚了　!!
        
        for(int i=0,len=str.length(); i<len; i++)
        {
            if( str[i]!='*' ){    //只关注空杯子的位置 
                continue;
            }
            
            for(int j=0; j<6; j++)    //六个方向 
            {
                int cur = i + dir[j];
                if( 0<=cur&&cur<len )
                {
                    swap(str[i],str[cur]);//交换 
                    if( !s.count(str) )
                    {
                        que.push(state(str,step+1));//加入队列 
                    }    
                    swap(str[i],str[cur]);//回溯 
                } 
            }
        }
    }    
} 

void solve()
{
    int ans = bfs();
    cout<<ans<<endl;
}

int main()
{
    cin>>begin>>end;
    
    solve();
    
    return 0;
}

---

AC代码：

#include<iostream>
#include<string>
#include<queue>
#include<set>
#include<algorithm>
using namespace std;

struct state//当前局面 
{
    string str;    //字符串 
    int step;    //从初始到当前状态所需的最小步数 
    state(string str_,int step_)    //构造函数 
    {
        str =  str_; step = step_;
    }
};

//输入
string begin,end;//初始局面和目标局面 

int dir[] = {-3,-2,-1,1,2,3};//可能移动的六个方向 

int bfs()
{
    
    queue<state> que;    //bfs显示调用队列
    set<string> s;        //用于标记已经访问的状态 
    
    que.push(state(begin,0));//首先加入初始队列 
    s.insert(begin);    //去重 
    
    while( que.size() )
    {
        
        state current = que.front();    que.pop();    //取出最前端局面 
        string str = current.str; int step = current.step;
 
        if( str==end ){  //如果到达目标局面 
            return step;
        }
        
        for(int i=0,len=str.length(); i<len; i++)
        {
            if( str[i]!='*' ){    //只关注空杯子的位置 
                continue;
            }
            
            for(int j=0; j<6; j++)    //六个方向 
            {
                int cur = i + dir[j];
                if( 0<=cur&&cur<len )
                {
                    swap(str[i],str[cur]);//交换 
                    if( !s.count(str) )
                    {
                        s.insert(str);//!!这里就要去重!! 
                        que.push(state(str,step+1));//加入队列 
                    }    
                    swap(str[i],str[cur]);//回溯 
                } 
            }
        }
    }    
} 

void solve()
{
    int ans = bfs();
    cout<<ans<<endl;
}

int main()
{
    cin>>begin>>end;
    
    solve();
    
    return 0;
}