鱼C论坛

 找回密码
 立即注册
查看: 3059|回复: 2

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

[复制链接]
发表于 2019-9-14 14:10:44 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能^_^

您需要 登录 才可以下载或查看,没有账号?立即注册

x

  1. #include<stdio.h>
  2. #include<stdlib.h>

  3. struct Pointer
  4. {
  5.         int num;
  6.         struct Pointer *next;
  7. };
  8. typedef struct Pointer Node;

  9. void Move(int i,int a[][1005],int x,int y,Node *head,int n);
  10. void Moveleft(int i,int a[][1005],int x,int y,Node *head,int n);
  11. void Moveright(int i,int a[][1005],int x,int y,Node *head,int n);
  12. void Moveup(int i,int a[][1005],int x,int y,Node *head,int n);
  13. void Movedown(int i,int a[][1005],int x,int y,Node *head,int n);

  14. void Moveleft(int i,int a[][1005],int x,int y,Node *head,int n)
  15. {
  16.         Node *node;
  17.         x--;
  18.         a[x][y]=1;
  19.         i++;
  20.         if(x-1>=0)
  21.         {
  22.                 if(a[x-1][y]==2)
  23.                 {
  24.                         i++;
  25.                         node=(Node *)malloc(sizeof(Node));
  26.                         head->num=i;
  27.                         node->next=head->next;
  28.                         head->next=node;
  29.                 }
  30.                 else if(a[x-1][y]==0)
  31.                 {
  32.                         Moveleft(i,a,x,y,head,n);
  33.                 }
  34.         }
  35.         if(y-1>=0)
  36.         {
  37.                 if(a[x][y-1]==2)
  38.                 {
  39.                         i++;
  40.                         node=(Node *)malloc(sizeof(Node));
  41.                         node->num=i;
  42.                         node->next=head->next;
  43.                         head->next=node;
  44.                 }
  45.                 else if(a[x][y-1]==0)
  46.                 {
  47.                         Movedown(i,a,x,y,head,n);
  48.                 }
  49.         }
  50.         if(y+1<n)
  51.         {
  52.                 if(a[x][y+1]==2)
  53.                 {
  54.                         i++;
  55.                         node=(Node *)malloc(sizeof(Node));
  56.                         node->num=i;
  57.                         node->next=head->next;
  58.                         head->next=node;
  59.                 }
  60.                 else if(a[x][y+1]==0)
  61.                 {
  62.                         Moveup(i,a,x,y,head,n);
  63.                 }
  64.         }
  65. }

  66. void Moveright(int i,int a[][1005],int x,int y,Node *head,int n)
  67. {
  68.         Node *node;
  69.         x++;
  70.         a[x][y]=1;
  71.         i++;
  72.         if(x+1<n)
  73.         {
  74.                 if(a[x+1][y]==2)
  75.                 {
  76.                         i++;
  77.                         node=(Node *)malloc(sizeof(Node));
  78.                         node->num=i;
  79.                         node->next=head->next;
  80.                         head->next=node;
  81.                 }
  82.                 else if(a[x+1][y]==0)
  83.                 {
  84.                         Moveright(i,a,x,y,head,n);
  85.                 }
  86.         }
  87.         if(y-1>=0)
  88.         {
  89.                 if(a[x][y-1]==2)
  90.                 {
  91.                         i++;
  92.                         node=(Node *)malloc(sizeof(Node));
  93.                         node->num=i;
  94.                         node->next=head->next;
  95.                         head->next=node;
  96.                 }
  97.                 else if(a[x][y-1]==0)
  98.                 {
  99.                         Movedown(i,a,x,y,head,n);
  100.                 }
  101.         }
  102.         if(y+1<n)
  103.         {
  104.                 if(a[x][y+1]==2)
  105.                 {
  106.                         i++;
  107.                         node=(Node *)malloc(sizeof(Node));
  108.                         node->num=i;
  109.                         node->next=head->next;
  110.                         head->next=node;
  111.                 }
  112.                 else if(a[x][y+1]==0)
  113.                 {
  114.                         Moveup(i,a,x,y,head,n);
  115.                 }
  116.         }
  117. }

  118. void Moveup(int i,int a[][1005],int x,int y,Node *head,int n)
  119. {
  120.         Node *node;
  121.         y++;
  122.         a[x][y]=1;
  123.         i++;
  124.         if(y+1<n)
  125.         {
  126.                 if(a[x][y+1]==2)
  127.                 {
  128.                         i++;
  129.                         node=(Node *)malloc(sizeof(Node));
  130.                         node->num=i;
  131.                         node->next=head->next;
  132.                         head->next=node;
  133.                 }
  134.                 else if(a[x][y+1]==0)
  135.                 {
  136.                         Moveup(i,a,x,y,head,n);
  137.                 }
  138.         }
  139.         if(x-1>=0)
  140.         {
  141.                 if(a[x-1][y]==2)
  142.                 {
  143.                         i++;
  144.                         node=(Node *)malloc(sizeof(Node));
  145.                         node->num=i;
  146.                         node->next=head->next;
  147.                         head->next=node;
  148.                 }
  149.                 else if(a[x-1][y]==0)
  150.                 {
  151.                         Moveleft(i,a,x,y,head,n);
  152.                 }
  153.         }
  154.         if(x+1<n)
  155.         {
  156.                 if(a[x+1][y]==2)
  157.                 {
  158.                         i++;
  159.                         node=(Node *)malloc(sizeof(Node));
  160.                         node->num=i;
  161.                         node->next=head->next;
  162.                         head->next=node;
  163.                 }
  164.                 else if(a[x+1][y]==0)
  165.                 {
  166.                         Moveright(i,a,x,y,head,n);
  167.                 }
  168.         }
  169. }

  170. void Movedown(int i,int a[][1005],int x,int y,Node *head,int n)
  171. {
  172.         Node *node;
  173.         y--;
  174.         a[x][y]=1;
  175.         i++;
  176.         if(y-1>=0)
  177.         {
  178.                 if(a[x][y-1]==2)
  179.                 {
  180.                         i++;
  181.                         node=(Node *)malloc(sizeof(Node));
  182.                         node->num=i;
  183.                         node->next=head->next;
  184.                         head->next=node;
  185.                 }
  186.                 else if(a[x][y-1]==0)
  187.                 {
  188.                         Movedown(i,a,x,y,head,n);
  189.                 }
  190.         }
  191.         if(x-1>=0)
  192.         {
  193.                 if(a[x-1][y]==2)
  194.                 {
  195.                         i++;
  196.                         node=(Node *)malloc(sizeof(Node));
  197.                         node->num=i;
  198.                         node->next=head->next;
  199.                         head->next=node;
  200.                 }
  201.                 else if(a[x-1][y]==0)
  202.                 {
  203.                         Moveleft(i,a,x,y,head,n);
  204.                 }
  205.         }
  206.         if(x+1<n)
  207.         {
  208.                 if(a[x+1][y]==2)
  209.                 {
  210.                         i++;
  211.                         node=(Node *)malloc(sizeof(Node));
  212.                         node->num=i;
  213.                         node->next=head->next;
  214.                         head->next=node;
  215.                 }
  216.                 else if(a[x+1][y]==0)
  217.                 {
  218.                         Moveright(i,a,x,y,head,n);
  219.                 }
  220.         }
  221. }

  222. void Move(int i,int a[][1005],int x,int y,Node *head,int n)
  223. {
  224.         Node *node;
  225.         if(x-1>=0)
  226.         {
  227.                 if(a[x-1][y]==2)
  228.                 {
  229.                         i++;
  230.                         node=(Node *)malloc(sizeof(Node));
  231.                         node->num=i;
  232.                         node->next=head->next;
  233.                         head->next=node;
  234.                 }
  235.                 else if(a[x-1][y]==0)
  236.                 {
  237.                         Moveleft(i,a,x,y,head,n);
  238.                 }
  239.         }       
  240.         if(x+1<n)
  241.         {
  242.                 if(a[x+1][y]==2)
  243.                 {
  244.                         i++;
  245.                         node=(Node *)malloc(sizeof(Node));
  246.                         node->num=i;
  247.                         node->next=head->next;
  248.                         head->next=node;
  249.                 }
  250.                 else if(a[x+1][y]==0)
  251.                 {
  252.                         Moveright(i,a,x,y,head,n);
  253.                 }
  254.         }
  255.         if(y-1>=0)
  256.         {
  257.                 if(a[x][y-1]==2)
  258.                 {
  259.                         i++;
  260.                         node=(Node *)malloc(sizeof(Node));
  261.                         node->num=i;
  262.                         node->next=head->next;
  263.                         head->next=node;
  264.                 }
  265.                 else if(a[x][y-1]==0)
  266.                 {
  267.                         Movedown(i,a,x,y,head,n);
  268.                 }
  269.         }
  270.         if(y+1<n)
  271.         {
  272.                 if(a[x][y+1]==2)
  273.                 {
  274.                         i++;
  275.                         node=(Node *)malloc(sizeof(Node));
  276.                         node->num=i;
  277.                         node->next=head->next;
  278.                         head->next=node;
  279.                 }
  280.                 else if(a[x][y+1]==0)
  281.                 {
  282.                         Moveup(i,a,x,y,head,n);
  283.                 }
  284.         }
  285. }

  286. int main()
  287. {
  288.         int n,m,k,d,i,j,minx,a[1005][1005]={0},x,y,food[1005],sum=0;
  289.         Node *head,*p;
  290.         fflush(stdin);
  291.         scanf("%d %d %d %d",&n,&m,&k,&d);
  292.         for(i=0;i<m;i++)
  293.         {       
  294.                 scanf("%d %d",&x,&y);
  295.                 a[x][y]=2;
  296.         }       
  297.         for(i=0;i<k;i++)
  298.         {
  299.                 scanf("%d %d %d",&x,&y,&food[i]);
  300.         }
  301.         for(i=0;i<d;i++)
  302.         {
  303.                 scanf("%d %d",&x,&y);
  304.                 a[x][y]=100;
  305.         }
  306.        
  307.         head=(Node *)malloc(sizeof(Node));
  308.         head->next=NULL;
  309.         head->num=0;
  310.        
  311.         for(i=0;i<k;i++)
  312.         {
  313.                 Move(0,a,x,y,head,n);
  314.                 minx=head->next->num;
  315.                 for(p=head->next->next;p->next!=NULL;p=p->next);
  316.                 {
  317.                         if(p->num<minx)
  318.                                 minx=p->num;
  319.                 }
  320.                 sum+=minx*food[i];
  321.         }
  322.         printf("%d\n",sum);
  323.         return 0;
  324. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

发表于 2019-9-14 15:24:40 | 显示全部楼层
本帖最后由 superbe 于 2019-9-14 18:53 编辑

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.         }
复制代码

小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-9-14 20:07:20 | 显示全部楼层
谢谢你,不过还是不行
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-7-13 00:39

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表