The 12th Zhejiang Provincial Collegiate Programming Contest - I Earthstone Keeper浙江省赛

题目:http://acm.zju.edu.cn/onlinejudge/showContestProblem.do?problemId=5501

思路：DFS，用了递归就溢出，所以可能得用非递归的。把所有可能到达终点的可能路径都计算，最后比较找最佳。限制条件很多，要细打细算。很烦，不想改了再试，写了很久了

 #include <iostream>
 #include <cstdio>
 #include <string>
 #include <map>
 #include <deque>
 #include <stack>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 char dun[][];
 bool vis[][];
 struct node
 {
     int x,y;
     int peln,path;  //惩罚/ 第几层
     int s[];     //遇到的陷阱,26开始就是A
 };
 stack<node> que;
 deque<node> anslist;

 int stax, stay;
 int tarx, tary;
 int n, m;
 int fat, mins;

 void init(node &tmp)        //初始化怪物标记s
 {
     for(int i=; i<; i++)
         tmp.s[i]='';
 }
 bool tar(node tmp)      //判断是否是目的地
 {
     if( tmp.x==tarx && tmp.y==tary )
         return true;
     else
         return false;
 }
 bool cango(node tmp)      //判断能不能走
 {
     if(tmp.x>=&&tmp.x<n&&tmp.y>=&&tmp.y<m )
     {
         if( dun[tmp.x][tmp.y]=='#' )
             return false;
         else
             return true;
     }
     else
         return false;
 }
 void adj_mon(node &tmp)   //计算怪物惩罚
 {
     char c1='',c2='',c3='',c4='', c5='';       //走过可能干掉3只怪物

     if( isupper( dun[tmp.x][tmp.y] )  )  //是怪物
     {
         c1=dun[tmp.x][tmp.y];
     }

     node node1=tmp;
     node1.x-=;
     if( cango(node1)&&isupper( dun[tmp.x-][tmp.y] )  )  //是怪物
     {
         c2=dun[tmp.x-][tmp.y];
         //cout<<"begin"<<endl;
     }

     node1=tmp;
     node1.x+=;
     if( cango(node1)&&isupper( dun[tmp.x+][tmp.y] )  )  //是怪物
     {
         c3=dun[tmp.x+][tmp.y];
         //cout<<"begin"<<endl;
     }

     node1=tmp;
     node1.y+=;
     if( cango(node1)&&isupper( dun[tmp.x][tmp.y+] )  )  //是怪物
     {
         c3=dun[tmp.x][tmp.y+];
         //cout<<"begin"<<endl;
     }

     node1=tmp;
     node1.y-=;
     if( cango(node1)&&isupper( dun[tmp.x][tmp.y-] )  )  //是怪物
     {
         //cout<<"begin"<<endl;
         c5=dun[tmp.x][tmp.y-];
     }

 //*************************************
     if(c1!=''&&tmp.s[ c1-'A'+ ]=='')
     {
         tmp.s[ c1-'A'+ ]=true;
         tmp.peln+=( c1-'A'+ );
         //cout<<"begin"<<endl;
     }

     if(c2!=''&&tmp.s[ c2-'A'+ ]=='')
     {
         tmp.s[ c2-'A'+ ]=true;
         tmp.peln+=( c2-'A'+ );
         //cout<<"begin"<<endl;
     }

     if(c3!=''&&tmp.s[ c3-'A'+ ]=='')
     {
         tmp.s[ c3-'A'+ ]=true;
         tmp.peln+=(c3-'A'+);
         //cout<<"begin"<<endl;
     }

     if(c4!=''&&tmp.s[ c4-'A'+ ]=='')
     {
         tmp.s[ c4-'A'+ ]=true;
         tmp.peln+=(c4-'A'+);
         //cout<<"begin"<<endl;
     }

     if(c5!=''&&tmp.s[ c5-'A'+ ]=='')
     {
         tmp.s[ c5-'A'+ ]=true;
         tmp.peln+= c5-'A'+;
         //cout<<"begin"<<endl;
     }

 }
 void trap(node &tmp)        //计算陷阱惩罚
 {
     if( islower(dun[tmp.x][tmp.y]) )   //陷阱
         tmp.peln += (dun[tmp.x][tmp.y] - 'a'+);
 }
 void cal_pel(node &tmp)      //计算惩罚
 {
     trap(tmp);
     adj_mon(tmp);
 }

 int bfs(node tmp)
 {
     //判断四周有没有能进盏的
     node node1=tmp;
     node1.x-=;
     if(cango(node1))    //合法
     {

         cal_pel(node1);
         node1.path++;
         if(tar(node1))
             anslist.push_back(node1);
         else if(vis[node1.x][node1.y]==false)                           //非目的
         {
             que.push(node1);
             vis[node1.x][node1.y]=true;
             bfs(node1);
             que.pop();
             vis[node1.x][node1.y]=false;

         }

     }

     node1=tmp;
     node1.x+=;
     if(cango(node1))    //合法
     {
         cal_pel(node1); node1.path++;
         if(tar(node1))
             anslist.push_back(node1);
         else if(vis[node1.x][node1.y]==false)                 //非目的
         {
             que.push(node1);
             vis[node1.x][node1.y]=true;
             bfs(node1) ;
             que.pop();
             vis[node1.x][node1.y]=false;
         }
     }

     node1=tmp;
     node1.y-=;
     if(cango(node1))    //合法
     {
         cal_pel(node1); node1.path++;
         if(tar(node1))
             anslist.push_back(node1);
         else if(vis[node1.x][node1.y]==false)                 //非目的
         {
             que.push(node1);
             vis[node1.x][node1.y]=true;
             bfs(node1) ;
             que.pop();
             vis[node1.x][node1.y]=false;
         }
     }

     node1=tmp;
     node1.y+=;
     if(cango(node1))    //合法
     {
         cal_pel(node1); node1.path++;
         if(tar(node1))
             anslist.push_back(node1);
         else if(vis[node1.x][node1.y]==false)               //非目的
         {
             que.push(node1);
             vis[node1.x][node1.y]=true;
             bfs(node1) ;
             que.pop();
             vis[node1.x][node1.y]=false;
         }

     }
     return ;
 }

 int main()
 {
     //freopen("input.txt", "r", stdin);
     int t;
     cin>>t;
     while(t--)
     {
         anslist.clear();
         memset(dun, , sizeof(dun));
         memset(vis, , sizeof(vis));

         cin>>n>>m;
         cin>>stax>>stay>>tarx>>tary;
         stax-=;stay-=;tarx-=;tary-=;

         for(int i=; i<n; i++)
             for(int j=; j<m; j++)
                 cin>>dun[i][j];

         node tmp;
         init(tmp);
         tmp.x=stax; tmp.y=stay; tmp.peln=; tmp.path=; //起点
         vis[tmp.x][tmp.y]=true;
         que.push(tmp); //先进队
         bfs(que.top());

         deque<node>::iterator it=anslist.begin();
         int min_path=;
         int min_pel=;
         for( ; it!=anslist.end(); it++)
         {
             //cout<<it->peln<<" "<<it->path<<endl;

             if(it->peln<=min_pel&&it->path<=min_path)
             {
                 min_pel=it->peln;
                 min_path=it->path;
             }

         }
         cout<<min_pel<<" "<<min_path<<endl;

     }

     return ;
 }

递归式的，seg错