求能计算所有方阵的程序

lordbyorn

C++果然有好处。
设计和修改时简单多了。
以后还是多用C++，这样可以更加专注于算法的设计。

要程序运行得快，算法最重要，而不是语言。

lordbyorn

上面的有点小错。

1. 
   
2. #include<time.h>
   
3. #include<stdio.h>
   
4. 
   
5. #define Max 20
   
6. #define MAX(x,y) (x)>(y)?(x) : (y)
   
7. 
   
8. int count=0;
   
9. int END;
   
10. int M,MM;
    
11. int sum;
    
12. int maxnum,minnum;
    
13. int data[Max*Max];
    
14. int flags[Max*Max];
    
15. 
    
16. FILE *outfile;
    
17. time_t start,end;
    
18. int min_not_used[Max+1]={0};
    
19. int max_not_used[Max+1]={0};
    
20. 
    
21. class STACKDATA{
    
22. private:
    
23.         int buff[Max+1];
    
24.         int cursor;
    
25. public:
    
26.         STACKDATA(){
    
27.                 cursor=-1;
    
28.                 sum=0;
    
29.         }
    
30.         ~STACKDATA(){
    
31.         }
    
32.         int push(int newdata){
    
33.                 buff[++cursor]=newdata;
    
34.                 sum+=newdata;
    
35.                 return 1;
    
36.         }
    
37.         int pop(){
    
38.                 if(cursor<0)return -1;
    
39.                 sum-=buff[cursor];
    
40.                 return buff[cursor--];
    
41.         }
    
42.         int sum;
    
43. };
    
44. 
    
45. void init();
    
46. void bye();
    
47. void range(int,int,int,int,int);
    
48. void magic(int);
    
49. void output(void);
    
50. 
    
51. 
    
52. STACKDATA rowbuff[Max+1];
    
53. STACKDATA colbuff[Max+1];
    
54. STACKDATA  ldbuff[Max+1];
    
55. STACKDATA  rdbuff[Max+1];
    
56. 
    
57. /***********  bigin main   *************/
    
58. 
    
59. int main(int argc,char *argv[]) {
    
60. if(argc!=2){
    
61.          fprintf(stderr,"usage: %s num\n",argv[0]);
    
62.          return 1;
    
63. }
    
64. sscanf(argv[1],"%d",&M);
    
65. init();
    
66. magic(0);
    
67. bye();
    
68. return 0;
    
69. }
    
70. 
    
71. /******    end of main  *****************/
    
72. 
    
73. void init()
    
74. {
    
75. 
    
76. int i;
    
77. outfile=fopen("result.txt","w");
    
78. for(i=0;i<Max*Max;i++)flags[i]=0;
    
79. if(M>Max){puts("Max M exceed!!\n");}
    
80. MM=M*M;
    
81. sum=(MM+1)*M/2;
    
82. END=MM-1;
    
83. start=time(&start);
    
84. fprintf(outfile,"start at %s\n//////////////////////////////////\n",ctime(&start));
    
85. 
    
86. }
    
87. 
    
88. /************************************************/
    
89. void bye()
    
90. {
    
91. end=time(&end);
    
92. fprintf(outfile,"\n//////////////////////////////////\nend at %s\n",ctime(&end));
    
93. fprintf(outfile,"%d matchs found!",count);
    
94. fclose(outfile);
    
95. }
    
96. /***************************************************/
    
97. void magic(int n)
    
98. {
    
99. int i,ii;
    
100. int max;
     
101. int col,row,rdiag,ldiag;
     
102. 
     
103. row=n/M;
     
104. col=n%M;
     
105. ldiag=(col-row+M)%M;
     
106. rdiag=(col+row+M)%M;
     
107. range(n,row,col,ldiag,rdiag);
     
108. 
     
109.         for(i=minnum,max=maxnum;i<=max;i++) {
     
110.                 if(flags[i]==0) {
     
111.                         ii=i+1;
     
112.                         flags[i]=1;
     
113.                         data[n]=ii;
     
114.                         rowbuff[row].push(ii);
     
115.                         colbuff[col].push(ii);
     
116.                         ldbuff[ldiag].push(ii);
     
117.                         rdbuff[rdiag].push(ii);
     
118.                         if(n==(END)){
     
119.                                 output();
     
120.                         }
     
121.                         else magic(n+1);
     
122.                         flags[i]=0;
     
123.                         rowbuff[row].pop();
     
124.                         colbuff[col].pop();
     
125.                         ldbuff[ldiag].pop();
     
126.                         rdbuff[rdiag].pop();
     
127.                 }
     
128.         }
     
129.         return;
     
130. }
     
131. 
     
132. /**********************************************************/
     
133. void output()
     
134. {
     
135.         int i,j;
     
136. 
     
137.         count++;
     
138.         fprintf(outfile,"%d:\n",count);
     
139.         for(i=0;i<M;i++){
     
140.                 for(j=0;j<M;j++){
     
141.                         fprintf(outfile,"%5d",data[i*M+j]);
     
142.                 }
     
143.                 fputc('\n',outfile);
     
144.         }
     
145.         fflush(outfile);
     
146. }
     
147. 
     
148. 
     
149. 
     
150. /*******************  This function to large!!!        ************/
     
151. void range(int n,int row,int col,int ldiag,int rdiag) {
     
152. static int used;
     
153. static int bottom,top,left;
     
154. static int c;
     
155. static int tmp;
     
156. static int i,j,k;
     
157. 
     
158. k=MAX(M-col,M-row);
     
159. 
     
160. if(k>M)k=M;
     
161. for(i=0,c=1,tmp=0;c<=k;i++){
     
162.          if(flags[i]==0){
     
163.                 tmp+=i+1;
     
164.                 c++;
     
165.                 min_not_used[c]=tmp;
     
166.          }
     
167. }
     
168. for(i=END,c=1,tmp=0;c<=k;i--){
     
169.          if(flags[i]==0){
     
170.                 tmp+=i+1;
     
171.                 c++;
     
172.                 max_not_used[c]=tmp;
     
173.          }
     
174. }
     
175. 
     
176. used=rowbuff[row].sum;
     
177. left=sum-used-1;
     
178. bottom=max_not_used[M-col];
     
179. top   =min_not_used[M-col];
     
180.         minnum=left-bottom;
     
181.         maxnum=left-top;
     
182.          
     
183. used=colbuff[col].sum;
     
184. left=sum-used-1;
     
185. bottom=max_not_used[M-row];
     
186. top   =min_not_used[M-row];
     
187. minnum=minnum<left-bottom?left-bottom:minnum;
     
188. maxnum=maxnum>left-top?left-top:maxnum;
     
189. 
     
190. used=ldbuff[ldiag].sum;
     
191. left=sum-used-1;
     
192. bottom=max_not_used[M-row];
     
193. top   =min_not_used[M-row];
     
194. minnum=minnum<left-bottom?left-bottom:minnum;
     
195. maxnum=maxnum>left-top?left-top:maxnum;
     
196. 
     
197. used=rdbuff[rdiag].sum;
     
198. left=sum-used-1;
     
199. bottom=max_not_used[M-row];
     
200. top   =min_not_used[M-row];
     
201. minnum=minnum<left-bottom?left-bottom:minnum;
     
202. maxnum=maxnum>left-top?left-top:maxnum;
     
203. 
     
204. if(minnum<0)minnum=0;
     
205. if(maxnum>=MM)maxnum=MM-1;
     
206. }
     
207. 
     
208. /*****************  end of program   ***********************/
     

复制代码