马周游问题（Java实现）

马周游问题

1. 问题描述

在一个n*n的棋盘中的某个位置有一只马，如果它走n*n步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，试设计一个算法，从给定的起点出发，找出它的一条周游路线。

2. 回溯法的一般思路

对于用回溯法求解的问题，首先要将问题进行适当的转化，得出状态空间树。 这棵树的每条完整路径都代表了一种解的可能。通过深度优先搜索这棵树，枚举每种可能的解的情况；从而得出结果。但是，回溯法中通过构造约束函数，可以大大 提升程序效率，因为在深度优先搜索的过程中，不断的将每个解（并不一定是完整的，事实上这也就是构造约束函数的意义所在）与约束函数进行对照从而删除一些 不可能的解，这样就不必继续把解的剩余部分列出从而节省部分时间。

3. 求解问题的回溯算法描述

1.按顺时针方向搜索当前点的8个方向，如果没有走过的就摘取下来。

2.判断点的个数是否为0，否的继续执行3，为0转5

3.对摘下来的点进行打分，规制：入度少的为第一优先级，靠边缘的为第二优先级。

4.根据分数获取分数最少的点（分数少的优先）。转到1

5.判断栈中的保存的点是否为空，如果为空，退出程序。如果不为空，就退一步，转到1.

4. 算法实现的关键技巧

1.判断要走的下一个点还有多少个点可以到达这个点，少的优先。

2.条件1相同的话，靠边的先走。

3．不管输入的点是哪一个，都是从中间位置开始，最后通过位移算出从输入那个点的路径。（对于这点，很多人都是不明白，我也不明白那些人为什么不明白，其实是一个很简单的道理。因为你最后走出来的是一个回路，不管那个棋盘是怎样的，最后你肯定可以把它变成一个环，环的每一个结点就是由棋盘中的格子和步数组成，在不移动格子的情况下，对数字进行转圈，然后再按拆开的办法放回去就会发现数字已经移动了）废话多了

下面贴代码，代码有三部分组成，用的是面向对象的方法

KnightTourPro类 负责运行程序

MPoint类 棋盘格子

ShowInfoWindow类 负责显示运行后的效果

KinghtTourPro

package nom.auggie.Knight;

import java.awt.Point;
import java.util.Scanner;

import nom.auggie.Knight.gui.ShowInfoWindow;

public class KnightTourPro {

    static final int NO＿PASS = 0;
    /**
     * 代表8个方向，顺时针方向
     */
    private static final Point[] dirs = { new Point(-2, 1), new Point(-1, 2), new Point(1, 2),
            new Point(2, 1), new Point(2, -1), new Point(1, -2), new Point(-1, -2),
            new Point(-2, -1) };

    /**
     * 矩阵大小
     */
    private int size;

    /**
     * 栈指针
     */
    private int stackL = -1;

    /**
     * 记录开始点
     */
    private MPoint oPt = new MPoint();
    /**
     * 当前的步数
     */
    private int step = 1;

    /**
     * 点矩阵矩阵
     */
    private MPoint[][] mPath;

    /**
     * 当前点的位置
     */
    private MPoint lPoint;

    /**
     * 保存走过的点
     */
    private MPoint[] stackPoint;

    public KnightTourPro(int size) {
        this.size = size;
        this.mPath = new MPoint[size][size];
        for (int i = 0; i < mPath.length; i++) {
            for (int j = 0; j < mPath.length; j++) {
                mPath[i][j] = new MPoint(i, j);
                this.getPSScore(mPath[i][j]);
            }
        }
        this.stackPoint = new MPoint[size * size];
    }

    /**
     * 开始执行
     *
     * @return
     */
    public int[][] doWalk(int x, int y) {
        oPt.x = x;
        oPt.y = y;
        lPoint = new MPoint(x, y);
        stackPoint[++stackL] = this.lPoint;
        mPath[this.lPoint.x][this.lPoint.y].stepNum = step++;
        int i=0;
        do {
            if (!this.goNext()) {
                if (!this.goBack()) {
                    if(i==0){ this.debugPrint();i++;}
                    break;
                }
            }
            // debugPrint();
            if (step - 1 == size * size) {
                if (isComeBack()) break;
            }
        } while (true);
        if (step < 1) return null;
        return this.toIntMatrix();
    }

    private boolean isComeBack() {
        // System.out.println("isComeBack");
        int x = stackPoint[stackL].x;
        int y = stackPoint[stackL].y;
        for (int i = 0; i < 8; i++) {
            if ((x + dirs[i].x) == oPt.x && (y + dirs[i].y) == oPt.y) { return true; }
        }
        return false;
    }

    /**
     * 调试用的
     */
    private void debugPrint() {
        int[][] mPath = this.toIntMatrix();
        for (int[] i : mPath) {
            for (int j : i) {
                System.out.print(j + " ");
            }
            System.out.println();
        }
        System.out.println();
        // try {
        // Thread.sleep(1000);
        // } catch (InterruptedException e) {
        // // TODO Auto-generated catch block
        // e.printStackTrace();
        // }
    }

