练习71

1. /******************************************************************************
3. 71. (最长连线) 设有一个 N×N 的方格图形，且 N 为 3 的倍数。要求在图形中
4.  存放 0 或 1，相邻的 1 可以连成一条连线，连接的方法可以是行，也可以是列；
5.  同时约定一条连线只能有一个起点和一个终点，图形上的点最多只能访问一次。
6.  编程求最长连线. 例如 N＝6 时，有下图：
7.                  １  ２  ３  ４  ５  ６
8.                ┌─┬─┬─┬─┬─┬─┐
9.            １  │１│１│１│０│０│１│
10.                ├─┼─┼─┼─┼─┼─┤
11.            ２  │１│１│０│１│１│１│
12.                ├─┼─┼─┼─┼─┼─┤
13.            ３  │０│０│０│１│０│１│
14.                ├─┼─┼─┼─┼─┼─┤
15.            ４  │１│１│０│１│１│１│
16.                ├─┼─┼─┼─┼─┼─┤
17.            ５  │０│１│０│０│０│０│
18.                ├─┼─┼─┼─┼─┼─┤
19.            ６  │１│１│１│１│０│０│
20.                └─┴─┴─┴─┴─┴─┘
21.    在该图中，包含有如下的一些连线：
22.      １←１←１        １←１                     １
23.      ↓                ↓                         ↓
24.      １→１            １                 １→１  １
25.                        ↓                 ↑      ↓
26.                        １→１→１         １      １
27.                                           ↑      ↓
28.                                           １←１←１
29.     在以上的连线中，最长的连线为：    表示方法：
30.              １                       最长连线长度：LMAX=9
31.              ↓                       连线：(1,6)→(2,6)→
32.      １→１  １                             (3,6)→(4,6)→
33.      ↑      ↓                             (4,5)→(4,4)→
34.      １      １                             (3,4)→(2,4)→
35.      ↑      ↓                             (2,5)
36.      １←１←１                  连线的表示不是唯一的，仅给出一种即可。
38.   *****************************************************************************/
39. /*
40. //分治法求解
41. #include <stdio.h>
43. typedef struct
44. {
45.     int x;
46.     int y;
47. } Pos;
49. #define N 6
51. int dx[] = {1,0,-1,0};
52. int dy[] = {0,1,0,-1};
55. int map[N][N] = {1,1,1,0,0,1,
56.                  1,1,0,1,1,1,
57.                  0,0,0,1,0,1,
58.                  1,1,0,1,1,1,
59.                  0,1,0,0,0,0,
60.                  1,1,1,1,0,0};
62. Pos Line[N*N];
63. Pos MaxLine[N*N];
65. //连线
66. void join(int x, int y, int k, int *pmax)
67. {
68.     int i;  
69.     Line[k].x = x;
70.     Line[k].y = y;
71.     map[y][x] = 0;
72.     for(i=0; i<4; i++)//分治
73.     {   
74.         #define CHECKED(x,y) x>=0 && x<N && y>=0 && y<N && map[y][x] == 1
75.         if(CHECKED(x+dx[i],y+dy[i]))
76.         {
77.             join(x+dx[i],y+dy[i],k+1,pmax);
78.         }
79.     }
80.     map[y][x] = 1;
81.     //找到一条路径
82.     if(k+1 > *pmax)
83.     {
84.         int t;
85.         *pmax = k+1;
86.         for(t=0; t<=*pmax; t++)
87.             MaxLine[t] = Line[t];
88.     }
89. }
91. //打印路径
92. void PrintMaxLine(int max)
93. {
94.     int i;
95.     printf("max = %d/n",max);
96.     for(i=0; i<max; i++)
97.     {
98.         printf("(%d , %d) ",MaxLine[i].x+1,MaxLine[i].y+1);
99.     }   
100.     printf("/n");
101. }
103. void main()
104. {
105.     int x,y;
106.     int max = 0;
107.     for(y=0; y<N; y++)
108.     {
109.         for(x=0; x<N; x++)
110.         {
111.             if(map[y][x] == 1)
112.                 join(x,y,0,&max);       
113.         }
114.     }
115.     PrintMaxLine(max);
116. }
117. */
119. //用回溯法求解
120. #include <stdio.h>
122. typedef struct
123. {
124.     int x;
125.     int y;
126. } Pos;
128. #define N 6
130. int dx[] = {1,0,-1,0};
131. int dy[] = {0,1,0,-1};
133. int map[N][N] = {1,1,1,0,0,1,
134.                  1,1,0,1,1,1,
135.                  0,0,0,1,0,1,
136.                  1,1,0,1,1,1,
137.                  0,1,0,0,0,0,
138.                  1,1,1,1,0,0};
140. Pos Line[N*N];
141. Pos MaxLine[N*N];
142. int path[N*N];
143. int join(int x, int y)
144. {
145.     int k;
146.     int max = 0;
148.     if(map[y][x] == 0)
149.         return 0;
151.     Line[0].x = x;
152.     Line[0].y = y;
153.     for(k=0; k<N*N; k++)
154.         path[k] = -1;
155.     
156.     map[y][x] = 0;
157.     k = 0;
158.     while(k>=0)
159.     {
160.         while(++path[k]<4)
161.         {
162.             int tx,ty;
163.             tx = x + dx[path[k]];
164.             ty = y + dy[path[k]];
165.             if(tx>=0 && tx<N && ty>=0 && ty<N && map[ty][tx] == 1)
166.             {
167.                 map[y][x] = 0;
168.                 x = tx;
169.                 y = ty;
170.                 k++;
171.             }
172.         }
173.         //找到从该点出发的一条路径
174.         if(max < k)//如果大于当前最大长度,保存
175.         {
176.             int i;
177.             max = k;
178.             for(i=0; i<max; i++)
179.             {
180.                 //保存从该点出发的最长路径
181.                 Line[i+1].x = Line[i].x + dx[path[i]];
182.                 Line[i+1].y = Line[i].y + dy[path[i]];
183.             }
184.         }
185.         //回溯
186.         map[y][x] = 1;
187.         path[k] = -1;
188.         k--;
189.         if(k<0)
190.         {
191.             break;
192.         }
193.         x = x - dx[path[k]];
194.         y = y - dy[path[k]];
195.     }
196.     map[y][x] = 1;
198.     return max;
199. }
201. void PrintMaxLine(int max)
202. {
203.     int i;
204.     printf("max = %d/n",max+1);
205.     for(i=0; i<=max; i++)
206.     {
207.         printf("(%d,%d) ",MaxLine[i].x+1,MaxLine[i].y+1);
208.     }
209.     printf("/n");
210. }
212. void main()
213. {
214.     int len;
215.     int x, y;
216.     int max = 0;
217.     for(y=0; y<N; y++)
218.     {
219.         for(x=0; x<N; x++)
220.         {
221.                 len = join(x,y);
222.                 if(max < len)
223.                 {
224.                     int i;
225.                     max = len;
226.                     for(i=0; i<=max; i++)
227.                         MaxLine[i] = Line[i];
228.                 }
229.         }
230.     }
231.     PrintMaxLine(max);  
232. }