请问为什么用dev-c++运行不等输入就直接exit了？

wzm1379005338

1. 
   
2. #include<stdio.h>
   
3. #include<stdlib.h>
   
4. 
   
5. struct Pointer
   
6. {
   
7.         int num;
   
8.         struct Pointer *next;
   
9. };
   
10. typedef struct Pointer Node;
    
11. 
    
12. void Move(int i,int a[][1005],int x,int y,Node *head,int n);
    
13. void Moveleft(int i,int a[][1005],int x,int y,Node *head,int n);
    
14. void Moveright(int i,int a[][1005],int x,int y,Node *head,int n);
    
15. void Moveup(int i,int a[][1005],int x,int y,Node *head,int n);
    
16. void Movedown(int i,int a[][1005],int x,int y,Node *head,int n);
    
17. 
    
18. void Moveleft(int i,int a[][1005],int x,int y,Node *head,int n)
    
19. {
    
20.         Node *node;
    
21.         x--;
    
22.         a[x][y]=1;
    
23.         i++;
    
24.         if(x-1>=0)
    
25.         {
    
26.                 if(a[x-1][y]==2)
    
27.                 {
    
28.                         i++;
    
29.                         node=(Node *)malloc(sizeof(Node));
    
30.                         head->num=i;
    
31.                         node->next=head->next;
    
32.                         head->next=node;
    
33.                 }
    
34.                 else if(a[x-1][y]==0)
    
35.                 {
    
36.                         Moveleft(i,a,x,y,head,n);
    
37.                 }
    
38.         }
    
39.         if(y-1>=0)
    
40.         {
    
41.                 if(a[x][y-1]==2)
    
42.                 {
    
43.                         i++;
    
44.                         node=(Node *)malloc(sizeof(Node));
    
45.                         node->num=i;
    
46.                         node->next=head->next;
    
47.                         head->next=node;
    
48.                 }
    
49.                 else if(a[x][y-1]==0)
    
50.                 {
    
51.                         Movedown(i,a,x,y,head,n);
    
52.                 }
    
53.         }
    
54.         if(y+1<n)
    
55.         {
    
56.                 if(a[x][y+1]==2)
    
57.                 {
    
58.                         i++;
    
59.                         node=(Node *)malloc(sizeof(Node));
    
60.                         node->num=i;
    
61.                         node->next=head->next;
    
62.                         head->next=node;
    
63.                 }
    
64.                 else if(a[x][y+1]==0)
    
65.                 {
    
66.                         Moveup(i,a,x,y,head,n);
    
67.                 }
    
68.         }
    
69. }
    
70. 
    
71. void Moveright(int i,int a[][1005],int x,int y,Node *head,int n)
    
72. {
    
73.         Node *node;
    
74.         x++;
    
75.         a[x][y]=1;
    
76.         i++;
    
77.         if(x+1<n)
    
78.         {
    
79.                 if(a[x+1][y]==2)
    
80.                 {
    
81.                         i++;
    
82.                         node=(Node *)malloc(sizeof(Node));
    
83.                         node->num=i;
    
84.                         node->next=head->next;
    
85.                         head->next=node;
    
86.                 }
    
87.                 else if(a[x+1][y]==0)
    
88.                 {
    
89.                         Moveright(i,a,x,y,head,n);
    
90.                 }
    
91.         }
    
92.         if(y-1>=0)
    
93.         {
    
94.                 if(a[x][y-1]==2)
    
95.                 {
    
96.                         i++;
    
97.                         node=(Node *)malloc(sizeof(Node));
    
98.                         node->num=i;
    
99.                         node->next=head->next;
    
100.                         head->next=node;
     
101.                 }
     
102.                 else if(a[x][y-1]==0)
     
103.                 {
     
104.                         Movedown(i,a,x,y,head,n);
     
105.                 }
     
106.         }
     
107.         if(y+1<n)
     
108.         {
     
109.                 if(a[x][y+1]==2)
     
110.                 {
     
111.                         i++;
     
112.                         node=(Node *)malloc(sizeof(Node));
     
113.                         node->num=i;
     
114.                         node->next=head->next;
     
115.                         head->next=node;
     
116.                 }
     
117.                 else if(a[x][y+1]==0)
     
118.                 {
     
119.                         Moveup(i,a,x,y,head,n);
     
120.                 }
     
121.         }
     
122. }
     
