当前位置： 首页 > article >正文

算法系列之深度优先搜索寻找妖怪和尚过河问题的所有方式

article 2025/3/10 5:16:17

_20250309_231001.png

在算法学习中，深度优先搜索（DFS）是一种常用的图搜索算法，通过递归或栈实现，适合路径搜索、连通性、拓扑排序、回溯、生成、环路检测、强连通分量和可达性等问题。本文将介绍如何利用深度优先搜索解决“妖怪和尚过河问题”的所有方式。

问题描述

有三个妖怪和三个和尚需要过河。他们只有一条小船，且船最多只能载两人。在任何时候，无论是岸边还是船上，如果妖怪的数量多于和尚，和尚就会被吃掉。如何安排过河顺序，才能让所有妖怪和和尚安全过河？列出所有可能的解？

_20250308_232541.png

问题分析

首先，我们需要将建立状态和动作的数学模型，我们要明确问题的状态表示。我们用五个属性来表示状态，

//左岸和尚数量
int leftMonk;
//左岸妖怪数量
int leftMonster;
//右岸和尚数量
int rightMonk;
//右岸妖怪数量
int rightMonster;
//-1代表左岸，1代表右岸
int boatLocation;

结合船移动的方向，一共右10中过河动作可供选择，分别是

* 1、一个妖怪从左岸到右岸
* 2、一个和尚从左岸到右岸
* 3、两个妖怪从左岸到右岸
* 4、两个和尚从左岸到右岸
* 5、一个和尚一个妖怪从左岸到右岸
* 6、一个妖怪从右岸到左岸
* 7、一个和尚从右岸到左岸
* 8、两个妖怪从右岸到左岸
* 9、两个和尚从右岸到左岸
* 10、一个和尚一个妖怪从右岸到左岸

我们的目标是从初始状态 (3, 3, 0, 0, -1) 通过一系列合法的移动，达到目标状态 (0, 0, 3, 3, 1)。

Java使用DFS解决问题

深度优先搜索和广度优先搜索一样，都是对图进行搜索的算法，目的也都是从起点开始搜索，直到到达顶点。深度优先搜索会沿着一条路径不断的往下搜索，直到不能够在继续为止，然后在折返，开始搜索下一条候补路径。我们可以将每个状态看作图中的一个节点，合法的移动就是节点之间的边。通过DFS，我们可以列出所有能过河的方式。

算法步骤

  1. 初始化：将初始状态 (3, 3, 0, 0, -1) 作为递归的起始节点，并标记为已访问。

  2. 递归寻找可能的路径：

  • 取出当前的状态。

  • 生成所有可能的下一步状态。

  • 检查这些状态是否合法（即不违反妖怪和和尚的数量限制）。

  • 如果某个状态是目标状态，则将当前节点添加到过河方式的集合中，回溯的时候将当前节点从访问标记set中删除。

  • 否则，继续递归求解，并标记为已访问。

  1. 递归完成后打印所有可能的过河方式

代码实现如下：


/**
 * 妖怪与和尚过河问题
 * 描述：
 * 有三个和尚和三个妖怪在河的左岸，他们需要过河到右岸。
 *
 * 只有一条小船，最多可以承载两个人。
 *
 * 在任何时候，无论是左岸还是右岸，如果和尚的数量少于妖怪的数量，和尚就会被妖怪吃掉。
 *
 * 列出所有可能的解
 */
public class DFSCrossRiver {

    /**
     * 状态类（数据模型）
     */
    public static class State{
        //左岸和尚数量
        int leftMonk;
        //左岸妖怪数量
        int leftMonster;
        //右岸和尚数量
        int rightMonk;
        //右岸妖怪数量
        int rightMonster;
        //-1代表左岸，1代表右岸
        int boatLocation;
        //前一状态，用于回溯打印路径
        State preState;

        public State(int leftMonk, int leftMonster, int rightMonk, int rightMonster, int boatLocation, State preState) {
            this.leftMonk = leftMonk;
            this.leftMonster = leftMonster;
            this.rightMonk = rightMonk;
            this.rightMonster = rightMonster;
            this.boatLocation = boatLocation;
            this.preState = preState;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            State state = (State) o;
            return leftMonk == state.leftMonk && leftMonster == state.leftMonster && rightMonk == state.rightMonk && rightMonster == state.rightMonster && boatLocation == state.boatLocation ;
        }

        @Override
        public int hashCode() {
            return Objects.hash(leftMonk, leftMonster, rightMonk, rightMonster, boatLocation);
        }
    }

    /**
     * 动作类，记录妖怪与和尚过河的动作
     */
    @Data
    public static class Action{
        int monkNum; //船上和尚数量
        int monsterNum;//船上妖怪数量
        int boatLocation;//船移动后位置

