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

修己xj2025-03-09 23:50

_20250309_231001.png

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

问题描述

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

_20250308_232541.png

问题分析

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

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

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

markdown 复制代码 
* 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. 递归完成后打印所有可能的过河方式

代码实现如下：

scss 复制代码 
/**
 * 妖怪与和尚过河问题
 * 描述：
 * 有三个和尚和三个妖怪在河的左岸，他们需要过河到右岸。
 *
 * 只有一条小船，最多可以承载两个人。
 *
 * 在任何时候，无论是左岸还是右岸，如果和尚的数量少于妖怪的数量，和尚就会被妖怪吃掉。
 *
 * 列出所有可能的解
 */
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++;
        }

    }
}

执行结果如下：

diff 复制代码 
--------------方式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

总结

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

相关推荐
IT猿手1 小时前
2025最新群智能优化算法：海市蜃楼搜索优化（Mirage Search Optimization, MSO）算法求解23个经典函数测试集，MATLAB
开发语言·人工智能·算法·机器学习·matlab·机器人
IT猿手3 小时前
2025最新群智能优化算法：山羊优化算法（Goat Optimization Algorithm, GOA）求解23个经典函数测试集，MATLAB
人工智能·python·算法·数学建模·matlab·智能优化算法
Dream it possible！6 小时前
LeetCode 热题 100_字符串解码（71_394_中等_C++）（栈）
c++·算法·leetcode
开心比对错重要7 小时前
leetcode69.x 的平方根
数据结构·算法·leetcode
美狐美颜sdk8 小时前
什么是美颜SDK？从几何变换到深度学习驱动的美颜算法详解
人工智能·深度学习·算法·美颜sdk·第三方美颜sdk·视频美颜sdk·美颜api
m0_461502698 小时前
【贪心算法1】
算法·贪心算法
Doopny@8 小时前
数字组合（信息学奥赛一本通-1291）
数据结构·算法·动态规划
原来是猿9 小时前
蓝桥备赛（13）- 链表和 list（上）
开发语言·数据结构·c++·算法·链表·list
项目申报小狂人9 小时前
高性能算法NGO！北方苍鹰优化算法（Northern Goshawk Optimization，NGO）
算法·数学建模
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04苍穹外卖面试总结05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06本地部署DeepSeek教程（Mac版本）07Coze扣子平台完整体验和实践（附国内和国际版对比）08Windows 11 安装 Dify 完整指南 非docker环境09保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型10macOS 上部署 RAGFlow