马踏棋盘笔记+源码

最新推荐文章于 2024-07-16 12:22:44 发布

Ghost-D

最新推荐文章于 2024-07-16 12:22:44 发布

阅读量394

点赞数 5

文章标签：笔记 java

本文链接：https://blog.csdn.net/m0_71187513/article/details/139296908

版权

马踏棋盘

1、思路分析

创建棋盘chessBoard(二维数组)
将当前位置设置成已访问，然后根据当前位置，计算马还能走哪些位置，并放入到一个集合中(ArraryList),最多有8个，每走一步，使用step+1

在这里插入图片描述

遍历ArraryList中存放的所有位置，看看哪个可以去，如果可以走通就继续，如果走不通就回溯
判断马是否完成任务，使用step和应该走的步数比较，如果没有达到要求就将整个棋盘设置为0

注意：马走的策略不同，则得到的结果也不同，效率也不一样

2、代码实现

（1）定义属性

private static int X=6; //表示col列
private static int Y=6; //表示row行
private static int[][] chessBoard=new int[Y][X];    //棋盘
private static boolean[] visited=new boolean[X*Y];  //记录某个位置是否走过
private static boolean finished=false;  //记录马儿是否遍历完棋盘

（2）编写方法，获取当前位置可以走的下一步的所有位置(Point表示 x,y)

//编写方法，可以获取当前位置，可以走的下一步的所有位置(Point表示 x,y)
public static ArrayList<Point> next(Point curPoint){

    //创建一个ArrayList
    ArrayList<Point> ps = new ArrayList<>();

    //创建一个Point对象(点/位置)，准备放入到ps
    Point p1 = new Point();

    //判断在curPoint是否可以走如下位置，如果可以走，就将该点(Point)放入到ps
    //判断条件是不可以超出棋盘范围
    //判断是否可以走0的位置
    if((p1.x=curPoint.x+2)<X&&(p1.y= curPoint.y-1)>=0){
        ps.add(new Point(p1));
    }
    //判断是否可以走1的位置
    if ((p1.x= curPoint.x+2)<X&&(p1.y= curPoint.y+1)<Y){
        ps.add(new Point(p1));
    }
    //判断是否可以走2的位置
    if ((p1.x= curPoint.x+1)<X&&(p1.y= curPoint.y+2)<Y){
        ps.add(new Point(p1));
    }
    //判断是否可以走3的位置
    if ((p1.x= curPoint.x-1)>=0&&(p1.y= curPoint.y+2)<Y){
        ps.add(new Point(p1));
    }
    //判断是否可以走4的位置
    if ((p1.x= curPoint.x-2)>=0&&(p1.y= curPoint.y+1)<Y){
        ps.add(new Point(p1));
    }
    //判断是否可以走5的位置
    if ((p1.x= curPoint.x-2)>=0&&(p1.y= curPoint.y-1)>=0){
        ps.add(new Point(p1));
    }
    //判断是否可以走6的位置
    if ((p1.x=curPoint.x-1)>=0&&(p1.y= curPoint.y-2)>=0){
        ps.add(new Point(p1));
    }
    //判断是否可以走7的位置
    if ((p1.x= curPoint.x+1)<X&&(p1.y= curPoint.y-2)>=0){
        ps.add(new Point(p1));
    }

    return ps;
}

（3）编写核心算法，遍历棋盘，如果遍历成功就把finished设置为true，并且马儿走的每一步step记录到chessBoard

//编写核心算法，遍历棋盘，如果遍历成功就把finished设置为true
//并且马儿走的每一步step记录到chessBoard
//该方法使用了递归注意分析！！！
public static void traversalChessBoard(int[][] chessBoard,int row,int col,int step){
    //先记录step到chessBoard
    chessBoard[row][col]=step;
    //把这个位置设置成已访问
    visited[row*X+col]=true;
    //获取当前位置可以走的位置有哪些？
    ArrayList<Point> ps = next(new Point(col, row));//X 表示col列	Y表示row行
    //遍历
    while(!ps.isEmpty()){    //判断是否为空，是的话返回true
        //取出当前这个ps的第一个位置
        Point p = ps.remove(0); //remove 是删除取出
        //判断该点是否走过，没有话递归
        if (!visited[p.y*X+p.x]){
            traversalChessBoard(chessBoard,p.y,p.x,step+1);
        }
    }

    //当退出while循环，查看是否遍历成功
    if (step<X*Y&&!finished){
        //重置棋盘
        chessBoard[row][col]=0;
        visited[row*X+col]=false;
    }else {
        finished=true;
    }
}

（4）编写main方法

public static void main(String[] args) {
    int row=5;
    int col=5;
    long start = System.currentTimeMillis();
    traversalChessBoard(chessBoard,row-1,col-1,1);
    long end = System.currentTimeMillis();
    System.out.println("执行时间="+(end-start));
    //输出这个棋盘的情况
    for(int rows[] : chessBoard){
        for (int step:rows){    //step表示 该位置是马儿应该走的第几步？
            System.out.print(step+"\t");
        }
        System.out.println();
    }
}

