解决啦，哈哈哈哈

谢坡坡

1. #include<stdio.h>
   
2. 
   
3. #define M 8   //行数  
   
4. #define N 8     //列数  
   
5. 
   
6. int mg[M+2][N+2]={      //一个迷宫，其四周要加上均为1的外框  
   
7.                     {1,1,1,1,1,1,1,1,1,1},  
   
8.                     {1,0,0,0,0,0,0,0,0,1},  
   
9.                     {1,0,0,1,1,0,1,1,0,1},  
   
10.                     {1,0,0,1,0,0,1,0,0,1},  
    
11.                     {1,0,1,1,1,0,1,1,0,1},  
    
12.                     {1,0,0,1,0,0,1,0,0,1},  
    
13.                     {1,0,0,1,1,0,1,0,0,1},  
    
14.                     {1,0,1,0,0,0,0,1,0,1},  
    
15.                     {1,0,0,0,0,1,0,0,0,1},  
    
16.                     {1,1,1,1,1,1,1,1,1,1}  
    
17. };
    
18. int GS[10][10]={0}; //定义一个二维数组，来存储怪兽的伤害
    
19. struct migong{  
    
20.     int i;      //路径横坐标  
    
21.     int j;      //路径纵坐标  
    
22.     int di;     //方向  
    
23. }Stack[100],Path[100];      //定义栈和存放最短路径的数组  
    
24. int top=-1;     //栈顶指针，空时为-1  
    
25. int sum=0;     //伤害
    
26. int min = 1000000;//最小的伤害
    
27. int minlen=0;//最小伤害对应的路径
    
28. void Printmap()//地图的初始化函数
    
29. {
    
30.         int i,j;
    
31.         for(i=0;i<M+2;i++)
    
32.         {
    
33.                 for(j=0;j<N+2;j++)
    
34.                 {
    
35.                         if(mg[i][j] == 1)
    
36.                         {
    
37.                                 printf("█");
    
38.                         }
    
39.                         else
    
40.                         {
    
41.                                 printf(" ");
    
42.                         }
    
43.                 }
    
44.                 printf("\n");
    
45.         }
    
46. }
    
47. void StartGS()//怪兽地图的初始化
    
48. {
    
49.         int you=srand(time(0));//产生一个随机种子
    
50.         int i,j;
    
51.         for(i=0;i<10;i++)
    
52.         {
    
53.                 for(j=0;j<10;j++)
    
54.                 {
    
55.                         GS[i][j]=rand(you)%100+1;//产生一个1~100的随机数
    
56.                 }
    
57.         }
    
58. }  
    
59. void mgpath()
    
60. {      //路径为:(1,1)->(M,N)  
    
61.     int i,j,di,find,k;  
    
62.     top++;
    
63.         Stack[top].i=1;
    
64.         Stack[top].j=1;
    
65.         Stack[top].di=-1;  //第一个点入栈
    
66.     mg[1][1]=-1;        //在地图上做标记
    
67. 
    
68.     while(top>-1)
    
69.         {      //栈不空时循环  
    
70.         i=Stack[top].i;
    
71.                 j=Stack[top].j;
    
72.                 di=Stack[top].di; //方向标记
    
73.                
    
74.         if(i==M && j==N)
    
75.                 {       //找到了出口，输出路径  
    
76.             printf("路径：");  
    
77.             for(k=0;k<=top;k++) //输出整个队列
    
78.                         {  
    
79.                 printf("(%d,%d)  ",Stack[k].i,Stack[k].j);
    
80.                                 sum+=GS[Stack[k].i][Stack[k].j]; //计算伤害
    
81.                 if((k+1)%5==0)      //输出时每5个结点换一行  
    
82.                     printf("\n\t");  
    
83.             }
    
84.                         printf("此路径的伤害是%d",sum);//输出对应的伤害
    
85.             printf("\n");  
    
86.             if(sum<min)
    
87.                         {       //比较输出最小路径  
    
88.                 for(k=0;k<=top;k++)  
    
89.                     Path[k]=Stack[k]; //对应的路径进栈
    
90.                                 minlen = top++;
    
91.                 min=sum;  
    
92.             }
    
93.                         sum=0;//清零，等待下一次的计算
    
94.             mg[Stack[top].i][Stack[top].j]=0;   //让该位置变为其他路径的可走结点  
    
95.             top--;  
    
96.             i=Stack[top].i;j=Stack[top].j;di=Stack[top].di;  
    
97.         }
    
98.                
    
99.         find=0;  
    
100.         while(di<4 && find==0)
     
101.                 {     //找下一个可走结点  
     
102.             di++;  
     
103.             switch(di)
     
104.                         {  
     
105.                 case 0:i=Stack[top].i-1;j=Stack[top].j;break;   //上面  
     
106.                 case 1:i=Stack[top].i;j=Stack[top].j+1;break;   //右边  
     
107.                 case 2:i=Stack[top].i+1;j=Stack[top].j;break;   //下面  
     
108.                 case 3:i=Stack[top].i;j=Stack[top].j-1;break;   //左边  
     
109.             }  
     
110.             if(mg[i][j]==0)  
     
111.                 find=1;  
     
112.         }  
     
113.         if(find == 1)
     
114.                 {      //找到了下一个可走结点  
     
115.             Stack[top].di=di;   //修改原栈顶元素的di值  
     
116.             top++;      //下一个可走结点进栈  
     
117.             Stack[top].i=i;  
     
118.             Stack[top].j=j;  
     
119.             Stack[top].di=-1;  
     
120.             mg[i][j]=-1;        //避免重复走到该结点  
     
121.         }
     
122.                 else
     
123.                 {  
     
124.             mg[Stack[top].i][Stack[top].j]=0;   //让该位置变为其他路径的可走结点  
     
125.             top--;  
     
126.         }  
     
127.     }  
     
128.     printf("最小伤害路径如下:\n");  
     
129.     printf("最小伤害伤害是  %d\n",min);  
     
130.     printf("路径:  ");  
     
131.     for(k=0;k<minlen;k++)
     
132.         {  
     
133.         printf("(%d,%d)  ",Path[k].i,Path[k].j);  
     
134.         if((k+1)%5==0)      //输出时每5个结点换一行  
     
135.             printf("\n\t");  
     
136.     }  
     
137.     printf("\n");  
     
138. }  
     
139. int main()
     
140. {
     
141.         printf("dituruxia;");
     
142.         Printmap();
     
143.         StartGS();
     
144.     printf("迷宫所有的路径如下:\n");  
     
145.     mgpath();  
     
146.     return 0;  
     
147. }

复制代码

U201010009

自己想想还是有解决方案的。地图里还有怪兽是什么鬼？