Earthstone Keeper 【ZOJ

题目链接

  题意：有一个N*M的图，图上有这样的几种情况：

1. ‘#’，此点为不可达到的点
2. 小写字母，此点有陷进，进去一次就会扣（小写字母-'a'+1）的血
3. 大写字母，有怪兽，如果你走到了怪兽点的毗邻的一个点，怪兽就会冲过来打你了，然后怪兽就死了，于是你会扣（大写字母-'A'+1）的血
4. 其他情况是安全的

  题目要我们求的是：扣血最少的情况下的最短路径。

  于是，就需要考虑一点，就是怪兽你打过一次就打死了，所以再经过这附近的点就不需要再打它了，又有很明显一点就是走回头路肯定不是最优的，所以肯定是走过不再回来了的。

  根据以上的信息，我们如此处理：

  分类讨论：怪物节点与非怪物节点。

  如果它是怪物节点，那么我们需要跳过它，怪物节点有上下左右四个毗邻的方向点，那么每个方向的点向另外三个方向的点各自建一条路径长度为2的，扣血值为终点需要受到的怪兽伤害的值，其中需要避免在起点附近的怪兽造成的旧伤害。

  否则，它是非怪物节点，那么直接考虑它到毗邻的非怪物节点的情况了，为什么不考虑它到毗邻的怪物节点的情况呢？上面已经考虑过了。所以，直接考虑为长度为1，扣血值为终点受到怪物伤害的值，这样的一条边。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define pii pair<int, int>
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int dir[4][2] =
{
    -1, 0,
    0, -1,
    0, 1,
    1, 0
};
const int maxN = 505;
int N, M;
char mp[maxN][maxN];
inline bool In_Map(int x, int y) { return x >= 1 && y>= 1 && x <= N && y <= M && mp[x][y] ^ '#'; }
struct Edge
{
    int nx, ny, hp, step;
    Edge(int a=0, int b=0, int c=0, int d=0):nx(a), ny(b), hp(c), step(d) {}
};
vector<Edge> to[maxN][maxN];
void addEddge(int x, int y, int nx, int ny, int hp, int step) { to[x][y].push_back(Edge(nx, ny, hp, step)); }
void Creat_Graph()
{
    for(int x=1; x<=N; x++)
    {
        for(int y=1; y<=M; y++)
        {
            if(!In_Map(x, y)) continue;
            if(isupper(mp[x][y]))
            {
                for(int i=0, x1, y1; i<4; i++)
                {
                    x1 = x + dir[i][0]; y1 = y + dir[i][1];
                    if(!In_Map(x1, y1)) continue;
                    for(int j=0, x2, y2, hp; j<4; j++)
                    {
                        if(i == j) continue;
                        x2 = x + dir[j][0]; y2 = y + dir[j][1];
                        if(!In_Map(x2, y2)) continue;
                        hp = 0;
                        for(int k=0, x3, y3; k<4; k++)
                        {
                            x3 = x2 + dir[k][0]; y3 = y2 + dir[k][1];
                            if(!In_Map(x3, y3)) continue;
                            if(isupper(mp[x3][y3]) && abs(x3 - x1) + abs(y3 - y1) > 1) hp += mp[x3][y3] - 'A' + 1;
                        }
                        addEddge(x1, y1, x2, y2, hp, 2);
                    }
                }
            }
            else
            {
                for(int i=0, x1, y1, hp; i<4; i++)
                {
                    x1 = x + dir[i][0]; y1 = y + dir[i][1];
                    if(!In_Map(x1, y1) || isupper(mp[x1][y1])) continue;
                    hp = 0;
                    for(int j=0, x2, y2; j<4; j++)
                    {
                        x2 = x1 + dir[j][0]; y2 = y1 + dir[j][1];
                        if(!In_Map(x2, y2)) continue;
                        if(isupper(mp[x2][y2])) hp += mp[x2][y2] - 'A' + 1;
                    }
                    addEddge(x, y, x1, y1, hp, 1);
                }
            }
        }
    }
}
struct node
{
    int x, y; pii val;
    node(int a=0, int b=0, pii c=MP(0, 0)):x(a), y(b), val(c) {}
    friend bool operator < (node e1, node e2) { return e1.val.first == e2.val.first ? e1.val.second > e2.val.second : e1.val.first > e2.val.first; }
} now;
priority_queue<node> Q;
int sx, sy, tx, ty;
pii dis[maxN][maxN];
void Dijkstra()
{
    while(!Q.empty()) Q.pop();
    for(int i=1; i<=N; i++) for(int j=1; j<=M; j++) dis[i][j] = MP(INF, INF);
    dis[sx][sy] = MP(0, 0);
    Q.push(node(sx, sy, MP(0, 0)));
    int x, y, xx, yy; pii val, nex_val;
    while(!Q.empty())
    {
        now = Q.top(); Q.pop();
        x = now.x; y = now.y; val = now.val;
        if(x == tx && y == ty) { printf("%d %d
", now.val.first, now.val.second); return; }
        if(dis[x][y] < now.val) continue;
        for(Edge V : to[x][y])
        {
            xx = V.nx; yy = V.ny;
            nex_val.first = val.first + V.hp;
            nex_val.second = val.second + V.step;
            if(islower(mp[xx][yy])) nex_val.first += mp[xx][yy] - 'a' + 1;
            if(dis[xx][yy] > nex_val)
            {
                dis[xx][yy] = nex_val;
                Q.push(node(xx, yy, nex_val));
            }
        }
    }
}
int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &N, &M);
        scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
        for(int i=1; i<=N; i++) scanf("%s", mp[i] + 1);
        for(int i=1; i<=N; i++) for(int j=1; j<=M; j++) to[i][j].clear();
        Creat_Graph();
        Dijkstra();
    }
    return 0;
}