自己试着写了一下马踏棋盘，看了好几个小时了。真的看不出问题

御坂19090

这个是我的代码

1. #include <stdio.h>
   
2. #include <time.h>
   
3. 
   
4. #define X 8
   
5. #define Y 8
   
6. 
   
7. int chess[X][Y];    //记录棋盘
   
8. 
   
9. void print() {
   
10.     int i, j;
    
11.     for (i = 0; i < X; i++) {
    
12.         for (j = 0; j < Y; j++) {
    
13.             printf("%2d  ", chess[i][j]);
    
14.         }
    
15.         putchar('\n');
    
16.     }
    
17. }
    
18. 
    
19. //根据xy坐标，判断指定位置可不可走,如果可走改变传入的x y坐标
    
20. int decide_next(int* px, int* py, int count) {
    
21.     int x = *px, y = *py;
    
22. 
    
23.     switch (count) {
    
24.     case 0:
    
25.         if (x + 2 < X && y - 1 >= 0 && chess[x + 2][y - 1] == 0) {
    
26.             *px = x + 2;
    
27.             *py = y - 1;
    
28.             return 1;
    
29.         }
    
30.         break;
    
31.     case 1:
    
32.         if (x + 2 < X && y + 1 < Y && chess[x + 2][y + 1] == 0) {
    
33.             *px = x + 2;
    
34.             *py = y + 1;
    
35.             return 1;
    
36.         }
    
37.         break;
    
38.     case 2:
    
39.         if (x + 1 < X && y - 2 >= 0 && chess[x + 1][y - 2] == 0) {
    
40.             *px = x + 1;
    
41.             *py = y - 2;
    
42.             return 1;
    
43.         }
    
44.         break;
    
45.     case 3:
    
46.         if (x + 1 < X && y + 2 < Y && chess[x + 1][y + 2] == 0) {
    
47.             *px = x + 1;
    
48.             *py = y + 2;
    
49.             return 1;
    
50.         }
    
51.         break;
    
52.     case 4:
    
53.         if (x - 2 >= 0 && y - 1 >= 0 && chess[x - 2][y - 1] == 0) {
    
54.             *px = x - 2;
    
55.             *py = y - 1;
    
56.             return 1;
    
57.         }
    
58.         break;
    
59.     case 5:
    
60.         if (x - 2 >= 0 && y + 1 < Y && chess[x - 2][y + 1] == 0) {
    
61.             *px = x - 2;
    
62.             *py = y + 1;
    
63.             return 1;
    
64.         }
    
65.         break;
    
66.     case 6:
    
67.         if (x - 1 >= 0 && y - 2 >= 0 && chess[x - 1][y - 2] == 0) {
    
68.             *px = x - 1;
    
69.             *py = y - 2;
    
70.             return 1;
    
71.         }
    
72.         break;
    
73.     case 7:
    
74.         if (x - 1 >= 0 && y + 2 < Y && chess[x - 1][y + 2] == 0) {
    
75.             *px = x - 1;
    
76.             *py = y + 2;
    
77.             return 1;
    
78.         }
    
79.         break;
    
80.     default:
    
81.         break;
    
82.     }
    
83.     return 0;
    
84. }
    
85. // 获得棋子的路径
    
86. int setHorse(int x, int y, int tag){
    
87.     int x1, y1, resule = 0, count = 0;
    
88. 
    
89.     // tag记录轨迹
    
90.     chess[x][y] = tag;
    
91.     if (tag == 62) {
    
92.         tag = 62;
    
93.     }
    
94.     // 如果tag等于64打印棋盘
    
95.     if (tag == X * Y) {
    
96.         return 1;
    
97.     }
    
98. 
    
99.     // 递归进入下一个坐标
    
100.     while (count < 8){
     
101.         
     
102.         // 尝试路径是否能走
     
103.         resule = decide_next(&x1, &y1, count);
     
104.         if (!resule) {
     
105.             count += 1;
     
106.         }
     
107.         for (x1 = x, y1 = y; resule == 0 && count < 8; count += 1) {
     
108.             resule = decide_next(&x1, &y1, count);
     
109.         }
     
110.         // 返回1表示成功找到路径；对新的点进行尝试
     
111.         if (setHorse(x1, y1, tag + 1))
     
112.         {
     
113.             return 1;
     
114.         }
     
115.         // 如果失败并且有没尝试的路径，回到上一步重新尝试
     
116.         count += 1;
     
117.     }
     
118.     // 如果全部路径都尝试过，并且没有返回1，说明这个点没有可行的路径，回到上一步并且去除痕迹
     
119.     chess[x][y] = 0;
     
120. 
     
121.     return 0;
     
122. }
     