    private int[][] toIntMatrix() {
        int[][] matrix = new int[size][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                matrix[i][j] = this.mPath[i][j].stepNum;
            }
        }
        return matrix;
    }

    /**
     * 回退函数
     * @return
     */
    private boolean goBack() {
        if (this.stackL > 0) {
            stackPoint[stackL].stepNum = NO＿PASS;// 设置这个点没有走过
            stackPoint[stackL].cleanDirsState();// 设置路径没有走过
            this.lPoint = this.stackPoint[--stackL];// 退栈
            step--;
            return true;
        }
        return false;
    }

    /**
     * 获得下个最佳的点
     *
     * @param lPoint
     *            当前的点
     * @return
     */
    public boolean goNext() {
        MPoint[] ptsCanGo = new MPoint[8];// 临时存储那个方向可以去的点的序号
        // 保存方向的位置
        int j = 0;
        for (int i = 0; i < 8; i++) {
            if (isCanGo(lPoint, dirs[i])) {
                ptsCanGo[j] = mPath[lPoint.x + dirs[i].x][lPoint.y + dirs[i].y];// 获得可以走的点
                ptsCanGo[j].dirIndex = i;// 记录方向序号
                j++;
            }
        }
        if (j == 0) return false;// 没有下一个点,向前走失败
        int i = 0;
        if (ptsCanGo[i].equals(stackPoint[stackL])) i++;// 防止第一个为来点
        if (i > j) return false;// 表示唯一一个可以走的点为来点
        MPoint[] pts = new MPoint[8];
        // 判断点是否已经走过,没有走过的点保存在pts中
        int n = 0;
        int k = 0;
        for (k = 0; k < j; k++) {
            // 如果这个方向没有走过，并且你是来自这个方向的话
            if (!lPoint.dirs[ptsCanGo[k].dirIndex]) {
                pts[n] = ptsCanGo[k];
                this.getPScore(pts[n]);// 给点打分
                n++;
            }
        }
        if (n == 0) return false;// 所有点都走过了
        MPoint mVPoint = pts[0];
        for (int m = 1; m < n; m++) {
            if (mVPoint.compareWithValue(pts[m]) == -1) {
                mVPoint = pts[m];
            }
        }
        this.lPoint.dirs[mVPoint.dirIndex] = true;// 设置为已走过
        this.lPoint = mVPoint;
        lPoint.stepNum = step++;// 把步数存入点中
        stackPoint[++stackL] = lPoint;// 已走过，压入栈中
        return true;
    }

    /**
     * 给结点动态打分
     *
     * @param mp
     */
    public void getPScore(MPoint mp) {
        mp.firstValue =8;
        mp.firstValue = this.canGoCount(mp);
    }

    /**
     * 给结点静态打分，某个结点分配下来就是静态的分数不会变的
     *
     * @param mp
     *            要打分的点
     */

    public void getPSScore(MPoint mp) {
        mp.seconedValue = Integer.MAX_VALUE;

        int lengthHalf = mPath.length / 2;
        if (mp.x <= lengthHalf / 2) {
            mp.seconedValue += mp.x;
        } else {
            mp.seconedValue += (mPath.length-mp.x);
        }
        if (mp.y <= lengthHalf / 2) {
            mp.seconedValue += mp.y;
        } else {
            mp.seconedValue += (mPath.length-mp.y);
        }
//        System.out.println(mp.seconedValue);
    }

    /**
     * 获得结点的出度
     *
     * @param mp
     *            结点
     * @return
     */
    public int canGoCount(MPoint mp) {
        int count = 0;
        for (int i = 0; i < dirs.length; i++) {
            if (isCanGo(mp, dirs[i])) {
                count++;
            }
        }
        return count;
    }

    /**
     * 判断是否可以过去
     *
     * @param mp
     *            要判断的起点
     * @param dir
     *            代表方向的点
     * @return
     */
    public boolean isCanGo(MPoint mp, Point dir) {
        int x = mp.x + dir.x;
        int y = mp.y + dir.y;
        if (x < size && x >= 0 && y < size && y >= 0
                && mPath[x][y].stepNum == KnightTourPro.NO＿PASS) { return true; }
        return false;
    }

    public static void main(String[] args) {


        while (true) {
            Scanner scan = new Scanner(System.in);
            System.out.print("输入矩阵大小");
            int size = scan.nextInt();
            System.out.print("输入开始点\nx=");
            int x = scan.nextInt();
            System.out.print("y=");
            int y = scan.nextInt();
            KnightTourPro knight = new KnightTourPro(size);
            final int[][] mPath = knight.doWalk(x - 1, y - 1);
            if (mPath == null) {
                System.out.println("无解");
            }
            for (int[] i : mPath) {
                for (int j : i) {
                    System.out.print(j + " ");
                }
                System.out.println();
            }
            new Thread(){
                @Override
                public void run(){
                    ShowInfoWindow show = new ShowInfoWindow(mPath);
                    show.setVisible(true);
                    show.startAnimation();
                }
            }.start();
        }


    }
}

