骑士走棋盘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

FOR(m = 2; m <= 总步数; m++) [
    测试下一步可以走的八个方向，记录可停留的格数count。

    IF(count == 0) [
        游历失败
    ]
    ELSE IF(count == 1) [
        下一步只有一个可能
    ]
    ELSE [
        找出下一步的出路最少的格子
       如果出路值相同，则选第一个遇到的出路。 
    ]

    走最少出路的格子，记录骑士的新位置。  
] 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

#include <stdio.h> 

int board[8][8] = {0}; 

int main(void) {
    int startx, starty;
    int i, j;

    printf("输入起始点：");
    scanf("%d %d", &startx, &starty);

    if(travel(startx, starty)) {
        printf("游历完成！\n");
    }
    else {
        printf("游历失败！\n");
    }

    for(i = 0; i < 8; i++) {
        for(j = 0; j < 8; j++) {
            printf("%2d ", board[i][j]);
        }
        putchar('\n');
    }

    return 0;
} 

int travel(int x, int y) {
    // 对应骑士可走的八个方向
    int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
    int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};

    // 测试下一步的出路
    int nexti[8] = {0};
    int nextj[8] = {0};

    // 记录出路的个数
    int exists[8] = {0};

    int i, j, k, m, l;
    int tmpi, tmpj;
    int count, min, tmp;

    i = x;
    j = y;

    board[i][j] = 1;

    for(m = 2; m <= 64; m++) {
        for(l = 0; l < 8; l++) {
            exists[l] = 0;
        }

        l = 0;

        // 试探八个方向
        for(k = 0; k < 8; k++) {
            tmpi = i + ktmove1[k];
            tmpj = j + ktmove2[k];

            // 如果是边界了，不可走
            if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)
                continue;

            // 如果这个方向可走，记录下来
            if(board[tmpi][tmpj] == 0) {
                nexti[l] = tmpi;
                nextj[l] = tmpj;
                // 可走的方向加一个
                l++;
            }
        }

        count = l;

        // 如果可走的方向为0个，返回
        if(count == 0) {
            return 0;
        }
        else if(count == 1) {
            // 只有一个可走的方向
            // 所以直接是最少出路的方向
            min = 0;
        }
        else {
            // 找出下一个位置的出路数
            for(l = 0; l < count; l++) {
                for(k = 0; k < 8; k++) {
                    tmpi = nexti[l] + ktmove1[k];
                    tmpj = nextj[l] + ktmove2[k];

                    if(tmpi < 0 || tmpj < 0 || 
                       tmpi > 7 || tmpj > 7) {
                        continue;
                    }

                    if(board[tmpi][tmpj] == 0)
                        exists[l]++;
                }
            }

            tmp = exists[0];
            min = 0;

            // 从可走的方向中寻找最少出路的方向
            for(l = 1; l < count; l++) {
                if(exists[l] < tmp) {
                    tmp = exists[l];
                    min = l;
                }
            }
        }

        // 走最少出路的方向
        i = nexti[min];
        j = nextj[min];
        board[i][j] = m;
    }

    return 1;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

public class Knight {
    public boolean travel(int startX, 
                          int startY, int[][] board) {
        // 对应骑士可走的八个方向
        int[] ktmove1 = {-2, -1, 1, 2, 2, 1, -1, -2};
        int[] ktmove2 = {1, 2, 2, 1, -1, -2, -2, -1};
        
        // 下一步出路的位置
        int[] nexti = new int[board.length];
        int[] nextj = new int[board.length];
        
        // 记录出路的个数
        int[] exists = new int[board.length];
        
        int x = startX;
        int y = startY;
        
        board[x][y] = 1;
        
        for(int m = 2; m <= Math.pow(board.length, 2); m++) {
            for(int k = 0; k < board.length; k++) {
                exists[k] = 0;
            }
            
            int count = 0;
            // 试探八个方向
            for(int k = 0; k < board.length; k++) {
                int tmpi = x + ktmove1[k];
                int tmpj = y + ktmove2[k];
                
                // 如果是边界了，不可走
                if(tmpi < 0 || tmpj < 0 || 
                   tmpi > 7 || tmpj > 7) {
                    continue;
                }
                
                // 如果这个方向可走，记录下来
                if(board[tmpi][tmpj] == 0) {
                    nexti[count] = tmpi;
                    nextj[count] = tmpj;
                    // 可走的方向加一个
                    count++;
                }
            }
            
            int min = -1;
            if(count == 0) {
                return false;
            }
            else if(count == 1) {
                min = 0;
            }
            else {
                // 找出下一个位置的出路数
                for(int l = 0; l < count; l++) {
                    for(int k = 0; k < board.length; k++) {
                        int tmpi = nexti[l] + ktmove1[k];
                        int tmpj = nextj[l] + ktmove2[k];

                        if(tmpi < 0 || tmpj < 0 || 
                           tmpi > 7 || tmpj > 7) {
                            continue;
                        }

                        if(board[tmpi][tmpj] == 0)
                            exists[l]++;
                    }
                }

                int tmp = exists[0];
                min = 0;

                // 从可走的方向中寻找最少出路的方向
                for(int l = 1; l < count; l++) {
                    if(exists[l] < tmp) {
                        tmp = exists[l];
                        min = l;
                    }
                }
            }
            
            // 走最少出路的方向
            x = nexti[min];
            y = nextj[min];
            board[x][y] = m;
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        int[][] board = new int[8][8];
        Knight knight = new Knight();
        
        if(knight.travel(
                Integer.parseInt(args[0]), 
                Integer.parseInt(args[1]), board)) {
            System.out.println("游历完成！");
        }
        else {
            System.out.println("游历失败！");
        }
        
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[0].length; j++) {
                if(board[i][j] < 10) {
                    System.out.print(" " + board[i][j]);
                }
                else {
                    System.out.print(board[i][j]);
                }
                System.out.print(" ");
            }
            System.out.println();
        }
    }
}