123. 
     
124. int main(void){
     
125.     int i, j, x, y;
     
126.     clock_t start, finish;
     
127. 
     
128.     for (i = 0; i < X; i++) {
     
129.         for (j = 0; j < Y; j++){
     
130.             chess[i][j] = 0;
     
131.         }
     
132.     }
     
133. 
     
134.     // 获取初始坐标；建议(2,0)
     
135.     printf("请输入初始坐标(x y):");
     
136.     scanf_s("%d %d", &x, &y);
     
137. 
     
138.     // 记录开始时间
     
139.     start = clock();
     
140. 
     
141.     if (setHorse(x, y, 1)) {
     
142.         print();
     
143.     }
     
144.     else{
     
145.         printf("可惜无解！\n");
     
146.     }
     
147. 
     
148.     // 记录结束时间
     
149.     finish = clock();
     
150. 
     
151.     printf("\n本次计算一共耗时∶%f秒\n", (double)(finish - start) / CLOCKS_PER_SEC);
     
152. 
     
153.     return 0;
     
154. }

复制代码

这一段代码

1. // 获得棋子的路径
   
2. int setHorse(int x, int y, int tag){
   
3.     int x1, y1, resule = 0, count = 0;
   
4. 
   
5.     // tag记录轨迹
   
6.     chess[x][y] = tag;
   
7.     if (tag == 62) {
   
8.         tag = 62;
   
9.     }
   
10.     // 如果tag等于64打印棋盘
    
11.     if (tag == X * Y) {
    
12.         return 1;
    
13.     }
    
14. 
    
15.     // 递归进入下一个坐标
    
16.     while (count < 8){
    
17.         
    
18.         // 尝试路径是否能走
    
19.         resule = decide_next(&x1, &y1, count);
    
20.         if (!resule) {
    
21.             count += 1;
    
22.         }
    
23.         for (x1 = x, y1 = y; resule == 0 && count < 8; count += 1) {
    
24.             resule = decide_next(&x1, &y1, count);
    
25.         }
    
26.         // 返回1表示成功找到路径；对新的点进行尝试
    
27.         if (setHorse(x1, y1, tag + 1))
    
28.         {
    
29.             return 1;
    
30.         }
    
31.         // 如果失败并且有没尝试的路径，回到上一步重新尝试
    
32.         count += 1;
    
33.     }
    
34.     // 如果全部路径都尝试过，并且没有返回1，说明这个点没有可行的路径，回到上一步并且去除痕迹
    
35.     chess[x][y] = 0;
    
36. 
    
37.     return 0;
    
38. }

复制代码

改成

1. nt setHorse(int x, int y, int tag)
   
2. {
   
3.         int x1 = x, y1 = y, flag = 0, count = 0;
   
4. 
   
5.         // tag记录轨迹
   
6.         chess[x][y] = tag;
   
7.         // 如果tag等于64退出程序
   
8.         if (tag == X*Y)
   
9.         {
   
10.                 return 1;
    
11.         }
    
12. 
    
13.         // 如果可以走，那么flag为1
    
14.         flag = next(&x1, &y1, count);
    
15.         // 否则尝试其他路径
    
16.         while (flag == 0 && count < 7)
    
17.         {
    
18.                 count += 1;
    
19.                 flag = next(&x1, &y1, count);
    
20.         }
    
21. 
    
22.         // 递归进入下一个坐标
    
23.         while (flag)
    
24.         {
    
25.                 // 返回1表示成功找到落脚点
    
26.                 if (setHorse(x1, y1, tag+1))
    
27.                 {
    
28.                         return 1;
    
29.                 }
    
30.                 // 否则从上一步重新尝试
    
31.                 x1 = x;
    
32.                 y1 = y;
    
33.                 count += 1;
    
34.                 flag = next(&x1, &y1, count);
    
35.                 while (flag == 0 && count < 7)
    
36.                 {
    
37.                         count += 1;
    
38.                         flag = next(&x1, &y1, count);
    
39.                 }
    
40.         }
    
41. 
    
42.         if (flag == 0)
    
43.         {
    
44.                 chess[x][y] = 0;
    
45.         }
    
46. 
    
47.         return 0;
    
48. }