MPoint

package nom.auggie.Knight;

public class MPoint {

    /**
     * 过来对应方向的序号
     */
    public int dirIndex = -1;
    /**
     * 对应点的步数
     */
    public int stepNum = 0;
    /**
     * 棋盘坐标x
     */
    public int x;

    /**
     * 棋盘坐标y
     */
    public int y;

    /**
     * 点的第一价值价值
     */
    public int firstValue=8;

    /**
     * 第二价值
     */
    public int seconedValue=Integer.MAX_VALUE;

    /**
     * 点的8个方向,顺时针数,走过的就设置为true;
     */
    public boolean[] dirs = new boolean[8];

    public MPoint puls(MPoint mPoint) {
        return new MPoint(this.x + mPoint.x, this.y + mPoint.y);
    }

    /**
     * 比较价值，第一价值优先，
     *
     * @param p
     * @return 1 比p价值大，-1 比p价值小，0 价值相同
     */
    public int compareWithValue(MPoint p) {
        if (p == null) return -1;
        if (this.firstValue < p.firstValue) return 1;
        if (this.firstValue == p.firstValue) {
            if (this.seconedValue == p.seconedValue) return 0;
            return this.seconedValue < p.seconedValue ? 1 : -1;
        }
        return -1;
    }

    public void cleanDirsState() {
        for (int i = 0; i < dirs.length; i++) {
            dirs[i] = false;
        }
    }

    public MPoint(int x, int y, int fristValue, int seconedValue) {
        this.x = x;
        this.y = y;
        this.firstValue = fristValue;
        this.seconedValue = seconedValue;
    }

    public MPoint() {
    }

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

    public MPoint(MPoint p) {
        x = p.x;
        y = p.y;
        firstValue = p.firstValue;
        seconedValue = p.seconedValue;
    }

    /**
     * 设定点的坐标
     *
     * @param p
     */
    public void setMPoint(MPoint p) {
        this.x = p.x;
        this.y = p.y;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) return false;
        if (obj instanceof MPoint) {
            MPoint mp = (MPoint) obj;
            if (mp.x == this.x && mp.y == this.y) return true;
        }
        return false;
    }
}

ShowInfoWindow

package nom.auggie.Knight.gui;

import java.awt.Color;

public class ShowInfoWindow extends JFrame {

    public static final int FREQUENCY = 2;
    public static final int DELAY_TIME=50;
    private Point[] pts;
    private int[][] matrix;
    private JPanel contentPane;
    private JLabel[][] jLabels;
    int[][] in = new int[50][50];

    /**
     * Create the frame.
     */
//    public ShowInfoWindow() {
    public ShowInfoWindow(int[][] matrix) {
        this.matrix = matrix;
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 0, 1024, 768);
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        GridLayout gLayout = new GridLayout(matrix.length,matrix.length);
        int padding = 3;
        gLayout.setHgap(padding);
        gLayout.setVgap(padding);
        contentPane.setLayout(gLayout);
        jLabels = new JLabel[matrix.length][matrix.length];
        for(int i=0;i<jLabels.length;i++){
            for(int j=0;j<jLabels[i].length;j++){
                jLabels[i][j] = new JLabel();
                jLabels[i][j].setHorizontalAlignment(SwingConstants.CENTER);
                jLabels[i][j].setOpaque(true);
                contentPane.add(jLabels[i][j]);
            }
        }
        pts = new Point[matrix.length*matrix.length];
        this.analyseMatrix();
    }


    public void startAnimation(){
        for(int i=0;i<pts.length;i++){
            this.labelAnim(pts[i].x, pts[i].y);
        }
    }



    /**
     * 渲染label
     * @param indexX 对应的横坐标
     * @param indexY 纵坐标
     */
    public void labelAnim(int indexX,int indexY){
        JLabel aLab = jLabels[indexX][indexY];
        aLab.setText(matrix[indexX][indexY]+"");
        for(int i=0;i<FREQUENCY;i++){
            aLab.setBackground(Color.BLUE);
            aLab.updateUI();
            try {
                Thread.sleep(DELAY_TIME);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            aLab.setBackground(Color.red);
            try {
                Thread.sleep(DELAY_TIME);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    /**
     * 分析矩阵
     */
    public void analyseMatrix(){
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix.length;j++){
                pts[matrix[i][j]-1] = new Point(i,j);
            }
        }
    }

}

运行效果图（8*8）

1. 自我评价及心得体会

程序实现的还不够好，理论上使用的启发式搜索的话应该可以跑到3000*3000的但是现在还只是能跑到26*26，和理论差太远了。还需努力。

心得体会：不用启发式的最多这是能搜到8*8而已，使用启发式立刻到26*26了差别很大。