[Codeforces 274E]:Mirror Room（模拟）

题目传送门

---

题目描述

有一个$n\times m$的格子图，其中有一些是黑色的，另一些为白色。
从某个白色格子的中心点向左上（$NW$），左下（$SW$），右上（$NE$），右下（$SE$）四个方向中的一个发出一束光线，若光线碰到黑色格子或者墙壁（即边界）会反射。反射情况如图所示：

我们不难发现，光线能穿过的格子总数是可以算出的。假如光线经过了某个格子的中心，则称光线经过了这个格子。求光线经过的格子总数。
由于答案可能很大，请使用$long\ long$的$C++$选手注意:请勿使用$\%lld$，推荐$cout$或者$\%I64d$

---

输入格式

第一行三个整数$n$、$m$、$k$，接下来$k$行每行两个整数$x_i$和$y_i$，表示第$i$个堵塞的格子的坐标。
最后一行两个整数$x_s,y_s$和一个字符串表示激光发出的方向。$“NE”,“NW”,“SE”,“SW”$分别表示方向$(-1,1),(-1,-1),(1,1),(1,-1)$。
保证输入的堵塞的格子坐标不重复。

---

输出格式

一行输出光束至少通过一次的空格子数。

---

样例

样例输入

7 5 3
3 3
4 3
5 3
2 1 SE

样例输出

14

---

数据范围与提示

$30\%$的数据，$n,m \leqslant 30$。

$60\%$的数据，$n,m \leqslant 1000$。

另$20\%$的数据，$k=0$。

$100\%$的数据，$n,m,k \leqslant 100,000$

---

题解

$30\%$算法：

我觉得这是这道题的难点所在，因为我到现在还想不出来$30\%$的算法怎么打。

$60\%$算法：

稍加思考，发现如果重复经过了某种状态，肯定已经循环过了一次。

想一想，一共有$n^2$个格子，$4$个方向，那么就有$4 \times n^2$个状态，暴力进去搜就好了。

不过需要注意以下几点：

　　$1.$只有当当前状态被访问过了才可以跳出，并不是当前格子被访问过了。

　　$2.$如果当前状态没有被访问过，但是当前格子被访问过了，答案不变。

时间复杂度：$O(4\times n^2)$。

期望得分：$60$分。

实际得分：$60$分。

另$20\%$算法：

考虑$k=0$，意思就是说，中间没有任何堵塞的格子，那么分为一下三种情况：

　　$1.$如果$n \neq m$，那么不管从那个点往哪个方向出发，都一定把整张图全跑一遍，答案即为$n \times m$，记得开$long long$就好了。

　　$2.$如果$n=m$，光线沿对角线发射，那么它会射到对角，再反弹回来，答案即为$n$。

　　$3.$还是$n=m$，但是光线不沿对角线发射，那么它会转一圈，答案即为$2 \times n$。

期望多得分数：$10$分。

$100\%$算法：

　　看一眼那$10^5$的数据范围，直接存图显然是不能接受的，那么我们这么考虑这个问题，用一个set存图，然后每次用二分法计算出下一个转向的位置，将答案加上，转向次数是$O(n+m+k)$级别的，每次查询是$O(\log k)$级别的，那么我们的理论最劣时间复杂度为：$O((n+m+k)\log k)$。

　　根据题目中光线反射的方式，可以发现，每当光线沿$NW$、$SE$方向前进时，只会经过一种颜色的网格，每当光线沿$NE$、$SW$方向前进时，只会经过另一种颜色的网格。所以光线在某一个格子中心时，要么只会是$NW$、$SE$方向之一，要么只会是$NE$、$SW$方向之一，所以一个点最多只会被经过两次。

　　易知，如果光线在前进过程中出现过如下两种反射，所有格子就会被经过两次。

　　

　　只需在模拟的过程中记录是否出现过这两种情况即可。

---

代码时刻

$60\%$算法：

#include<bits/stdc++.h>
using namespace std;
int n,m,k;
int ans;
bool Map[1001][1001];//记录堵塞
bool vis[1001][1001][5];//记录状态
void dfs(int x,int y,int w)
{
	if(vis[x][y][w])//出现了已经访问过的状态
	{
		printf("%d",ans);
		exit(0);
	}
	if(!vis[x][y][1]&&!vis[x][y][2]&&!vis[x][y][3]&&!vis[x][y][4])ans++;//如果这个点还没有被经过过
	vis[x][y][w]=1;//标记这种状态已经出现过
	if(w==1)//四个方向
	{
		if(!Map[x-1][y+1]){dfs(x-1,y+1,1);return;}//四种情况，小心别打错就好了
		if((Map[x-1][y]&&Map[x][y+1])||(!Map[x-1][y]&&!Map[x][y+1])){dfs(x,y,4);return;}
		if(Map[x-1][y]){dfs(x,y+1,3);return;}
		if(Map[x][y+1]){dfs(x-1,y,2);return;}
	}
	if(w==2)
	{
		if(!Map[x-1][y-1]){dfs(x-1,y-1,2);return;}
		if((Map[x][y-1]&&Map[x-1][y])||(!Map[x][y-1]&&!Map[x-1][y])){dfs(x,y,3);return;}
		if(Map[x][y-1]){dfs(x-1,y,1);return;}
		if(Map[x-1][y]){dfs(x,y-1,4);return;}
	}
	if(w==3)
	{
		if(!Map[x+1][y+1]){dfs(x+1,y+1,3);return;}
		if((Map[x+1][y]&&Map[x][y+1])||(!Map[x+1][y]&&!Map[x][y+1])){dfs(x,y,2);return;}
		if(Map[x+1][y]){dfs(x,y+1,1);return;}
		if(Map[x][y+1]){dfs(x+1,y,4);return;}
	}
	if(w==4)
	{
		if(!Map[x+1][y-1]){dfs(x+1,y-1,4);return;}
		if((Map[x+1][y]&&Map[x][y-1])||(!Map[x+1][y]&&!Map[x][y-1])){dfs(x,y,1);return;}
		if(Map[x+1][y]){dfs(x,y-1,2);return;}
		if(Map[x][y-1]){dfs(x+1,y,3);return;}
	}
}
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=k;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		Map[x][y]=1;
	}
	int x,y;
	char ch[5];//这个稍微开打点，因为输入最后会有'\0'。
	scanf("%d%d%s",&x,&y,ch+1);
	for(int i=0;i<=n+1;i++)Map[i][0]=Map[i][m+1]=1;//边界
	for(int i=0;i<=m+1;i++)Map[0][i]=Map[n+1][i]=1;
	if(ch[1]=='N'&&ch[2]=='E')dfs(x,y,1);
	if(ch[1]=='N'&&ch[2]=='W')dfs(x,y,2);
	if(ch[1]=='S'&&ch[2]=='E')dfs(x,y,3);
	if(ch[1]=='S'&&ch[2]=='W')dfs(x,y,4);
	return 0;
}

