两道bfs题 ——（青蛙跳杯子，跳蚱蜢）Java_青蛙跳杯子问题java解析-优快云博客

本文探讨了如何使用广度优先搜索(BFS)算法求解青蛙从一个杯子状态跳到另一个杯子状态的最少步数问题，以及在环形路线中找到目标状态的策略。通过示例代码展示了BFS的基本原理和实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

从一个状态到另一个状态最少需要多少步骤，毫无疑问就是BFS问题

青蛙跳杯子


import java.util.*;

public class wwww {
    static HashSet<String> set =  new HashSet<>();//访问标记
    static String s1;
    static String s2;
    static int n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        s1 = sc.next();//原状态
        s2 = sc.next();//目标状态
        n = s1.length();
        bfs();
    }
    public static void bfs() {
        Queue<NODE> q = new LinkedList<>();
        q.offer(new NODE(s1,0));//存初始状态
        set.add(s1);//标记为访问
        while (!q.isEmpty()){
            NODE top = q.poll();
            String str = top.str;
            int step = top.step;
            if(str.equals(s2)){//终止条件
                System.out.println(step);
                break;
            }
            char[] ch = str.toCharArray();
            int index = str.indexOf('*');//找每个状态的操作起点，即杯子的位置
            for(int i = -3;i <= 3;i++){
                int newIndex = index+i;//杯子的新的位置
                if(check1(newIndex,i)){//第一次检查：越界问题
                    //交换位置，即移动操作
                    swap(ch,index,newIndex);
                    String newStr = new String(ch);//得到了新的状态
                    if(check2(newStr)) {//第二次检查：是否访问过次状态
                        set.add(newStr);
                        q.offer(new NODE(newStr,step+1));
                    }
                    swap(ch,index,newIndex);
                }
            }
        }
    }
    private static void swap(char[] ch,int index,int newIndex) {
        char temp = ch[index];
        ch[index] = ch[newIndex];
        ch[newIndex] = temp;
    }
    public static boolean check1(int newIndex,int i){
        if(newIndex >= 0 && newIndex < n && i != 0){//i不能等于0，因为就相当于没移动杯子，对解题无益
            return true;
        }
        return false;
    }
    public static boolean check2(String newStr){
        if (set.contains(newStr)){
            return false;
        }
        return true;
    }
}
class NODE{
    String str;
    int step;
    public NODE(String str, int step) {
        this.str = str;
        this.step = step;
    }
}

跳蚱蜢
与上一题不同的时，这道题是在环形路线中找目标状态，那么取个余就好


import java.util.*;

public class wwww {
    static HashSet<String> set =  new HashSet<>();//访问标记
    static String s1;
    static String s2;
    static int n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        s1 = sc.next();//原状态
        s2 = sc.next();//目标状态
        n = s1.length();
        bfs();
    }
    public static void bfs() {
        Queue<NODE> q = new LinkedList<>();
        q.offer(new NODE(s1,0));//存初始状态
        set.add(s1);//标记为访问
        while (!q.isEmpty()){
            NODE top = q.poll();
            String str = top.str;
            int step = top.step;
            if(str.equals(s2)){//终止条件
                System.out.println(step);
                break;
            }
            char[] ch = str.toCharArray();
            int index = str.indexOf('*');
            for(int i = -2;i <= 2;i++){
                int newIndex = (index+i+9)%9;
                if(check1(newIndex,i)){//第一次检查：越界问题
                    //交换位置，即移动操作
                    swap(ch,index,newIndex);
                    String newStr = new String(ch);//得到了新的状态
                    if(check2(newStr)) {//第二次检查：是否访问过次状态
                        set.add(newStr);
                        q.offer(new NODE(newStr,step+1));
                    }
                    swap(ch,index,newIndex);
                }
            }
        }
    }
    private static void swap(char[] ch,int index,int newIndex) {
        char temp = ch[index];
        ch[index] = ch[newIndex];
        ch[newIndex] = temp;
    }
    public static boolean check1(int newIndex,int i){
        if(newIndex >= 0 && newIndex < n && i != 0){
            return true;
        }
        return false;
    }
    public static boolean check2(String newStr){
        if (set.contains(newStr)){
            return false;
        }
        return true;
    }
}
class NODE{
    String str;
    int step;
    public NODE(String str, int step) {
        this.str = str;
        this.step = step;
    }
}

bfs找得到目标状态所需要的最小操作数的模板


import java.util.*;

public class Main {
    static HashSet<> set =  new HashSet<>();//访问标记
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        s1//原状态
        s2//目标状态
        bfs();
    }
    public static void bfs() {
        Queue<NODE> q = new LinkedList<>();
        q.offer(new NODE(s1,0));//存初始状态
        set.add(s1);//标记为访问
        while (!q.isEmpty()){
            NODE top = q.poll();
            if(top.xxx.equals(s2)){//终止条件
                System.out.println(xxx);
                break;
            }
            for(xxxxxxxxxx){
                if(check1()){//第一次检查
					xxxx
                    if(check2(newStr)) {//第二次检查
                    	xxxx										  
                        set.add(xxxx);
                        q.offer(new NODE(xxx));
                    }
                }
            }
        }
    }
    public static boolean check1(xxxxx){
        if(xxxx){
            return true;
        }
        return false;
    }
    public static boolean check2(){
        if (xxxx){
            return false;
        }
        return true;
    }
}
class NODE{
   xxx
   xxx
   xxx
}