The 12th Zhejiang Provincial Collegiate Programming Contest

题目: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[505][505];
bool vis[505][505];
struct node
{
    int x,y;
    int peln,path;  //惩罚/ 第几层
    int s[55];     //遇到的陷阱,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=0; i<55; i++)
        tmp.s[i]='0';
}
bool tar(node tmp)      //判断是否是目的地
{
    if( tmp.x==tarx && tmp.y==tary )
        return true;
    else
        return false;
}
bool cango(node tmp)      //判断能不能走
{
    if(tmp.x>=0&&tmp.x<n&&tmp.y>=0&&tmp.y<m )
    {
        if( dun[tmp.x][tmp.y]=='#' )
            return false;
        else
            return true;
    }
    else
        return false;
}
void adj_mon(node &tmp)   //计算怪物惩罚
{
    char c1='0',c2='0',c3='0',c4='0', c5='0';       //走过可能干掉3只怪物

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

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

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

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

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

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

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

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

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

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


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

int bfs(node tmp) 
{
    //判断四周有没有能进盏的
    node node1=tmp;
    node1.x-=1;
    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+=1;
    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-=1;
    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+=1;
    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 0;
}

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

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


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


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

        deque<node>::iterator it=anslist.begin();
        int min_path=1247483647;
        int min_pel=1247483647;
        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 0;
}