传送爸爸【图论】【SPFA】【记忆化搜索】

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

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

. (dot) 表⽰一块空地，

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

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

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

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

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

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

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

---

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

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

---

>Sample Input
4 4
.#.C
.#.#
…
S…

>Sample Output
4

---

>解题思路
一道dogT

样例的图：

基本思路：对于输入的数据我们需要建一个图，然后跑spfa

如何建图？

1. 空地对四周的空地连一条边权为1的边
2. 传送门：空地对四周离得最近的墙都可以建传送门，所以我们暴力求出四周最近的墙，建边，边权为四周这四面墙中离当前点最近的那条路径，因为我们可以走到离得最近的墙再传送到其它的墙，注意传送需要+1

对于lyf巨爷提出的类似建门转弯再建门的最优方案，其实也可以用这种方法向四周建两个门用最小代价到达爸爸

然后由于暴力找墙这里，路径可能特别大就会tle，所以我们需要用到记忆化搜索，记录每个点同一方向最近的墙及路径长度，这样就不用重复跑很长的路。注意经过的每个点都要标记！

最后的最后，洛谷的输入数据会很狗，所以输入这里要用到类似快读这样的while语句判断输入 不然就5分

---

>代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#define N 1005
using namespace std;

const int xxx[4] = {-1, 0, 0, 1}, yyy[4] = {0, -1, 1, 0};
struct line
{
	int to, next, c;
} a[8 * N * N];
int n, m, S, T, t, h[N * N], c[N * N], s[N * N][5], ex[N * N][5], ey[N * N][5];
int eex, eey, es;
bool yd[N * N];
char cc, p[N][N];

void add (int u, int v, int l)
{
	a[++t] = (line) {v, h[u], l}; h[u] = t;
}
bool check (int x, int y)
{
	if (p[x][y] == '#') return 1;
	if (x < 1 || x > n || y < 1 || y > m) return 1;
	return 0;
} //判断是否为墙
int getnum (int x, int y) {return (x - 1) * m + y;} //二维换一维
void dfs (int x, int y, int i, int ss)
{
	if (check (x + xxx[i], y + yyy[i]))
	{
		eex = x; eey = y;
		es = ss; //记录我们要求的数据
		return;
	}
	if (!ex[getnum (x, y)][i])
	{
		dfs (x + xxx[i], y + yyy[i], i, ss + 1);
		s[getnum (x, y)][i] = es - ss; //注意这里s对于每个点是不同的
		ex[getnum (x, y)][i] = eex;
		ey[getnum (x, y)][i] = eey; //每个点标记
	}
	else
	{
		int lx = x, ly = y;
		ss += s[getnum (lx, ly)][i];
		x = ex[getnum (lx, ly)][i];
		y = ey[getnum (lx, ly)][i];
		dfs (x, y, i, ss);
	}
} //记忆化搜索墙
void find (int x, int y)
{
	for (int i = 0; i < 4; i++)
	{
		int xx = x + xxx[i], yy = y + yyy[i];
		if (check (xx, yy)) continue;
		add (getnum (x, y), getnum (xx, yy), 1); //四周建边
	}
	int l[5], k[5], minn = 1000;
	for (int i = 0; i < 4; i++)
	{
		eex = eey = es = 0;
		dfs (x, y, i, 0);
		minn = min (minn, es); //最近的墙
		k[i] = es;
		l[i] = getnum (eex, eey);
	} //找墙
	for (int i = 0; i < 4; i++)
	  if (k[i] != minn) add (getnum (x, y), l[i], minn + 1); //建边
	  //如果不用传送门就已经是最短路就不用加边了，因为可以通过四周加的边走到那（阿巴阿巴）
}
void spfa ()
{
	memset (c, 0x7f, sizeof (c));
	queue<int> st;
	st.push (S); c[S] = 0; yd[S] = 1;
	while (!st.empty ())
	{
		int u = st.front ();
		st.pop ();
		for (int i = h[u]; i; i = a[i].next)
		  if (c[u] + a[i].c < c[a[i].to])
		  {
		  	c[a[i].to] = c[u] + a[i].c;
		  	if (!yd[a[i].to])
		  	{
		  		yd[a[i].to] = 1;
		  		st.push (a[i].to);
		  	}
		  }
		yd[u] = 0;
	}
}

int main()
{
	scanf ("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
	  for (int j = 1; j <= m; j++)
	  {
	  	cc = getchar();
		while (cc != '#' && cc != '.' && cc != 'S' && cc != 'C')
		  cc = getchar();
		p[i][j] = cc;
	  }
	for (int i = 1; i <= n; i++)
	  for (int j = 1; j <= m; j++)
	  {
	  	if (p[i][j] == '#') continue;
	    find (i, j);
	    if (p[i][j] == 'S') S = getnum (i, j);
	    if (p[i][j] == 'C') T = getnum (i, j);
	  }
	spfa ();
	printf ("%d", c[T]);
	return 0;
}

本文地址：https://blog.csdn.net/qq_43010386/article/details/108187028