练习21

1. /****************************************************************************
2. 21. 请设计一个程序，由计算机把１..￣.８的八个自然数填入图中，使得横、
3.  竖、对角任何两个相邻的小方格中的两个数是不连续的。(下图右侧的 4 个图
4.  为禁止的情形).
6.             ┌─┐          ┌─┐               ┌─┐
7.             │  │          │４│               │８│
8.         ┌─┼─┼─┐      └─┼─┐       ┌─┼─┘
9.         │  │  │  │          │５│       │７│
10.         ├─┼─┼─┤          └─┘       └─┘
11.         │  │  │  │      ┌─┐
12.         └─┼─┼─┘      │６│           ┌─┬─┐
13.             │  │          ├─┤           │１│２│
14.             └─┘          │７│           └─┴─┘
15.                             └─┘ 
17.             ┌─┐                    
18.             │t2│                       
19.         ┌─┼─┼─┐     
20.         │t4│t0│t6│        
21.         ├─┼─┼─┤        
22.         │t7│t1│t5│      
23.         └─┼─┼─┘   
24.             │t3│          
25.             └─┘  
27. 分析:采用剪枝回溯法
28. 由于位置的特殊性,将空格按照如下次序搜索.
29. ******************************************************************************/
31. #include <stdio.h>
32. #include <math.h>
34. //路径集合
35. static int *t[8];
36. int t0[] = {1,8,0};//由于位置的特殊性,这里只能放1,8
37. int t1[] = {1,8,0};//如上类推
38. int t2[] = {2,7,0};
39. int t3[] = {2,7,0};
40. int t4[] = {3,4,5,6,0};
41. int t5[] = {3,4,5,6,0};
42. int t6[] = {3,4,5,6,0};
43. int t7[] = {3,4,5,6,0};
45. //邻居表
46. static int *n[8];
47. int n0[] = {1,2,4,5,6,7,-1};
48. int n1[] = {0,3,4,5,6,7,-1};
49. int n2[] = {0,4,6,-1};
50. int n3[] = {1,5,7,-1};
51. int n4[] = {0,1,2,7,-1};
52. int n5[] = {0,1,3,6,-1};
53. int n6[] = {0,1,2,5,-1};
54. int n7[] = {0,1,3,4,-1};
56. //结果的形式
57. char res[] = "/
58.             ┌─┐/n/
59.             │%2d│/n/
60.         ┌─┼─┼─┐/n/
61.         │%2d│%2d│%2d│/n/
62.         ├─┼─┼─┤/n/
63.         │%2d│%2d│%2d│/n/
64.         └─┼─┼─┘/n/
65.             │%2d│/n/
66.             └─┘/n/
67. ";
69. //保存路径
70. static int Path[8];
72. //检查合法性
73. int checked(int k)
74. {
75.     int i;
76.     for(i=0; n[k][i]!=-1; i++)
77.     {
78.         if( n[k][i] < k) 
79.         {
80.             //如果与邻居数相差1,(不符合)则返回0
81.             if(abs(t[k][Path[k]]-t[n[k][i]][Path[n[k][i]]]) == 1 )
82.                 return 0;
83.         }
84.     }
85.     for(i=0; i<k; i++)
86.     {
87.         //如果与前面解有重复,(不符合)返回0
88.         if(t[k][Path[k]] == t[i][Path[i]])
89.             return 0;
90.     }
91.     //符合,返回1
92.     return 1;
93. }
95. //显示结果
96. void ShowRes()
97. {
98.     printf(res, t2[Path[2]],t4[Path[4]],
99.         t0[Path[0]],t6[Path[6]],t7[Path[7]],
100.         t1[Path[1]],t5[Path[5]],t3[Path[3]]);
101. }
103. //主函数
104. void main()
105. {
106.     int k;
107.     int flag = 0;
109.     t[0] = t0;
110.     t[1] = t1;
111.     t[2] = t2;
112.     t[3] = t3;
113.     t[4] = t4;
114.     t[5] = t5;
115.     t[6] = t6;
116.     t[7] = t7;
118.     n[0] = n0;
119.     n[1] = n1;
120.     n[2] = n2;
121.     n[3] = n3;
122.     n[4] = n4;
123.     n[5] = n5;
124.     n[6] = n6;
125.     n[7] = n7;
127.     for(k=0; k<8; k++)
128.         Path[k] = -1;
130.     k=0;
132.     while(k>=0)
133.     {
134.         while(t[k][++Path[k]]!=0)
135.         {
136.             if(checked(k) && k<7)
137.             {
138.                 //部分解
139.                 k++;
140.             }
141.             else if(checked(k) && k==7)
142.             {
143.                 //完全解
144.                 flag = 1;
145.                 ShowRes();
146.                 //回溯,找出所有解
147.                 Path[k] = -1;
148.                 k--;
149.             }
150.         }
151.         //回溯
152.         Path[k] = -1;
153.         k--;
154.     }
156.     //如果没有解
157.     if(flag == 0)
158.     {
159.         printf("no solve!");
160.     }
162. }