正文
Java实现第八届蓝桥杯青蛙跳杯子
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
flowchart 箭头图标 勿删
青蛙跳杯子
题目描述
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
我们约定，输入的串的长度不超过15
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
----------------------------
笨笨有话说：
我梦见自己是一棵大树，
青蛙跳跃，
我就发出新的枝条，
春风拂动那第 5 层的新枝,
哦，我已是枝繁叶茂。
package 第三次线下模拟;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
public class 青蛙跳杯子 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String start = sc.next();
String end = sc.next();
sc.close();
Map<String, Boolean> map = new HashMap<String, Boolean>();
Queue<Node> queue = new LinkedList<Node>();
queue.add( new Node(start,0));
map.put(start, true);
while(!queue.isEmpty()){
Node node =queue.poll();
if(node.str.equals(end)){
System.out.println(node.step);
return;
}
int step=node.step;
char[] str = node.str.toCharArray();
for (int i = 0; i < str.length; i++) {
if(str[i]!='*'){
for (int j = -3; j <=3; j++) {
if(i+j<0||i+j>=str.length||j==0||str[i+j]!='*') continue;
str=swap(str,i,i+j);
node = new Node(String.valueOf(str),step+1);
if(!map.containsKey(node.str)){
queue.add(node);
map.put(node.str,true);
}
str=swap(str,i,i+j);
}
}
}
}
}
public static char[] swap(char[] s,int i,int j){
s[i]^=s[j];
s[j]^=s[i];
s[i]^=s[j];
return s;
}
static class Node{
int step = 0;
String str;
public Node(String str, int step){
this.str = str;
this.step = step;
}
}
}
package 第五次模拟;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
public class Demo9青蛙跳被子 {
static String inStr;
static String targetStr;
static List<String> list = new LinkedList<String>();
//使用map来记录，防止循环重复
static Map<String, Boolean> vis = new HashMap<String, Boolean>();
public static void main(String[] args)throws IOException {
BufferedReader bReader = new BufferedReader(new InputStreamReader(System.in));
inStr = bReader.readLine();
targetStr = bReader.readLine();
bReader.close();
System.out.println(bfs());
}
public static int bfs (){
//典型的BFS用LinkedList实现Queue
Queue<Node> queue = new LinkedList<Node>();
Node node = new Node(String.valueOf(inStr), 0);
queue.add(node);
// list.add(node.str);
vis.put(node.str, true);
while(queue.size() != 0){
node = queue.poll();
//如果当前字符串和结果相等，直接输出
if(isOk(node.str)){
return node.step;
}
char[] str = node.str.toCharArray();
int step = node.step;
for(int i=0; i<str.length; i++){
//如果当前位*，则跳过，我们判断的是青蛙，而不是空杯子
if(str[i] == '*') continue;
for(int j = -3; j<=3; j++){
if(i+j<0 || i+j>=str.length || j==0 || str[i+j] != '*') continue;
//有空杯子就叫唤
str = swap(str, i, j);
//新建node
node = new Node(String.valueOf(str), step+1);
//看以前有没有相同的字符串，如果有只能是循环了，continue
if (!vis.containsKey(node.str)){
//没有就加进去
queue.add(node);
// list.add(node.str);
vis.put(node.str, true);
}
//使用完交换回来
str = swap(str, i, j);
}
}
}
//全部循环完，还没有，没结果
return -1;
}
public static char[] swap (char[] str, int i, int j){
char tmp = str[i];
str[i] = str[j+i];
str[j+i] = tmp;
return str;
}
public static boolean isOk(String str){
if (targetStr.equalsIgnoreCase(String.valueOf(str))){
return true;
} else {
return false;
}
}
}
class Node{
int step = 0;
String str;
public Node(String str, int step){
this.str = str;
this.step = step;
}
}