复制代码

就可以。不知道问题在哪里。想知道是哪里错误了？

人造人

1. sh-5.1$ cat main.c
   
2. #include <stdio.h>
   
3. #include <time.h>
   
4. 
   
5. #define X 8
   
6. #define Y 8
   
7. 
   
8. int chess[X][Y]; // 记录棋盘
   
9. 
   
10. void print(void) {
    
11.     int i, j;
    
12.     for(i = 0; i < X; i++) {
    
13.         for(j = 0; j < Y; j++) {
    
14.             printf("%2d  ", chess[i][j]);
    
15.         }
    
16.         putchar('\n');
    
17.     }
    
18. }
    
19. 
    
20. // 根据xy坐标，判断指定位置可不可走,如果可走改变传入的x y坐标
    
21. int decide_next(int *px, int *py, int count) {
    
22.     int x = *px, y = *py;
    
23. 
    
24.     switch(count) {
    
25.     case 0:
    
26.         if(x + 2 < X && y - 1 >= 0 && chess[x + 2][y - 1] == 0) {
    
27.             *px = x + 2;
    
28.             *py = y - 1;
    
29.             return 1;
    
30.         }
    
31.         break;
    
32.     case 1:
    
33.         if(x + 2 < X && y + 1 < Y && chess[x + 2][y + 1] == 0) {
    
34.             *px = x + 2;
    
35.             *py = y + 1;
    
36.             return 1;
    
37.         }
    
38.         break;
    
39.     case 2:
    
40.         if(x + 1 < X && y - 2 >= 0 && chess[x + 1][y - 2] == 0) {
    
41.             *px = x + 1;
    
42.             *py = y - 2;
    
43.             return 1;
    
44.         }
    
45.         break;
    
46.     case 3:
    
47.         if(x + 1 < X && y + 2 < Y && chess[x + 1][y + 2] == 0) {
    
48.             *px = x + 1;
    
49.             *py = y + 2;
    
50.             return 1;
    
51.         }
    
52.         break;
    
53.     case 4:
    
54.         if(x - 2 >= 0 && y - 1 >= 0 && chess[x - 2][y - 1] == 0) {
    
55.             *px = x - 2;
    
56.             *py = y - 1;
    
57.             return 1;
    
58.         }
    
59.         break;
    
60.     case 5:
    
61.         if(x - 2 >= 0 && y + 1 < Y && chess[x - 2][y + 1] == 0) {
    
62.             *px = x - 2;
    
63.             *py = y + 1;
    
64.             return 1;
    
65.         }
    
66.         break;
    
67.     case 6:
    
68.         if(x - 1 >= 0 && y - 2 >= 0 && chess[x - 1][y - 2] == 0) {
    
69.             *px = x - 1;
    
70.             *py = y - 2;
    
71.             return 1;
    
72.         }
    
73.         break;
    
74.     case 7:
    
75.         if(x - 1 >= 0 && y + 2 < Y && chess[x - 1][y + 2] == 0) {
    
76.             *px = x - 1;
    
77.             *py = y + 2;
    
78.             return 1;
    
79.         }
    
80.         break;
    
81.     }
    
82.     return 0;
    
83. }
    
84. 
    
85. // 获得棋子的路径
    