123. 
     
124. void Moveup(int i,int a[][1005],int x,int y,Node *head,int n)
     
125. {
     
126.         Node *node;
     
127.         y++;
     
128.         a[x][y]=1;
     
129.         i++;
     
130.         if(y+1<n)
     
131.         {
     
132.                 if(a[x][y+1]==2)
     
133.                 {
     
134.                         i++;
     
135.                         node=(Node *)malloc(sizeof(Node));
     
136.                         node->num=i;
     
137.                         node->next=head->next;
     
138.                         head->next=node;
     
139.                 }
     
140.                 else if(a[x][y+1]==0)
     
141.                 {
     
142.                         Moveup(i,a,x,y,head,n);
     
143.                 }
     
144.         }
     
145.         if(x-1>=0)
     
146.         {
     
147.                 if(a[x-1][y]==2)
     
148.                 {
     
149.                         i++;
     
150.                         node=(Node *)malloc(sizeof(Node));
     
151.                         node->num=i;
     
152.                         node->next=head->next;
     
153.                         head->next=node;
     
154.                 }
     
155.                 else if(a[x-1][y]==0)
     
156.                 {
     
157.                         Moveleft(i,a,x,y,head,n);
     
158.                 }
     
159.         }
     
160.         if(x+1<n)
     
161.         {
     
162.                 if(a[x+1][y]==2)
     
163.                 {
     
164.                         i++;
     
165.                         node=(Node *)malloc(sizeof(Node));
     
166.                         node->num=i;
     
167.                         node->next=head->next;
     
168.                         head->next=node;
     
169.                 }
     
170.                 else if(a[x+1][y]==0)
     
171.                 {
     
172.                         Moveright(i,a,x,y,head,n);
     
173.                 }
     
174.         }
     
175. }
     
176. 
     
177. void Movedown(int i,int a[][1005],int x,int y,Node *head,int n)
     
178. {
     
179.         Node *node;
     
180.         y--;
     
181.         a[x][y]=1;
     
182.         i++;
     
183.         if(y-1>=0)
     
184.         {
     
185.                 if(a[x][y-1]==2)
     
186.                 {
     
187.                         i++;
     
188.                         node=(Node *)malloc(sizeof(Node));
     
189.                         node->num=i;
     
190.                         node->next=head->next;
     
191.                         head->next=node;
     
192.                 }
     
193.                 else if(a[x][y-1]==0)
     
194.                 {
     
195.                         Movedown(i,a,x,y,head,n);
     
196.                 }
     
197.         }
     
198.         if(x-1>=0)
     
199.         {
     
200.                 if(a[x-1][y]==2)
     
201.                 {
     
202.                         i++;
     
203.                         node=(Node *)malloc(sizeof(Node));
     
204.                         node->num=i;
     
205.                         node->next=head->next;
     
206.                         head->next=node;
     
207.                 }
     
208.                 else if(a[x-1][y]==0)
     
209.                 {
     
210.                         Moveleft(i,a,x,y,head,n);
     
211.                 }
     
212.         }
     
213.         if(x+1<n)
     
214.         {
     
215.                 if(a[x+1][y]==2)
     
216.                 {
     
217.                         i++;
     
218.                         node=(Node *)malloc(sizeof(Node));
     
219.                         node->num=i;
     
220.                         node->next=head->next;
     
221.                         head->next=node;
     
222.                 }
     
223.                 else if(a[x+1][y]==0)
     
224.                 {
     
225.                         Moveright(i,a,x,y,head,n);
     
226.                 }
     
227.         }
     
228. }
     
229. 
     
230. void Move(int i,int a[][1005],int x,int y,Node *head,int n)
     
