马踏棋盘 算法 自己总结自己理解如有不对请指点，总感觉差点

奥普瓯江

时间库我占时没用

1. #include <stdio.h>
   
2. #include <time.h>
   
3. 
   
4. #define X 6   //建立网格数量
   
5. #define Y 6
   
6. 
   
7. int chess[X][Y];        //建立棋盘
   
8. 
   
9. int Function_Chess(int x, int y, int step);        //马踏棋盘程序
   
10. int Every_Chess(int *x1, int *y1, int count);        //每一步运行的程序count选项
    
11. void Print_Chess();                                        //打印棋盘
    
12. 
    
13. void Print_Chess()
    
14. {
    
15.         int i, j;
    
16.         for (i = 0; i < X; i++)
    
17.         {
    
18.                 for (j = 0; j < Y; j++)
    
19.                 {
    
20.                         printf("%3d", chess[i][j]);
    
21.                 }
    
22.                 putchar('\n');
    
23.         }
    
24. 
    
25. }
    
26. 
    
27. 
    
28. int Every_Chess(int *x1, int *y1, int count)//因为要更x1与y1中的数值所以用指针
    
29. {
    
30.         switch (count)
    
31.         {
    
32.         case 0:        //上左
    
33.                 {
    
34.                         if (*x1-1 >= 0 && *y1-2 >= 0 && chess[*x1-1][*y1-2] == 0)
    
35.                         {
    
36.                                 *x1 -= 1;
    
37.                                 *y1 -= 2;
    
38.                                 return 1;
    
39.                         }       
    
40.                 }
    
41.                 break;
    
42.         case 1:        //上右
    
43.                 {
    
44.                         if (*x1+1 <= X-1 && *y1-2 >= 0 && chess[*x1+1][*y1-2] == 0)
    
45.                         {
    
46.                                 *x1 += 1;
    
47.                                 *y1 -= 2;
    
48.                                 return 1;
    
49.                         }       
    
50.                 }
    
51.                 break;
    
52.         case 2:        //右上
    
53.                 {
    
54.                         if (*x1+2 <= X-1 && *y1-1 >= 0 && chess[*x1+2][*y1-1] == 0)
    
55.                         {
    
56.                                 *x1 += 2;
    
57.                                 *y1 -= 1;
    
58.                                 return 1;
    
59.                         }       
    
60.                 }
    
61.                 break;
    
62.         case 3:        //右下
    
63.                 {
    
64.                         if (*x1+2 <= X-1 && *y1+1 <= Y-1 && chess[*x1+2][*y1+1] == 0)
    
65.                         {
    
66.                                 *x1 += 2;
    
67.                                 *y1 += 1;
    
68.                                 return 1;
    
69.                         }       
    
70.                 }
    
71.                 break;
    
72.         case 4:        //下右
    
73.                 {
    
74.                         if (*x1+1 <= X-1 && *y1+2 <= Y-1 && chess[*x1+1][*y1+2] == 0)
    
75.                         {
    
76.                                 *x1 += 1;
    
77.                                 *y1 += 2;
    
78.                                 return 1;
    
79.                         }       
    
80.                 }
    
81.                 break;
    
82.         case 5:        //下左
    
83.                 {
    
84.                         if (*x1-1 >= 0 && *y1+2 <= Y-1 && chess[*x1-1][*y1+2] == 0)
    
85.                         {
    
86.                                 *x1 -= 1;
    
87.                                 *y1 += 2;
    
88.                                 return 1;
    
89.                         }       
    
90.                 }
    
91.                 break;
    
92.         case 6:        //左下
    
93.                 {
    
94.                         if (*x1-2 >= 0 && *y1+1 <= Y-1 && chess[*x1-2][*y1+1] == 0)
    
95.                         {
    
96.                                 *x1 -= 2;
    
97.                                 *y1 += 1;
    
98.                                 return 1;
    
99.                         }       
    
100.                 }
     
101.                 break;
     
102.         case 7:        //左上
     
103.                 {
     
104.                         if (*x1-2 >= 0 && *y1-1 >= 0 && chess[*x1-2][*y1-1] == 0)
     
105.                         {
     
106.                                 *x1 -= 2;
     
107.                                 *y1 -= 1;
     
108.                                 return 1;
     
109.                         }       
     
110.                 }
     
111.                 break;
     
112.         default:
     
113.                 break;
     
114.         }
     
115.         return 0;
     
116. }
     