86. int setHorse(int x, int y, int tag) {
    
87.     //int x1, y1, resule = 0, count = 0;
    
88.     int x1, y1, count = 0;
    
89. 
    
90.     // tag记录轨迹
    
91.     chess[x][y] = tag;
    
92. 
    
93. 
    
94. #if 0
    
95.     // ？？？
    
96.     // 这是在做什么？
    
97.     if(tag == 62) {
    
98.         tag = 62;
    
99.     }
    
100. #endif
     
101. 
     
102. 
     
103.     // 如果tag等于64打印棋盘
     
104.     if(tag == X * Y) {
     
105.         return 1;
     
106.     }
     
107. 
     
108.     // 递归进入下一个坐标
     
109.     while(count < 8) {
     
110. 
     
111.         // 尝试路径是否能走
     
112.         x1 = x; y1 = y;
     
113.         //if(!decide_next(&x1, &y1, count)) {++count; continue;}
     
114.         /*
     
115.         resule = decide_next(&x1, &y1, count);
     
116.         if(!resule) {
     
117.             count += 1;
     
118.         }
     
119.         */
     
120.         /*
     
121.         // 这个for循环是在做什么？
     
122.         // 这里需要两层循环吗？
     
123.         for(x1 = x, y1 = y; resule == 0 && count < 8; count += 1) {
     
124.             resule = decide_next(&x1, &y1, count);
     
125.         }
     
126.         */
     
127.         // 返回1表示成功找到路径；对新的点进行尝试
     
128.         if(decide_next(&x1, &y1, count)) {
     
129.             if(setHorse(x1, y1, tag + 1)) return 1;
     
130.         }
     
131.         // 如果失败并且有没尝试的路径，回到上一步重新尝试
     
132.         count += 1;
     
133.     }
     
134.     // 如果全部路径都尝试过，并且没有返回1，说明这个点没有可行的路径，回到上一步并且去除痕迹
     
135.     chess[x][y] = 0;
     
136. 
     
137.     return 0;
     
138. }
     
139. 
     
140. int main(void) {
     
141.     int i, j, x, y;
     
142.     clock_t start, finish;
     
143. 
     
144.     for(i = 0; i < X; i++) {
     
145.         for(j = 0; j < Y; j++) {
     
146.             chess[i][j] = 0;
     
147.         }
     
148.     }
     
149. 
     
150.     // 获取初始坐标；建议(2,0)
     
151.     printf("请输入初始坐标(x y):");
     
152.     //scanf_s("%d %d", &x, &y);
     
153.     scanf("%d%d", &x, &y);
     
154. 
     
155.     // 记录开始时间
     
156.     start = clock();
     
157. 
     
158.     if(setHorse(x, y, 1)) {
     
159.         print();
     
160.     } else {
     
161.         printf("可惜无解！\n");
     
162.     }
     
163. 
     
164.     // 记录结束时间
     
165.     finish = clock();
     
166. 
     
167.     printf("\n本次计算一共耗时∶%f秒\n", (double)(finish - start) / CLOCKS_PER_SEC);
     
168. 
     
169.     return 0;
     
170. }
     
171. sh-5.1$ ./main
     
172. 请输入初始坐标(x y):1 1
     
173. 53  48  51  38  55  40  61  36
     
174. 50   1  54  47  60  37  56  41
     
175. 11  52  49  44  39  58  35  62
     
176. 2  19  12  59  46  33  42  57
     
177. 13  10  45  20  43  28  63  34
     
178. 18   3  16   7  26  23  32  29
     
179. 9  14   5  24  21  30  27  64
     
180. 4  17   8  15   6  25  22  31
     
181. 
     
182. 本次计算一共耗时∶1.926012秒
     
183. sh-5.1$
     

复制代码

ExiaGN001

人造人 发表于 2023-2-21 21:14

然而他的意图是debug而不是做题

ExiaGN001

原先的代码栈溢出挂掉了。
问题还在看。
先指出几点明确的：
count有高亮，不要乱用作标识符
中间有一个意义不明的“如果tag==62就把tag=62”，人家都等于62了，就不用赋值成62了

御坂19090

ExiaGN001 发表于 2023-2-21 22:36
原先的代码栈溢出挂掉了。
问题还在看。
先指出几点明确的：

那个tag是设置断点的