骑士

Code:

1. #include <stdio.h>    
2. int board[8][8] = {0};   
3.   
4. int travel(int x, int y) ;   
5.     
6. int main(void)    
7. {       
8.     int startx, starty;       
9.     int i, j;       
10.     printf("輸入起始點：");       
11.     scanf("%d %d", &startx, &starty);       
12.     if(travel(startx, starty))    
13.     {           
14.         printf("遊歷完成！/n");       
15.     }       
16.     else    
17.     {           
18.         printf("遊歷失敗！/n");       
19.     }       
20.     for(i = 0; i < 8; i++)    
21.     {           
22.         for(j = 0; j < 8; j++)    
23.         {               
24.             printf("%2d ", board[i][j]);           
25.         }           
26.         putchar('/n');   
27.     }   
28.         
29.     return 0;   
30.  }    
31.  int travel(int x, int y)    
32.  {       
33.     // 對應騎士可走的八個方向       
34.      int ktmove1[8] = {-2, -1, 1, 2, 2, 1, -1, -2};       
35.      int ktmove2[8] = {1, 2, 2, 1, -1, -2, -2, -1};       
36.      // 測試下一步的出路       
37.      int nexti[8] = {0};       
38.      int nextj[8] = {0};       
39.      // 記錄出路的個數       
40.      int exists[8] = {0};       
41.      int i, j, k, m, l;       
42.      int tmpi, tmpj;       
43.      int count, min, tmp;       
44.      i = x;       
45.      j = y;       
46.      board[i][j] = 1;       
47.      for(m = 2; m <= 64; m++)    
48.      {           
49.         for(l = 0; l < 8; l++)    
50.         {               
51.             exists[l] = 0;           
52.         }           
53.         l = 0;           
54.         // 試探八個方向           
55.         for(k = 0; k < 8; k++)   
56.         {               
57.             tmpi = i + ktmove1[k];               
58.             tmpj = j + ktmove2[k];              
59.              // 如果是邊界了，不可走               
60.              if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)                   
61.                 continue;               
62.              // 如果這個方向可走，記錄下來               
63.              if(board[tmpi][tmpj] == 0)    
64.              {                   
65.                 nexti[l] = tmpi;                   
66.                 nextj[l] = tmpj;                   
67.                 // 可走的方向加一個                   
68.                  l++;              
69.              }           
70.          }           
71.          count = l;           
72.          // 如果可走的方向為0個，返回           
73.          if(count == 0)    
74.          {               
75.             return 0;           
76.          }           
77.          else if(count == 1)    
78.          {               
79.             // 只有一個可走的方向               
80.              // 所以直接是最少出路的方向              
81.               min = 0;           
82.          }          
83.          else    
84.          {              
85.             // 找出下一個位置的出路數               
86.                for(l = 0; l < count; l++)    
87.                {                   
88.                     for(k = 0; k < 8; k++)    
89.                     {                       
90.                        tmpi = nexti[l] + ktmove1[k];                       
91.                        tmpj = nextj[l] + ktmove2[k];                       
92.                        if(tmpi < 0 || tmpj < 0 || tmpi > 7 || tmpj > 7)    
93.                        {                           
94.                           continue;                       
95.                        }                       
96.                        if(board[tmpi][tmpj] == 0)                           
97.                                 exists[l]++;                   
98.                      }               
99.                  }               
100.                  tmp = exists[0];               
101.                  min = 0;               
102.                  // 從可走的方向中尋找最少出路的方向               
103.                  for(l = 1; l < count; l++)    
104.                  {                   
105.                     if(exists[l] < tmp)    
106.                      {                       
107.                         tmp = exists[l];                       
108.                         min = l;                   
109.                      }               
110.                  }           
111.              }           
112.              // 走最少出路的方向           
113.              i = nexti[min];           
114.              j = nextj[min];           
115.              board[i][j] = m;       
116.      }       
117.      return 1;   
118.  }