稍微有点坑的bfs

[USACO11OPEN]Corn Maze S

题面翻译

奶牛们去一个 $N\times M$ 玉米迷宫，$2\le N\le 300,2\le M\le 300$。

迷宫里有一些传送装置，可以将奶牛从一点到另一点进行瞬间转移。这些装置可以双向使用。

如果一头奶牛处在这个装置的起点或者终点，这头奶牛就必须使用这个装置。

玉米迷宫除了唯一的一个出口都被玉米包围。

迷宫中的每个元素都由以下项目中的一项组成：

1. 玉米，# 表示，这些格子是不可以通过的。
2. 草地，. 表示，可以简单的通过。
3. 传送装置，每一对大写字母 $\mathtt{A}$ 到 $\mathtt{Z}$ 表示。
4. 出口，= 表示。
5. 起点， @ 表示

奶牛能在一格草地上可能存在的四个相邻的格子移动，花费 $1$ 个单位时间。从装置的一个结点到另一个结点不花时间。

题目描述

This past fall, Farmer John took the cows to visit a corn maze. But this wasn’t just any corn maze: it featured several gravity-powered teleporter slides, which cause cows to teleport instantly from one point in the maze to another. The slides work in both directions: a cow can slide from the slide’s start to the end instantly, or from the end to the start. If a cow steps on a space that hosts either end of a slide, she must use the slide.

The outside of the corn maze is entirely corn except for a single exit.

The maze can be represented by an N x M (2 <= N <= 300; 2 <= M <= 300) grid. Each grid element contains one of these items:

* Corn (corn grid elements are impassable)

* Grass (easy to pass through!)

* A slide endpoint (which will transport a cow to the other endpoint)

* The exit

A cow can only move from one space to the next if they are adjacent and neither contains corn. Each grassy space has four potential neighbors to which a cow can travel. It takes 1 unit of time to move from a grassy space to an adjacent space; it takes 0 units of time to move from one slide endpoint to the other.