117. 
     
118. 
     
119. int Function_Chess(int x, int y, int step)       
     
120. {
     
121.         int x1 = x, y1 = y;                        //临时变量
     
122.         int flag = 0, count = 0;        //flag 返回值的存储，count选项的存储
     
123.        
     
124.         chess[x][y] = step;                        //把step中的数值传给棋盘
     
125.         if (step == X*Y)                        //打印棋盘中的数据
     
126.         {
     
127.                 Print_Chess();
     
128.                 return 1;
     
129.         }
     
130.         //再此段中下面这句话可以不需要，经过测试不会对结果产生影响
     
131.         //flag = Every_Chess(&x1, &y1, count);        //首次运行Every函数判断第一步是否可行选项值为0，因为要更改x1和y1的值所以用地址输入
     
132.         while (flag == 0 && count < 8)
     
133.         {
     
134.                 //count++;
     
135.                 flag = Every_Chess(&x1, &y1, count);        //如果第一步运行失败返回0就对另外七个方向进行判断
     
136.                 count++;
     
137.         }
     
138. 
     
139.         while (flag)                //如果flag返回来的是1则运行西面的程序
     
140.         {
     
141.                 if (Function_Chess(x1, y1, step+1))                //此处为递归，递归在归来的时候不是直接跳转到本函数结尾而是继续往下走一直往下执行，在本函数中flag等于0是递归返回得其中一个条件但是他不是立刻返回而是先执行if(flag == 0)然后一直到到“}” 在进行返回
     
142.                 {
     
143.                         return 1;
     
144.                 }
     
145. 
     
146.                 x1 = x;
     
147.                 y1 = y;
     
148.                 count++; //这个是保证不能再原有基础上再次进行，运算而是对剩余部分进行运算，比如递归时进入站中的时1当他被归运算时及加一进行像下一个项进行运算
     
149. 
     
150.                 flag = Every_Chess(&x1, &y1, count);        //此处如果不添加将在返回时没有办法从新计算因为返回时自带的count值有可能为1或者更大递归返回是整体储存
     
151.                 while (flag == 0 && count < 8)
     
152.                 {
     
153.                         //count++;
     
154.                         flag = Every_Chess(&x1, &y1, count);        //如果第一步运行失败返回0就对另外七个方向进行判断
     
155.                         count++;
     
156.                 }
     
157. 
     
158.         }
     
159.         if (flag == 0)                //如果失败及x与y标志位的数值还原为0
     
160.         {
     
161.                 chess[x][y] = 0;
     
162.         }
     
163.         return 0;        //如果不加这条再Visual中他自动返回0也是可以的这是个结束语，如果想执行if(Function_chess)的return 1；就必须执行该程序
     
164. 
     
165. }
     
166. int main()
     
167. {
     
168.         int i, j;
     
169.         for (i = 0; i < X; i++)        //初始化棋盘
     
170.         {
     
171.                 for (j = 0; j < Y; j++)
     
172.                 {
     
173.                         chess[i][j] = 0;
     
174.                 }
     
175.         }
     
176. 
     
177. 
     
178.         //运行马踏棋盘程序
     
179.         if(!Function_Chess(6-1, 6-1, 0))  //如果fuchtion函数运行结束后返回来的数值是0则打印print如果返回来的数值是1则结束程序，因为if内包含一个叹号取相反的意思
     
180.         {
     
181.                 printf("马踏棋盘失败了！");
     
182.         }
     
183. 
     
184.        
     
185.         return 0;
     
186. }

复制代码