人工智能 DFS 卒子穿阵问题 Java

---

一、问题描述

要求一卒子从顶部通过下图所示的阵列到达底部。卒子行进中不可进入到代表敌兵驻守的区域（标注1），并不准后退。假定深度限制值为5。

二、解决方法

1.定义状态空间

用一个二维数组来记录卒子的位置
（x，y）即为当前卒子在矩阵中的位置。
起始状态为（0，1）或（0，2）或（0，3），
目标状态为（3，1）或（3，2）或（3，3）。
(只要最顶部为0即可出发，底部为0即可结束)

2.确定一组操作数

①卒子向右走
②卒子向左走
③卒子向下走

3.搜索过程

1.演示图

简单画了一下图
为了看起来方便我坐标从1开始，代码从0开始的

整体思路为深度优先搜索算法
先初始化状态空间，将起点的状态空间设为已访问，
之后对卒子进行操作，生成子节点，判断是否为目标状态，
如果不是，则将该节点加入栈中，并设为已访问，继续向下遍历
如果是，输出，然后继续循环，直到遍历完所有的节点

三、代码实现

1.关键代码

实现深度优先搜索

private void dfs(int x, int y) {
        //判断是否到达底部并且对深度进行限制
        if (x == 3 && pathStack.size() <= 6) {
            print(pos);
            pos++;
        } else {
            for (int i = 1; i <= 3; i++) {
                //移动后返回子节点
                SoldierPosition news = operate(x, y, i);
                //查重，并判断操作后的子节点是否为敌军驻守的区域
                if (checkRepeat(news.x, news.y) == 0 && map[news.x][news.y] == 0) {
                    pathStack.push(news);//入栈
                    space[news.x][news.y] = 1;//设置为已访问
                    dfs(news.x, news.y);//递归遍历
                    pathStack.pop();//出栈
                    space[news.x][news.y] = 0;//状态重置
                }
            }
        }
    }

2.全部代码

import java.util.Stack;

public class Soldier {
    private int space[][] = new int[5][5];//状态空间，记录节点访问情况
    private int[][] map = {
            {1, 0, 0, 0},
            {0, 0, 1, 0},
            {0, 1, 0, 0},
            {1, 0, 0, 0}
    };
    private int[][] newMap = new int[5][5];//设置两个二维数组，map主要用来重置和进行对照，newMap用于修改并输出
    private int pos = 1;
    private Stack<SoldierPosition> pathStack = new Stack();

    public static void main(String[] args) {
        Soldier soldier = new Soldier();
    }

    public Soldier() {
        System.out.println("---------------起点为[0,1]---------------");
        initSpace();
        //将起点设置为已访问
        space[0][1] = 1;
        pathStack.push(new SoldierPosition(0, 1));
        dfs(0, 1);//深度优先搜索
        pathStack.pop();
        System.out.println("---------------起点为[0,2]---------------");
        //新的起点开始前要初始化状态空间
        initSpace();
        space[0][2] = 1;
        pathStack.push(new SoldierPosition(0, 2));
        dfs(0, 2);
        pathStack.pop();//同时不要忘了将起点出栈，将栈清空
        System.out.println("---------------起点为[0,3]---------------");
        initSpace();
        space[0][3] = 1;
        pathStack.push(new SoldierPosition(0, 3));
        dfs(0, 3);
        pathStack.pop();
    }
    //输出
    private void print(int pos) {
        //每次输出都要重置地图
        resetMap();
        System.out.println("result:" + pos);
        int l1 = pathStack.size();//存储栈的长度
        int l2 = l1;//要用到两次，所以再取一次
        int i = 0;
        while (l1 > 0) {
            newMap[pathStack.get(i).x][pathStack.get(i).y] = 2;
            i++;
            l1--;
        }
        for (int k = 0; k < 4; k++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(newMap[k][j] + " ");
            }
            System.out.println();
        }
        //输出具体的路径
        System.out.print("路径为：");
        int j = 0;
        while (l2 > 0) {
            System.out.print("<" + pathStack.get(j).x + ',' + pathStack.get(j).y + "> ");
            j++;
            l2--;
        }
        System.out.println("\n");
    }
    //深度优先搜索
    private void dfs(int x, int y) {
        //判断是否到达底部并且对深度进行限制
        if (x == 3 && pathStack.size() <= 6) {
            print(pos);
            pos++;
        } else {
            for (int i = 1; i <= 3; i++) {
                //移动后返回子节点
                SoldierPosition news = operate(x, y, i);
                //查重，并判断操作后的子节点是否为敌军驻守的区域
                if (checkRepeat(news.x, news.y) == 0 && map[news.x][news.y] == 0) {
                    pathStack.push(news);//入栈
                    space[news.x][news.y] = 1;//设置为已访问
                    dfs(news.x, news.y);//递归遍历
                    pathStack.pop();//出栈
                    space[news.x][news.y] = 0;//状态重置
                }
            }
        }
    }
    //每次对地图的输出都会修改地图的值，所以地图需要重置
    private void resetMap() {
        for (int i = 0; i < map.length; i++) {
            newMap[i] = map[i].clone();
        }
    }
    //实现卒子的移动
    private SoldierPosition operate(int x, int y, int i) {
        switch (i) {
            case 1://右移
                if (y + 1 < 4)
                    y++;
                break;
            case 2://左移
                if (y - 1 >= 0)
                    y--;
                break;
            case 3://下移
                if (x + 1 < 4)
                    x++;
                break;
        }
        return new SoldierPosition(x, y);
    }
    //查重
    private int checkRepeat(int x, int y) {
        if (space[x][y] == 1) {
            return 1;
        }
        return 0;
    }

    //初始化，将状态空间全部设置为未访问
    private void initSpace() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                space[i][j] = 0;
            }
        }
    }

    //声明内部类记录士兵的位置
    static class SoldierPosition {
        int x, y;

        SoldierPosition(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

}

四、运行结果

---

总结

在csdn没有找到满意的解答，所以自己琢磨琢磨写的，有不足的地方，希望大家可以指正。整体还是在水壶问题和分啤酒问题的基础上进行修改，希望可以帮助到大家。