在这里插入图片描述

3、算法优化（贪心算法）

优化思路：编写一个核心算法对ps集合进行排序(从小到大，目的是找出下一个位置能走的路较少的方法，能够减少回溯的次数)。

在这里插入图片描述

下面我们进行代码的优化:(编写了一个对ps集合排序的核心算法和在遍历时先排序在进行取出)

package com;

import java.awt.*;
import java.nio.channels.Pipe;
import java.util.ArrayList;
import java.util.Comparator;

/**
 * @author D
 * @version 1.0
 * @project qishizhouyou
 * @description 马踏棋盘
 * @date 2024/5/28 20:54:06
 */
public class HorseChessBoard {
    private static int X=6; //表示col列
    private static int Y=6; //表示row行
    private static int[][] chessBoard=new int[Y][X];    //棋盘
    private static boolean[] visited=new boolean[X*Y];  //记录某个位置是否走过
    private static boolean finished=false;  //记录马儿是否遍历完棋盘

    public static void main(String[] args) {
        int row=2;
        int col=2;
        long start = System.currentTimeMillis();
        traversalChessBoard(chessBoard,row-1,col-1,1);
        long end = System.currentTimeMillis();
        System.out.println("执行时间="+(end-start));
        //输出这个棋盘的情况
        for(int rows[] : chessBoard){
            for (int step:rows){    //step表示 该位置是马儿应该走的第几步？
                System.out.print(step+"\t");
            }
            System.out.println();
        }
    }

    //编写核心算法，对ps集合进行排序
    public static void sort(ArrayList<Point> ps){
        ps.sort(new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                return (next(o1).size()-next(o2).size());
            }
        });
    }

    //编写核心算法，遍历棋盘，如果遍历成功就把finished设置为true
    //并且马儿走的每一步step记录到chessBoard
    public static void traversalChessBoard(int[][] chessBoard,int row,int col,int step){
        //先记录step到chessBoard
        chessBoard[row][col]=step;
        //把这个位置设置成已访问
        visited[row*X+col]=true;
        //获取当前位置可以走的位置有哪些？
        ArrayList<Point> ps = next(new Point(col, row));//X 表示col列
        //遍历
        while(!ps.isEmpty()){    //判断是否为空，是的话返回true
            //对ps进行排序
            sort(ps);
            //取出当前这个ps的第一个位置
            Point p = ps.remove(0); //remove 是删除取出
            //判断该点是否走过，没有话递归
            if (!visited[p.y*X+p.x]){
                traversalChessBoard(chessBoard,p.y,p.x,step+1);
            }
        }

        //当退出while循环，查看是否遍历成功
        if (step<X*Y&&!finished){
            //重置棋盘
            chessBoard[row][col]=0;
            visited[row*X+col]=false;
        }else {
            finished=true;
        }
    }

    //编写方法，可以获取当前位置，可以走的下一步的所有位置(Point表示 x,y)
    public static ArrayList<Point> next(Point curPoint){

        //创建一个ArrayList
        ArrayList<Point> ps = new ArrayList<>();

        //创建一个Point对象(点/位置)，准备放入到ps
        Point p1 = new Point();

        //判断在curPoint是否可以走如下位置，如果可以走，就将该点(Point)放入到ps
        //判断是否可以走0的位置
        if((p1.x=curPoint.x+2)<X&&(p1.y= curPoint.y-1)>=0){
            ps.add(new Point(p1));
        }
        //判断是否可以走1的位置
        if ((p1.x= curPoint.x+2)<X&&(p1.y= curPoint.y+1)<Y){
            ps.add(new Point(p1));
        }
        //判断是否可以走2的位置
        if ((p1.x= curPoint.x+1)<X&&(p1.y= curPoint.y+2)<Y){
            ps.add(new Point(p1));
        }
        //判断是否可以走3的位置
        if ((p1.x= curPoint.x-1)>=0&&(p1.y= curPoint.y+2)<Y){
            ps.add(new Point(p1));
        }
        //判断是否可以走4的位置
        if ((p1.x= curPoint.x-2)>=0&&(p1.y= curPoint.y+1)<Y){
            ps.add(new Point(p1));
        }
        //判断是否可以走5的位置
        if ((p1.x= curPoint.x-2)>=0&&(p1.y= curPoint.y-1)>=0){
            ps.add(new Point(p1));
        }
        //判断是否可以走6的位置
        if ((p1.x=curPoint.x-1)>=0&&(p1.y= curPoint.y-2)>=0){
            ps.add(new Point(p1));
        }
        //判断是否可以走7的位置
        if ((p1.x= curPoint.x+1)<X&&(p1.y= curPoint.y-2)>=0){
            ps.add(new Point(p1));
        }

        return ps;
    }
}