        public Action(int monkNum, int monsterNum, int boatLocation) {
            this.monkNum = monkNum;
            this.boatLocation = boatLocation;
            this.monsterNum = monsterNum;
        }
    }


    /**
     * 列举过河动作的可供选择
     * 共有十种情况
     * 1、一个妖怪从左岸到右岸
     * 2、一个和尚从左岸到右岸
     * 3、两个妖怪从左岸到右岸
     * 4、两个和尚从左岸到右岸
     * 5、一个和尚一个妖怪从左岸到右岸
     * 6、一个妖怪从右岸到左岸
     * 7、一个和尚从右岸到左岸
     * 8、两个妖怪从右岸到左岸
     * 9、两个和尚从右岸到左岸
     * 10、一个和尚一个妖怪从右岸到左岸
     *
     */
    public static List<Action> getActions(){
        List<Action> actions = new ArrayList<>();
        //一个妖怪从左岸到右岸
        actions.add(new Action(0,1,1));
        //两个妖怪从左岸到右岸
        actions.add(new Action(0,2,1));
        //一个和尚从左岸到右岸
        actions.add(new Action(1,0,1));
        //两个和尚从左岸到右岸
        actions.add(new Action(2,0,1));
        //一个和尚一个妖怪从左岸到右岸
        actions.add(new Action(1,1,1));
        //一个妖怪从右岸到左岸
        actions.add(new Action(0,1,-1));
        //两个妖怪从右岸到左岸
        actions.add(new Action(0,2,-1));
        //一个和尚从右岸到左岸
        actions.add(new Action(1,0,-1));
        //两个和尚从右岸到左岸
        actions.add(new Action(2,0,-1));
        //一个和尚一个妖怪从右岸到左岸
        actions.add(new Action(1,1,-1));
        return actions;

    }

    /**
     * 初始状态
     */
    public static State initState(){
        State state = new State(3,3,0,0,-1,null);
        return state;
    }

    /**
     * 生成所有可能的下一个状态
     */
    public static List<State> generateNextStates(State state){
        List<State> nextStates = new ArrayList<>();
        State nextState;
        for (Action action : getActions()) {
            if(state.boatLocation != action.boatLocation){
                nextState = new State(state.leftMonk - action.monkNum*action.boatLocation, state.leftMonster - action.monsterNum*action.boatLocation,
                        state.rightMonk + action.monkNum*action.boatLocation, state.rightMonster + action.monsterNum*action.boatLocation,
                        action.boatLocation, state);
                //有效则添加
                if(checkState(nextState)){
                    nextStates.add(nextState);
                }
            }
        }
        return nextStates;
    }

    /**
     * 检查状态是否有效,(无论是左岸还是右岸，和尚数量大于妖怪数量则有效)
     */
    public static boolean checkState(State state) {
        //任何一岸的和尚数量不能少于妖怪数量，除非和尚数量为0。
        if(state.leftMonk < 0 || state.leftMonster < 0 || state.rightMonk < 0 || state.rightMonster < 0){
            return false;
        }
        //不管是左岸还是右岸，和尚数量大于妖怪数量或者和尚全部在河对岸则有效,船也只能从对岸来回开
        return (state.leftMonk == 0 || state.leftMonk >= state.leftMonster)
                && (state.rightMonk == 0 || state.rightMonk >= state.rightMonster) && state.boatLocation !=state.preState.boatLocation;
    }

    /**
     * 判断是否成功
     */
    public static boolean isSuccess(State state){
        return state.leftMonk == 0 && state.leftMonster == 0;
    }


    /**
     * 深度优先搜索方式解决渡河问题
     * 添加所有可能的方式
     */
    public static void crossRiver(State state,Set<State> visited,List<State> resultStates){
        //每次递归之前都要检查是否成功，如果成功则添加到结果集合中，并返回。
        if(isSuccess(state)){
            resultStates.add(state);
            return ;
        }
        //递归深度优先搜索
        for(State nextState : generateNextStates(state)){
            if(!visited.contains(nextState)){
                //每种方式都要添加到已访问集合中，避免重复搜索
                visited.add(nextState);
                crossRiver(nextState,visited,resultStates);
                visited.remove(nextState);
            }
        }


    }

    /**
     * 递归打印路径
     */

    public static void  printPath(State state){
        if(state.preState == null){
            return;
        }
        printPath(state.preState);
        System.out.println("从"+(state.preState.boatLocation==-1?"左":"右")+"岸到"+(state.boatLocation==-1?"左":"右")+"岸");
        System.out.println("和尚："+state.leftMonk+" "+state.rightMonk);
        System.out.println("妖怪："+state.leftMonster+" "+state.rightMonster);
    }


