【2020.8.23NOIP模拟赛】【图论】【最短路】传送爸爸

题目背景

wdyhy非常喜欢他的爸爸们，所以只要让爸爸们永远呆在wdyhy的迷宫里，wdyhy就可以永远爱着他们啦！

题目描述

wdyhy有一个$R$行$C$列的迷宫，每一个小格有一个字符。

#(number sign) 表⽰一个墙块，

. (dot) 表⽰一块空地，

S (uppercase letter s) 表⽰你现在的位置，

C (uppercase letter c) 表⽰爸爸现在的位置。

你只能通过空地，并且，只有当两块空地有相临边时，你才可以从其中一个走向另一个。特别的，描述在地图里的矩形区域完全被墙块包围。

为了能够更快的到达爸爸的位置，你从迦勒底获得了一个传送枪，它的操作方式如下：任意时候它都可以向上下左右四个方向发射传送门。当一个传送门以某一特定方向发送时，它会沿着此方向飞出直到碰到第一个墙块。当发生上述情况时，一个传送门就会贴在面对着你那面的墙块上。

任意时刻最多只能存在两个传送门。如果迷宫里已经有了两个传送门，那么你可以使用传送枪的另一个功能马上移除一个（由你选定）。向一个已经存在的传送门发射时，后发射的传送门会替代原有的,所以每个墙块的每一面最多只会存在一个传送门。注意，可以存在两个传送门在同一墙块上，只要他们所朝方向不同。

当迷宫中存在两个传送门时，你可以通过它们传送自己。当你站在一个传送门旁时，你可以走进传送门然后从另一个传送门走出来到它相邻的空地，这样耗费的时间与你走相邻两个空地的时间是相同的。

你可以假设发射传送门不会耗费任何时间，走相邻两个空地和通过传送门的时间都是$1$。 那么,你最少需要多长时间才能到爸爸那里。

输入格式

输入文件第一行包括两个整数：地图的行数$R$和列数$C$。接下来的$R$行描述这个地图。每一行包括$C$个字符：#,.,S或C（含义已在上文描述）。

输出格式

输出一个整数——从你现在位置出发到达爸爸的位置所需要的最少时间。

输入输出样例

输入 #1

4 4
.#.C
.#.#
....
S...

输出 #1

4

说明/提示

---

解题思路

对于每个不是墙块的点，首先对四个方向连边
再考虑发射传送门，我们发现对四个方向的墙块距离，是最近墙块的距离
从蓝块出发，假设走到$T$块前的空地距离是$S$，那么走到其它三块的距离就是从$T$块的传送门走，距离是$S+1$

跑一遍$SPFA$

由于每次找四周砖块的距离过长，所以要用记忆化搜索记录每个点到砖块的距离，缩短时间

另外，每个点$(i,j)$的编号是$(i-1)\ast m+j$

---

Code

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
const int way[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
struct DT{
	int to, s, next;
}a[1000100 * 8];
struct demo{
	int l, x, y;
}bj[10001000][4];
char c;
int n, m, num, sx, sy, ex, ey, x, y, z;
int head[10000100], dis[10001000], v[20000100], use[10000100], f[10000100],vv[10000100];
bool check (int x, int y){//判断有无超界（注意：超界的是墙）
	return (x <= n && x > 0 && y <= m && y > 0);
}
void add (int x, int y, int s){//邻接表建边
	a[++num].to = y, a[num].s = s, a[num].next = head[x], head[x] = num;
}
int getnum (int x, int y){  //去每个点的标号
	return ((x - 1) * m + y);
}
void dfs (int xx, int yy, int ss, int k){ //记忆化搜索每个点到墙的距离
    int bi = getnum(xx, yy);
	if (!f[bi] || !check(xx, yy))//如果走到了墙，
		x = xx - way[k][0], y = yy - way[k][1], z = ss - 1; //返回
	else if (!bj[bi][k].l) //如果原本没有数，那么就更新
    	{  
    		dfs (xx + way[k][0], yy + way[k][1], ss+1, k);
    		bj[bi][k].l = z - ss, bj[bi][k].x = x, bj[bi][k].y = y;
    	}else //原本有数，可以直接利用记忆化数组
		  x = bj[bi][k].x, y = bj[bi][k].y, z = bj[bi][k].l + ss;
}
void SPFA (int x, int y){//模板SPFA
	memset (dis, 0x3f, sizeof (dis));
	int h = 0, t = 1;
	v[t] = getnum (x, y);
	dis[v[t]] = 0, use[v[t]] = 1;
    while (h++ < t)
    {
    	for (int i = head[v[h]]; i; i = a[i].next)
    		if (dis[v[h]] + a[i].s < dis[a[i].to])
    		{
    			dis[a[i].to] = dis[v[h]] + a[i].s; 
    			if (!use[a[i].to])
    			{
    				use[a[i].to] = 1;
    				v[++t] = a[i].to;
    			}
    		}
    	use[v[h]]=0;
    }
}
int main(){
	scanf ("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
	    for (int j = 1; j <= m; j++)
		{
			cin >> c;
			if (c != '#')
			    f[getnum (i, j)] = 1; 
			if (c == 'S')
			    sx = i, sy = j;
			 else if (c == 'C')
			         ex = i, ey = j;
		} 
	//输入 + 标记 + 记录起、终点
	for (int i = 1; i <= n; i++)
	    for (int j = 1; j <= m; j++)
	    {
	    	if (!f[getnum (i, j)]) continue;
	    	int s = 0x3fffffff;
	    	int l[4];
	    	for (int k = 0; k < 4; k++)
	    	{
	    		x = i + way[k][0], y = j + way[k][1];
	    		if (check(x, y) && f[getnum(x, y)])
	    		   add (getnum (i, j), getnum (x, y), 1);
	    		//向四周走一步
	    		x = 0; 
	    		dfs (i, j, 0, k);
				l[k] = getnum (x, y);
				s = min (s, z + 1);//s记录离四周墙最短的距离
	    	}
	    	for (int k = 0; k < 4; k++)
	    		if (l[k] != getnum (i, j))//不用连最近的那个墙，因为不会有其它传送门缩短这段距离
			    add (getnum (i, j), l[k], s);
			//向墙连边
	    }
	//预处理（建图）

	SPFA(sx, sy);
	printf ("%d", dis[getnum(ex,ey)]);
}