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

$Description$

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

wdyhy非常喜欢他的爸爸们,所以只要让爸爸们永远呆在wdyhy的迷宫里,wdyhy就可以永远爱着他们啦!
wdyhy有一个R行C列的迷宫,每一个小格有一个字符.
#(number sign) 表⽰一个墙块,
. (dot) 表⽰一块空地,
S (uppercase letter s) 表⽰你现在的位置,
C (uppercase letter c) 表⽰爸爸现在的位置.
你只能通过空地,并且,只有当两块空地有相临边时,你才可以从其中一个走向另一个.特别的,描述在地图里的矩形区域完全被墙块包围.
为了能够更快的到达爸爸的位置,你从迦勒底获得了一个传送枪,它的操作方式如下:任意时候它都可以向上下左右四个方向发射传送门.当一个传送门以某一特定方向发送时,它会沿着此方向飞出直到碰到第一个墙块.当发生上述情况时,一个传送门就会贴在面对着你那面的墙块上.
任意时刻最多只能存在两个传送门.如果迷宫里已经有了两个传送门,那么你可以使用传送枪的另一个功能马上移除一个(由你选定).向一个已经存在的传送门发射时,后发射的传送门会替代原有的,所以每个墙块的每一面最多只会存在一个传送门.注意,可以存在两个传送门在同一墙块上,只要他们所朝方向不同.
当迷宫中存在两个传送门时,你可以通过它们传送自己.当你站在一个传送门旁时,你可以走进传送门然后从另一个传送门走出来到它相邻的空地.这样耗费的时间与你走相邻两个空地的时间是相同的.
你可以假设发射传送门不会耗费任何时间,走相邻两个空地和通过传送门的时间都是1.
那么,你最少需要多长时间才能到爸爸那里.

$Input$

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

$Output$

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

$Sample$ $Input$

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

$Sample$ $Output$

4

$Hint$

$Train$ $of$ $Thought$

很简单能想到BFS
一开始我做的是现向四个方向走一格
然后再向四个方向走到尽头（传送门）（并没有判断附近是否有墙）
然后后来改的时候可能是对$dalao$的思路有一些误解
SPFA建图时只判断了如果一个点的四个方向如果有墙
才能走传送门到一个方向的尽头（改了几个小时，然后发现是伪正解时，心态直接崩了）
然后开始正解：
SPFA照样（应该不用多讲了吧）
只是建图麻烦
每个点有两个要连
一个是四个方向走一格
另一个就是四个方向走到尽头
一个传送门放路的尽头的墙上
那另一个传送门呢？
就要找离这个点最近的一个点
我的方法时朝四个方向走
然后在四个值中取min
就是走传送门的最小代价
在求一个点某方向的尽头时
需要记忆化
否则时间会炸

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;

const int dx[5] = {0, 1, -1, 0, 0};
const int dy[5] = {0, 0, 0, 1, -1};

int Bol[10000005], M[1005][1005], dis[10000005], h[10000005], Get[5], D[10000005][5], F[10000005][5];
int n, m, Ans, Start, End, t, tot;
char c;
struct wh_
{
	int w, h, k;
}wh[10000005];
char read()//交洛谷时要加这个|洛谷数据比较狗(doge)
{
	char c = getchar();
	while(c != '#' && c != '.' && c != 'S' && c != 'C')
		c = getchar();
	return c;
}

bool Check(int x, int y)//判断是否有墙
{
	if(x < 1 || x > n || y < 1 || y > m)return 0;
	if(!M[x][y])return 0;
	return 1;
}

void SPFA(int k)
{
	memset(dis, 0x7f, sizeof(dis));
	queue<int>hy;
	hy.push(k);
	Bol[k] = 1;
	dis[k] = 0;
	while(hy.size())
	{
		int l = hy.front(); hy.pop();
		for(int i = h[l]; i; i = wh[i].h)
			if(dis[l] + wh[i].k <  dis[wh[i].w])
			{
				dis[wh[i].w] = dis[l] + wh[i].k;
				if(!Bol[wh[i].w])
				{
					hy.push(wh[i].w);
					Bol[wh[i].w] = 1;
				}
			}
		Bol[l] = 0;
	}
	
}

void hw(int x, int y, int z)
{wh[++tot] = (wh_){y, h[x], z}; h[x] = tot;}

int Dfs(int x, int y, int k)
{
	int xx = x + dx[k], yy = y + dy[k];
	if(!Check(xx, yy))//若到墙了
	{
		Get[k] = M[x][y];//Get为某一方向走到墙时的点的编号
		D[M[x][y]][k] = Get[k];//D为某点某方向走到墙时的点的编号|记忆化
		return 0;
	}
	if(D[M[x][y]][k])//记忆化
	{
		Get[k] = D[M[x][y]][k];
		return F[M[x][y]][k];
	}
	int l = Dfs(xx, yy, k) + 1;
	D[M[x][y]][k] = D[M[xx][yy]][k];
	return (F[M[x][y]][k] = l);
}

int main()
{
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 1; j <= m; ++j)
		{
			c = read();
			if(c == '#')continue;//不给墙编号（墙什么时候能站起来，气抖冷）
			M[i][j] = ++t;
			if(c == 'S')Start = t;
			else if(c == 'C')End = t;
		}
	}
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= m; ++j)
			if(M[i][j])//若是空地
			{
				memset(Get, 0, sizeof(Get));
				int Min = 1e9;
				for(int k = 1; k <= 4; ++k)
				{
					Min = min(Min, Dfs(i, j, k) + 1);//四个方向到达墙的最小值
					if(Check(i + dx[k], j + dy[k]))//判断是否可以走一格
						hw(M[i][j], M[i + dx[k]][j + dy[k]], 1);
				}
				for(int k = 1; k <= 4; ++k)//传送门
					if(Get[k] != M[i][j])hw(M[i][j], Get[k], Min);
			}
	SPFA(Start);
	printf("%d", dis[End]);
	return 0;
}