Eight queens Problem (n queens Problem): recursive and non-recursive solutions (C ++)

Eight queens Problem: put eight queens on the 8*8 lattice board. Any two queens cannot be in the same row, in the same column, or on the same diagonal line. There are several ways to solve this problem.

Queen N problem: Put N queens on the board of N * n grids. Any two queens cannot be in the same row, in the same column, or on the same diagonal line. There are several methods to solve this problem.

 

1. # Include "stdafx. H"
2. # Include <iostream>
3. # Include <fstream>
4. Using namespace STD;
7. // Non-recursion
8. Void Queen (int n)
9. {
10. Int * c = new int [N]; // records the column status
11. Int * D1 = new int [2 * n-1]; // records the positive/diagonal state.
12. Int * D2 = new int [2 * n-1]; // records the negative diagonal state.
13. Int * lc = new int [N]; // records the number of columns placed by the Queen on the nth node.
15. Int ** Queen = new int * [n]; // chessboard
16. For (int I = 0; I <n; I ++) // Initialization
17. {
18. Queen [I] = new int [n];
19. For (int j = 0; j <n; j ++)
20. {
21. Queen [I] [j] = 0;
22. }
23. C [I] = 0;
24. D1 [I] = 0;
25. D1 [2 * n-i-2] = 0;
26. D2 [I] = 0;
27. D2 [2 * n-i-2] = 0;
29. }
33. Int line = 0; // line
34. Int column = 0; // column
36. _ Int64 num = 0; // number of items that can be placed
37. _ Int64 count = 0; // number of cycles
40. While (line> = 0)
41. {
42. While (column <n)
43. {
45. Count ++;
46. If (c [column] = 0 & d1 [line-column + n-1] = 0 & d2 [line + column] = 0) // if a column, true if no plus or minus diagonal lines are placed
47. {
51. If (line = N-1) // if it reaches the last line, it is true
52. {
53. Queen [Line] [column] = 1;
54. Num ++; // Add 1 to the placement quantity
55. Queen [Line] [column] = 0;
58. Break;
60. }
61. Else
62. {
63. // Record the placement status
64. Queen [Line] [column] = 1;
65. C [column] = 1;
66. D1 [Line-column + n-1] = 1;
67. D2 [LINE + column] = 1;
68. LC [Line] = column;
70. Line ++; // enter the next row, starting from column 0th
71. Column = 0;
72. }
73. }
74. Else
75. Column ++;
76. }
78. Count ++;
79. // If all cells in this row cannot be placed, move the row back and traverse the row starting from the next column placed in the previous row.
80. Line --;
82. If (line> = 0)
83. {
85. Column = Lc [Line];
86. Queen [Line] [column] = 0;
87. C [column] = 0;
88. D1 [Line-column + n-1] = 0;
89. D2 [line + column] = 0;
90. Column ++;
95. }
101. }
102. Cout <num <'/t' <count <endl ;;
106. }
108. // Recursion
109. Void queen1 (int I, int ** Queen, int * a, int * d1, int * d2, int & n, int & QueenNumber ,__ int64 & count)
110. {
112. Int iColumn;
113. For (iColumn = 0; iColumn <n; iColumn ++)
114. {
115. Count ++;
116. If (a [iColumn] = 0 & d1 [I-iColumn + n-1] = 0 & d2 [I + iColumn] = 0)
117. {
118. Queen [I] [iColumn] = 1;
119. A [iColumn] = 1;
120. D1 [I-iColumn + n-1] = 1;
121. D2 [I + iColumn] = 1;
122. If (I <n-1)
123. Queen1 (I + 1, Queen, a, d1, d2, n, QueenNumber, count );
124. Else
125. {
126. QueenNumber ++;
127. /*
128. Fstream outstuf;
129. Outstuf. open ("out.txt", ios: out | ios: app );
130. For (int I = 0; I <8; I ++)
131. {
132. For (int j = 0; j <8; j ++)
133. {
134. Outstuf <Queen [I] [j] <"";
135. }
136. Outstuf <"/r/n ";
137. }
138. Outstuf <"/r/n ";
139. Outstuf. close ();*/
140. }
142. Queen [I] [iColumn] = 0;
143. A [iColumn] = 0;
144. D1 [I-iColumn + n-1] = 0;
145. D2 [I + iColumn] = 0;
147. }
148. }
150. }
151. Void queendg (int n)
152. {
154. Int * c = new int [n];
155. Int * d1 = new int [2 * n-1];
156. Int * d2 = new int [2 * n-1];
158. Int ** Queen = new int * [n];
159. For (int I = 0; I <n; I ++)
160. {
161. Queen [I] = new int [n];
162. For (int j = 0; j <n; j ++)
163. {
164. Queen [I] [j] = 0;
165. }
166. C [I] = 0;
167. D1 [I] = 0;
168. D1 [2 * n-i-2] = 0;
169. D2 [I] = 0;
170. D2 [2 * n-i-2] = 0;
172. }
173. Int QueenNumber = 0;
174. _ Int64 count = 0;
175. Queen1 (0, Queen, c, d1, d2, n, QueenNumber, count );
176. Cout <QueenNumber <'/t' <count <endl ;;
177. }
179. Int _ tmain (int argc, _ TCHAR * argv [])
180. {
182. Queendg (8 );
183. Queen (8 );
185. Return 0;
186. }

Tested

There are 14772512 methods for putting Queen (16) in total, in 206 seconds

A total of 14772512 queendg (16) release methods, with a total time of 248 seconds