關於馬踏棋盤的思路，大致演算法如下：
1.貪心演算法（找最少的出路，因為最少的出路往往不用進行多次選擇，貪 心演算法的主要理念是：最拿走的路是最好的路）；
2.深度搜索：主要的演算法是深入進去探索，但執行時間有點長，效率有點低，但搜尋面比較廣泛；
3.回溯：當搜尋到該點沒有出路時，就退回到上一個點的位置；
4.遞迴：馬踏棋盤主要用到是遞迴的方法，遞迴迴圈；

閒話不多說，來看看程式碼吧。。。。。

package ma;

import java.util.Scanner;

public class ma {

    //馬在一個點時，能走的方向有8個；
    static final
 
 int[] fx = {-1,-2,-2,-1,1,2,2,1};
    static final int[] fy={2,1,-1,-2,-2,-1,1,2};
    static final int N =8;              //棋盤的大小；
    static int[][] board = new int[N][N];//馬走的棋盤；

    class manode{
        int x;          //x座標
        int y;          //y座標
        int way;        //該點有多少種走法； 
    }                   //定義一個內部類，馬所在點的資訊；
 


    int wayout(int x,int y){
        int tx,ty;
        int count = 0;
        if(x<0||y<0||x>=N||y>=N||board[x][y]>0){
            return -1;
        }               //當點超出邊界或者所在的點的值不為0時，返回-1；
        for(int i = 0;i<N;i++){
            tx = x+fx[i];
            ty = y+fy[i];
            if
 
(tx<0||ty<0||tx>=N||ty>=N){
                continue;//如果點的另一個點超出邊界時，就continue；
            }
            if(board[tx][ty] == 0){
                count++;//否則計數器計數;
            }
        }
        return count;
    }//計算該點的走法有多少種；

    void sort(manode[] hn,int n){
        int i,j,k;
        manode temp;    //臨時物件，用來排序交換；
        for(i=0;i<n;i++){
            for(k=i,j=i+1;j<n;j++){
                if(hn[j].way<hn[k].way)
                    k=j;
            }
            if(k>i){
                temp = hn[i];
                hn[i] = hn[k];
                hn[k] = temp;
            }
        }
    }//將走法的數量進行排序，將最少的走法放在陣列的頭；

    void dfs(int x,int y,int count){
        int i,tx,ty;
        manode[] t = new manode[N];
        if(count >N*N){
            output();
            return;
        }   //當count計數器超過64時，列印輸出;

        for(i=0;i<N;i++){
            tx = x+fx[i];
            ty = y+fy[i];
            manode h = new manode();
            t[i]=h;
            t[i].x = tx;
            t[i].y = ty;
            t[i].way = wayout(tx,ty);
        }
        sort(t,N);

        for(i = 0;t[i].way<0;i++)
            ;
        for(;i<N;i++){
            tx = t[i].x;
            ty = t[i].y;
            board[tx][ty] = count;
            dfs(tx,ty,count+1);
            board[tx][ty] = 0;//遇到死路時，回退回去，並將其變成0；
        }
    }//深度搜索與回溯演算法；

    public static void main(String[] args) {
        int x,y;
        Scanner input = new Scanner(System.in);
        System.out.println("please input x,y:");
        x = input.nextInt();
        y = input.nextInt();
        ma test = new ma();
        board[x][y]=1;
        test.dfs(x, y, 2);
    }

    void output(){
        for(int i = N-1;i>=0;i--){
            for(int j = 0;j<N;j++){
                System.out.printf("%d\t",board[i][j]);
            }
            System.out.printf("\n\n\n");
        }
        System.exit(0);
    }       //列印輸出函式；
}

that is all…end…..thank you….