    public static void main(String[] args) {
        State initState = initState();
        List<State> result = new ArrayList<>();
        Set<State> visited = new HashSet<>();
        visited.add(initState);
        crossRiver(initState,visited,result);
        int i =1;
        for(State state : result){
            System.out.println("--------------方式"+i+"---------------------------");
            printPath(state);
            i++;
        }

    }
}

执行结果如下：

--------------方式1---------------------------
从左岸到右岸
和尚：3 0
妖怪：1 2
从右岸到左岸
和尚：3 0
妖怪：2 1
从左岸到右岸
和尚：3 0
妖怪：0 3
从右岸到左岸
和尚：3 0
妖怪：1 2
从左岸到右岸
和尚：1 2
妖怪：1 2
从右岸到左岸
和尚：2 1
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：2 1
从右岸到左岸
和尚：0 3
妖怪：3 0
从左岸到右岸
和尚：0 3
妖怪：1 2
从右岸到左岸
和尚：0 3
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：0 3
--------------方式2---------------------------
从左岸到右岸
和尚：3 0
妖怪：1 2
从右岸到左岸
和尚：3 0
妖怪：2 1
从左岸到右岸
和尚：3 0
妖怪：0 3
从右岸到左岸
和尚：3 0
妖怪：1 2
从左岸到右岸
和尚：1 2
妖怪：1 2
从右岸到左岸
和尚：2 1
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：2 1
从右岸到左岸
和尚：0 3
妖怪：3 0
从左岸到右岸
和尚：0 3
妖怪：1 2
从右岸到左岸
和尚：1 2
妖怪：1 2
从左岸到右岸
和尚：0 3
妖怪：0 3
--------------方式3---------------------------
从左岸到右岸
和尚：2 1
妖怪：2 1
从右岸到左岸
和尚：3 0
妖怪：2 1
从左岸到右岸
和尚：3 0
妖怪：0 3
从右岸到左岸
和尚：3 0
妖怪：1 2
从左岸到右岸
和尚：1 2
妖怪：1 2
从右岸到左岸
和尚：2 1
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：2 1
从右岸到左岸
和尚：0 3
妖怪：3 0
从左岸到右岸
和尚：0 3
妖怪：1 2
从右岸到左岸
和尚：0 3
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：0 3
--------------方式4---------------------------
从左岸到右岸
和尚：2 1
妖怪：2 1
从右岸到左岸
和尚：3 0
妖怪：2 1
从左岸到右岸
和尚：3 0
妖怪：0 3
从右岸到左岸
和尚：3 0
妖怪：1 2
从左岸到右岸
和尚：1 2
妖怪：1 2
从右岸到左岸
和尚：2 1
妖怪：2 1
从左岸到右岸
和尚：0 3
妖怪：2 1
从右岸到左岸
和尚：0 3
妖怪：3 0
从左岸到右岸
和尚：0 3
妖怪：1 2
从右岸到左岸
和尚：1 2
妖怪：1 2
从左岸到右岸
和尚：0 3
妖怪：0 3

总结

通过深度优先搜索，我们可以找到所有可能的过河方案。这个问题展示了如何通过状态空间搜索来解决经典的逻辑问题。希望这篇博客对你理解妖怪与和尚过河问题的解法有所帮助！


http://www.kler.cn/a/578134.html

相关文章：

  • 自执行函数（Self-Invoking Function）
  • Vue2使用jsts，将wkt转为geojson
  • 计算机网络篇：基础知识总结与基于长期主义的内容更新
  • 【问题解决】Jenkins使用File的exists()方法判断文件存在，一直提示不存在的问题
  • webshell一些上传心得
  • 代理IP与反爬技术的博弈
  • mysql经典试题共34题
  • UDP协议和报文格式
  • Redis | 哨兵 Sentinel
  • Java高频面试之集合-07
  • LeetCode 90: 子集 II
  • 【后端开发】go-zero微服务框架实践（goland框架对比，go-zero开发实践，文件上传问题优化等等）
  • Docker基础-项目部署流程解析
  • 07 HarmonyOS NEXT 仿uv-ui Tag组件开发教程系列(一)
  • VUE3开发-9、axios前后端跨域问题解决方案
  • K8s 1.27.1 实战系列（三）安装网络插件
  • spring Web Mvc 介绍
  • SpireCV荣获Gitee 最有价值开源项目称号
  • 中国嵌入式单片机就业形势分析
  • 【Redis】终极缓存四连杀：缓存预热、缓存击穿、缓存穿透、缓存雪崩，真的懂了吗？