Corn-filled spaces are denoted with an octothorpe (#). Grassy spaces are denoted with a period (.). Pairs of slide endpoints are denoted with the same uppercase letter (A-Z), and no two different slides have endpoints denoted with the same letter. The exit is denoted with the equals sign (=).

Bessie got lost. She knows where she is on the grid, and marked her current grassy space with the ‘at’ symbol (@). What is the minimum time she needs to move to the exit space?

输入格式

第一行：两个用空格隔开的整数 $N$ 和 $M$。

第 $2\sim N+1$ 行：第 $i+1$ 行描述了迷宫中的第 $i$ 行的情况（共有$M$个字符，每个字符中间没有空格）。

输出格式

一个整数，表示起点到出口所需的最短时间。

样例 #1

样例输入 #1

5 6
###=##
#.W.##
#.####
#.@W##
######

样例输出 #1

3

提示

例如以下矩阵，$N=5,M=6$。

###=##
#.W.##
#.####
#.@W##
######

唯一的一个装置的结点用大写字母 $\mathtt{W}$ 表示。

最优方案为：先向右走到装置的结点，花费一个单位时间，再到装置的另一个结点上，花费 $0$ 个单位时间，然后再向右走一个，再向上走一个，到达出口处，总共花费了 $3$ 个单位时间。`

题解：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <map>
#include <queue>
#define pii pair<int,int>
using namespace std;
int N, M, sx, sy, dx[4] = { -1,0,1,0 }, dy[4] = { 0,1,0,-1 };
char a[301][301]; bool vis[301][301] = { 0 };

struct Teleport {
    int x1, y1, x2, y2, sum;
    Teleport():sum(0) {}
    pii get_partner(int x, int y) {
        if (x == x1 && y == y1)
            return { x2,y2 };
        else
            return { x1,y1 };
    }
}t[26];

struct Node {
    pii p; int steps;
    Node(pii pp, int st) :p(pp), steps(st) {}
};

int bfs() {
    queue<Node> q;
    q.push(Node({ sx, sy }, 0));
    vis[sx][sy] = 1;
    while (q.size()) {
        int curx = q.front().p.first, cury = q.front().p.second, step = q.front().steps;
        q.pop();
        for (int i = 0; i < 4; i++) {
            int tx = curx + dx[i], ty = cury + dy[i];
            if (tx > 0 && ty > 0 && tx <= N && ty <= M && a[tx][ty] != '#' && !vis[tx][ty]) {
                if (a[tx][ty] >= 'A' && a[tx][ty] <= 'Z') {
                    pii temp = t[a[tx][ty] - 'A'].get_partner(tx, ty);
                    q.push(Node(temp, step + 1));
                    vis[tx][ty] = 1;
                }
                else if (a[tx][ty] == '=') {
                    return step + 1;
                }
                else if (a[tx][ty] == '.') {
                    q.push(Node({ tx,ty }, step + 1));
                    vis[tx][ty] = 1;
                }
            }
        }
    }
    return -1;
}

int main()
{
    //freopen("IN.txt", "r", stdin);
    cin >> N >> M;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= M; j++) {
            cin >> a[i][j];
            if (a[i][j] >= 'A' && a[i][j] <= 'Z') {
                if (t[a[i][j] - 'A'].sum == 0)
                    t[a[i][j] - 'A'].x1 = i, t[a[i][j] - 'A'].y1 = j, t[a[i][j] - 'A'].sum++;
                else
                    t[a[i][j] - 'A'].x2 = i, t[a[i][j] - 'A'].y2 = j, t[a[i][j] - 'A'].sum++;
            }
            else if (a[i][j] == '@') {
                sx = i, sy = j;
            }
        }
    }
    cout << bfs();
    return 0;
}

bfs的思路不想说了，这题主要坑了我两点：

• 传送门不一定只使用了一次，考虑一种极端的情况：

  
  在这种情况下，走寻常路已经无路可走，必须通过传送门中转一下才能到达出口，最短时间为4。

• 如何让传送门多次使用而不重复？

  既然可能多次使用传送门，就不得不思考传送门到底能用多少次。上图的例子其实已经说明，传送门最多只能使用两次，一种是通过传送门跳到下一个离出口更近的点，这种情况传送门用一次就够了；另一种则是just路过一下传送门，这种情况传送门就要用两次，因为踩到传送门就必须传送。。。走个过场也要踩个两回。

  但是仅仅用次数就能判断吗，简单的对每一对传送门计数，超过2次就不可用了吗？不！

  
  这是张很有意思的图，从起点出发，上右下左都可走，但是现在我们先只看上和右的情况。

  如果向上走，那么要想走到终点，肯定要踩传送门，于是传送门被使用了一次，另一个传送门的位置入队。

  然后按照bfs顺序，这时候应该去访问右边，而不是顺着传送门继续走。

  向右走的话，那么要想走到终点，肯定又要踩传送门，于是传送门又被使用了一次。

  至此，传送门已经使用了两次，不能再用了，但是队列里还有两个对面传送门的结点，而且这两结点也没用了，因为这对传送门已失效，回不来了。显然是不合理的。

  我的想法是，既然上和右是等效的，那只走其中一个就好了嘛
  所以，传送过去的时候，我给传送起点标记已访问，终点不标记，方便它传回来，这样右的情况就访问不了传送起点。然后传送回来的时候，这时候原来的传送终点变成起点了，我再把这个起点标记已访问，至此，这个传送门就已完成它的使命。

然后除了这两个坑点，再浅说一下怎么查询传送门的坐标：

• 先明白一点，‘B’=‘A’+1，‘C’=‘A’+2…‘Z’=‘A’+25，这是通过ASCII码值来计算的，设计一个结构体，里面存放每对传送门的两个坐标。
• 然后创建一个大小为26的结构体数组，通过ASCII码值就可以实现随机存取啦，而且使用的空间还是常数阶的。比如，数组名为t，则要查询’B’号传送门，则直接用t[‘B’-‘A’]就能够实现了。