231. {
     
232.         Node *node;
     
233.         if(x-1>=0)
     
234.         {
     
235.                 if(a[x-1][y]==2)
     
236.                 {
     
237.                         i++;
     
238.                         node=(Node *)malloc(sizeof(Node));
     
239.                         node->num=i;
     
240.                         node->next=head->next;
     
241.                         head->next=node;
     
242.                 }
     
243.                 else if(a[x-1][y]==0)
     
244.                 {
     
245.                         Moveleft(i,a,x,y,head,n);
     
246.                 }
     
247.         }       
     
248.         if(x+1<n)
     
249.         {
     
250.                 if(a[x+1][y]==2)
     
251.                 {
     
252.                         i++;
     
253.                         node=(Node *)malloc(sizeof(Node));
     
254.                         node->num=i;
     
255.                         node->next=head->next;
     
256.                         head->next=node;
     
257.                 }
     
258.                 else if(a[x+1][y]==0)
     
259.                 {
     
260.                         Moveright(i,a,x,y,head,n);
     
261.                 }
     
262.         }
     
263.         if(y-1>=0)
     
264.         {
     
265.                 if(a[x][y-1]==2)
     
266.                 {
     
267.                         i++;
     
268.                         node=(Node *)malloc(sizeof(Node));
     
269.                         node->num=i;
     
270.                         node->next=head->next;
     
271.                         head->next=node;
     
272.                 }
     
273.                 else if(a[x][y-1]==0)
     
274.                 {
     
275.                         Movedown(i,a,x,y,head,n);
     
276.                 }
     
277.         }
     
278.         if(y+1<n)
     
279.         {
     
280.                 if(a[x][y+1]==2)
     
281.                 {
     
282.                         i++;
     
283.                         node=(Node *)malloc(sizeof(Node));
     
284.                         node->num=i;
     
285.                         node->next=head->next;
     
286.                         head->next=node;
     
287.                 }
     
288.                 else if(a[x][y+1]==0)
     
289.                 {
     
290.                         Moveup(i,a,x,y,head,n);
     
291.                 }
     
292.         }
     
293. }
     
294. 
     
295. int main()
     
296. {
     
297.         int n,m,k,d,i,j,minx,a[1005][1005]={0},x,y,food[1005],sum=0;
     
298.         Node *head,*p;
     
299.         fflush(stdin);
     
300.         scanf("%d %d %d %d",&n,&m,&k,&d);
     
301.         for(i=0;i<m;i++)
     
302.         {       
     
303.                 scanf("%d %d",&x,&y);
     
304.                 a[x][y]=2;
     
305.         }       
     
306.         for(i=0;i<k;i++)
     
307.         {
     
308.                 scanf("%d %d %d",&x,&y,&food[i]);
     
309.         }
     
310.         for(i=0;i<d;i++)
     
311.         {
     
312.                 scanf("%d %d",&x,&y);
     
313.                 a[x][y]=100;
     
314.         }
     
315.        
     
316.         head=(Node *)malloc(sizeof(Node));
     
317.         head->next=NULL;
     
318.         head->num=0;
     
319.        
     
320.         for(i=0;i<k;i++)
     
321.         {
     
322.                 Move(0,a,x,y,head,n);
     
323.                 minx=head->next->num;
     
324.                 for(p=head->next->next;p->next!=NULL;p=p->next);
     
325.                 {
     
326.                         if(p->num<minx)
     
327.                                 minx=p->num;
     
328.                 }
     
329.                 sum+=minx*food[i];
     
330.         }
     
331.         printf("%d\n",sum);
     
332.         return 0;
     
333. }

复制代码

superbe

main函数定义的数组a太大了，可能超过了栈的空间大小。
把a改成这样试下：

1. int main()
   
2. {
   
3.         int n,m,k,d,i,j,minx,**a,x,y,food[1005],sum=0;
   
4.         Node *head,*p;
   
5.         a=(int **)malloc(sizeof(int)*1005);
   
6.         for(i=0;i<1005;i++)
   
7.         {
   
8.                 a[i]=(int *)malloc(sizeof(int)*1005);
   
9.         }

复制代码

wzm1379005338

谢谢你，不过还是不行