练习23

 

1. /********************************************************************************
2.  23. (覆盖问题) 有边长为Ｎ（Ｎ为偶数）的正方形，请你用Ｎ＾２／２个长为２,
3.  宽为１的长方形，将它全部覆盖。编程打印出所有覆盖方法。如：Ｎ＝４
5.     ┌─┬──┬─┐            ┌──┬──┐
6.     │  │    │  │ １２２４   │    │    │  １１２２
7.     │  ├──┤  │            ├──┼──┤
8.     │  │    │  │ １３３４   │    │    │  ３３４４
9.     ├─┼──┼─┤            ├──┼──┤
10.     │  │    │  │ ５６６８   │    │    │  ５５６６
11.     │  ├──┤  │            ├──┼──┤
12.     │  │    │  │ ５７７８   │    │    │  ７７８８
13.     └─┴──┴─┘            └──┴──┘
14.     分析:
15.     经过观察显然可知:
16.     找出一个没有被覆盖的1*1的方块,它可以与上,下,左,右相邻的1*1方块组成2*1的覆盖
17.     方块,而这样的几种情况是没有重复的,所以我们要完成所有的覆盖方法,就等于我们要完
18.     成这几种情况的覆盖方法,而这几种情况还是一个覆盖问题,所以,我采用分治算法解决!
19. *********************************************************************************/
22. #include <stdio.h>
24. #define N 4
26. typedef struct
27. {
28.     int x;
29.     int y;
30.     int d;//方向
31. } Block;
33. void Find(int k);
34. void Cover(int x, int y, int d, int k);
36. //四种基于某点的覆盖情况
37. int dx[] = {0,1,0,-1};
38. int dy[] = {1,0,-1,0};
40. //保存覆盖结果
41. Block blk[N*N/2];
43. //保存显示结果
44. int map[N][N];
46. //输出数据文件指针
47. FILE* fp;
49. //计数器
50. int counter = 0;
52. //输出显示结果到文件cover.txt
53. void output()
54. {
55.     int k;
56.     int x,y;
57.     //填充显示矩阵
58.     for(k=0; k<N*N/2; k++)
59.     {
60.         map[blk[k].y][blk[k].x] = k+1;
61.         map[blk[k].y+dy[blk[k].d]][blk[k].x+dx[blk[k].d]] = k+1;
62.     }
63.     //显示矩阵
64.     for(y=0; y<N; y++)
65.     {
66.         for(x=0; x<N; x++)
67.         {
68.             fprintf(fp,"%3d",map[y][x]);
69.         }
70.         fprintf(fp,"/n");
71.     }
72.     fprintf(fp,"/n");
74. }
76. //判断该块是否在覆盖范围内
77. int InArea(int x, int y)
78. {
79.     if(x<0)
80.         return 0;
81.     if(x>=N)
82.         return 0;
83.     if(y<0)
84.         return 0;
85.     if(y>=N)
86.         return 0;
88.     return 1;
89. }
91. //查找某一块是否有重叠
92. int Search(int x, int y, int k)
93. {
94.     int t,flag=0;
95.     for(t=0; t<k; t++)
96.     {
97.         if(x==blk[t].x && y==blk[t].y)
98.         {
99.             flag = 1;
100.             break;
101.         }
102.         if(x==blk[t].x+dx[blk[t].d] && y==blk[t].y+dy[blk[t].d])
103.         {
104.             flag = 1;
105.             break;
106.         }
107.     }
108.     return flag;
109. }
111. //找出一个没有被覆盖的1*1方块
112. void Find(int k)
113. {
114.     int x,y;
115.     for(y=0; y<N; y++)
116.     {
117.         for(x=0; x<N; x++)
118.         {
119.             if(!Search(x,y,k))
120.             {
121.                 goto L;
122.             }
123.         }
124.     }
125.     //分治
126. L:  Cover(x,y,0,k);
127.     Cover(x,y,1,k);
128.     Cover(x,y,2,k);
129.     Cover(x,y,3,k);
130. }
132. //覆盖
133. void Cover(int x, int y, int d, int k)
134. {
135.     int tx,ty;
136.     tx = x+dx[d];
137.     ty = y+dy[d];
138.     if(!InArea(tx,ty) || Search(tx,ty,k))
139.         return;
140.     blk[k].x = x;
141.     blk[k].y = y;
142.     blk[k].d = d;
144.     if(k==N*N/2-1)//完成了
145.     {
146.         counter ++;
147.         //输出覆盖结果
148.         output();
149.     }
150.     else{//如果还没完成,继续查找
151.         Find(k+1);
152.     }
153. }
155. void main()
156. {
157.     fp = fopen("cover.txt","w");
158.     Find(0);
159.     fprintf(fp,"一共有%d种覆盖方法!",counter);
160.     fclose(fp);
161. }