經常使用十大算法（十）— 踏棋盤算法

經常使用十大算法（十）— 踏棋盤算法

<!-- more -->

博客說明

文章所涉及的資料來自互聯網整理和我的總結，意在於我的學習和經驗彙總，若有什麼地方侵權，請聯繫本人刪除，謝謝！

介紹

• 馬踏棋盤算法也被稱爲騎士周遊問題
• 將馬隨機放在國際象棋的8×8棋盤Board0～7]的某個方格中，馬按走棋規則(馬走日字)進行移動。要求每一個方格只進入一次，走遍棋盤上所有64個方格

思路

• 馬踏棋盤問題(騎士周遊問題)其實是圖的深度優先搜索(DFS)的應用。
• 若是使用回溯（就是深度優先搜索）來解決，假如馬兒踏了53個點，如圖：走到了第53個，座標（1,0），發現已經走到盡頭，沒辦法，那就只能回退了，查看其餘的路徑，就在棋盤上不停的回溯…… ，

代碼實現

package com.atguigu.horse;

import java.awt.Point;
import java.util.ArrayList;
import java.util.Comparator;

public class HorseChessboard {

    private static int X; // 列
    private static int Y; // 行
    
    private static boolean visited[];
    private static boolean finished; 
    
    public static void main(String[] args) {
        X = 8;
        Y = 8;
        int row = 1; 
        int column = 1; 
        int[][] chessboard = new int[X][Y];
        visited = new boolean[X * Y];
        long start = System.currentTimeMillis();
        traversalChessboard(chessboard, row - 1, column - 1, 1);
        long end = System.currentTimeMillis();
        System.out.println("時間: " + (end - start));
        for(int[] rows : chessboard) {
            for(int step: rows) {
                System.out.print(step + "\t");
            }
            System.out.println();
        }
    }
    
    public static void traversalChessboard(int[][] chessboard, int row, int column, int step) {
        chessboard[row][column] = step;
        visited[row * X + column] = true; 
        ArrayList<Point> ps = next(new Point(column, row));
        sort(ps);
        while(!ps.isEmpty()) {
            Point p = ps.remove(0);
            if(!visited[p.y * X + p.x]) {
                traversalChessboard(chessboard, p.y, p.x, step + 1);
            }
        }
        if(step < X * Y && !finished ) {
            chessboard[row][column] = 0;
            visited[row * X + column] = false;
        } else {
            finished = true;
        }
    }
    

    public static ArrayList<Point> next(Point curPoint) {
        ArrayList<Point> ps = new ArrayList<Point>();
        Point p1 = new Point();
        if((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y -1) >= 0) {
            ps.add(new Point(p1));
        }
        if((p1.x = curPoint.x - 1) >=0 && (p1.y=curPoint.y-2)>=0) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y - 2) >= 0) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y - 1) >= 0) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x + 2) < X && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x + 1) < X && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x - 1) >= 0 && (p1.y = curPoint.y + 2) < Y) {
            ps.add(new Point(p1));
        }
        if ((p1.x = curPoint.x - 2) >= 0 && (p1.y = curPoint.y + 1) < Y) {
            ps.add(new Point(p1));
        }
        return ps;
    }

    //排序
    public static void sort(ArrayList<Point> ps) {
        ps.sort(new Comparator<Point>() {
            @Override
            public int compare(Point o1, Point o2) {
                int count1 = next(o1).size();
                int count2 = next(o2).size();
                if(count1 < count2) {
                    return -1;
                } else if (count1 == count2) {
                    return 0;
                } else {
                    return 1;
                }
            }
        });
    }
}

感謝

尚硅谷

以及勤勞的本身，我的博客，GitHub