$100\%$算法：

#include<bits/stdc++.h>
using namespace std;
struct rec{int x,y,d;};
int n,m,k;
long long ans;//注意long long
set<int>s1[200010],s2[200010];
map<pair<int,int>,bool>mp;
int getid(int x,int y,int d){return d==1?x-y+m+1:x+y;}
bool same(rec a,rec b){if(a.x==b.x&&a.y==b.y&&a.d==b.d)return 1;return 0;}
bool check(int x,int y){return mp[make_pair(x,y)];}
void add(int x,int y)//标记堵塞
{
    s1[getid(x,y,1)].insert(x);
    s2[getid(x,y,2)].insert(x);
    mp[make_pair(x,y)]=1;
}
pair<rec,int> dfs(rec u)//暴力搜索
{
    rec re;
    set<int>::iterator it;
    if(u.d==1)//四个方向
    {
        it=s1[getid(u.x,u.y,1)].lower_bound(u.x);it--;//用set和lower_bound在log的时间复杂度内求出答案
        re.x=u.x-(abs(*it-u.x)-1);
        re.y=u.y-(abs(*it-u.x)-1);
        if(check(re.x-1,re.y)&&check(re.x,re.y-1))re.d=3;//枚举情况
        else if(check(re.x-1,re.y)){re.y--;re.d=4;}
        else if(check(re.x,re.y-1)){re.x--;re.d=2;}
        else re.d=3;
    }
    if(u.d==2)
    {
        it=s2[getid(u.x,u.y,2)].lower_bound(u.x);it--;
        re.x=u.x-(abs(*it-u.x)-1);
        re.y=u.y+(abs(*it-u.x)-1);
        if(check(re.x-1,re.y)&&check(re.x,re.y+1))re.d=4;
        else if(check(re.x-1,re.y)){re.y++;re.d=3;}
        else if(check(re.x,re.y+1)){re.x--;re.d=1;}
        else re.d=4;
    }
    if(u.d==3)
    {
        it=s1[getid(u.x,u.y,1)].lower_bound(u.x);
        re.x=u.x+(abs(*it-u.x)-1);
        re.y=u.y+(abs(*it-u.x)-1);
        if(check(re.x+1,re.y)&&check(re.x,re.y+1))re.d=1;
        else if(check(re.x+1,re.y)){re.y++;re.d=2;}
        else if(check(re.x,re.y+1)){re.x++;re.d=4;}
        else re.d=1;
    }
    if(u.d==4)
    {
        it=s2[getid(u.x,u.y,2)].lower_bound(u.x);
        re.x=u.x+(abs(*it-u.x)-1);
        re.y=u.y-(abs(*it-u.x)-1);
        if(check(re.x+1,re.y)&&check(re.x,re.y-1))re.d=2;
        else if(check(re.x+1,re.y)){re.y--;re.d=1;}
        else if(check(re.x,re.y-1)){re.x++;re.d=3;}
        else re.d=2;
    }
    return make_pair(re,abs(*it-u.x));
}
bool judge(rec u)
{
    rec re=u;
    do
    {
        pair<rec,int> cur=dfs(u);
        ans+=(long long)cur.second;
        switch(cur.first.d)//转向
        {
        	case 1:if(u.d==3)return 0;break;
        	case 2:if(u.d==4)return 0;break;
        	case 3:if(u.d==1)return 0;break;
        	case 4:if(u.d==2)return 0;break;
        }
        u=cur.first;
    }while(!same(re,u));
    return 1;
}
void pre_build()//处理边界
{
    for(int i=0;i<=m+1;i++)
    {
        add(0,i);
        add(n+1,i);
    }
    for(int i=1;i<=n;i++)
    {
        add(i,0);
        add(i,m+1);
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&k);
    pre_build();
    for(int i=1;i<=k;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y);
    }
    int x,y,d;
    char ch[5];
    scanf("%d%d%s",&x,&y,ch+1);
    if(ch[1]=='N'&&ch[2]=='W')d=1;
    if(ch[1]=='N'&&ch[2]=='E')d=2;
    if(ch[1]=='S'&&ch[2]=='E')d=3;
    if(ch[1]=='S'&&ch[2]=='W')d=4;
    rec st={x,y,d};
    st=dfs(st).first;
    if(!judge(st))//开始模拟
    {
        ans--;
        switch(st.d)
        {
        	case 1:st.d=3;break;
        	case 2:st.d=4;break;
        	case 3:st.d=1;break;
        	case 4:st.d=2;break;
        }
        judge(st);
    }
    printf("%lld",ans);
    return 0;
}
 

---

rp++