HZOJ 光

一道大模拟，打的我要吐了。

先说一下60%暴力吧，其实模拟光的路线即可，最好还是把边界设为障碍，这样就不用判边界了。最后输出n*m可以骗到10分。

注意不要把n和m弄混（愁死我了）。

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<vector>
#define LL long long
#define int LL
using namespace std;
int n,m,k,xs,ys,f;
char te[10];
bool map[2010][2010];
vector<short> v[1010][1010];
void dfs(int x,int y,int num,int fx)
{
//    cout<<x<<" "<<y<<" "<<fx<<endl;
    if(v[x][y].size()==0)num++;
    for(int i=0;i<v[x][y].size();i++)if(v[x][y][i]==fx){cout<<num<<endl;exit(0);}
    v[x][y].push_back(fx);
    if(fx==1)
    {
        if(x==1&&y==m)dfs(x,y,num,3);
        else if(map[x-1][y]&&map[x-1][y+1]&&map[x][y+1])dfs(x,y,num,3);
        else if(x==1||(y<m&&map[x-1][y]&&map[x-1][y+1]))dfs(x,y+1,num,2);
        else if(y==m||(x>1&&map[x][y+1]&&map[x-1][y+1]))dfs(x-1,y,num,4);
        else if(map[x-1][y+1])dfs(x,y,num,3);
        else dfs(x-1,y+1,num,fx);
    }
    else if(fx==2)
    {
        if(x==n&&y==m)dfs(x,y,num,4);
        else if(map[x+1][y]&&map[x+1][y+1]&&map[x][y+1])dfs(x,y,num,4);
        else if(x==n||(y<m&&map[x+1][y]&&map[x+1][y+1]))dfs(x,y+1,num,1);
        else if(y==m||(x<n&&map[x][y+1]&&map[x+1][y+1]))dfs(x+1,y,num,3);
        else if(map[x+1][y+1])dfs(x,y,num,4);
        else dfs(x+1,y+1,num,fx);
    }//A
    else if(fx==3)
    {
        if(x==n&&y==1)dfs(x,y,num,1);
        else if(map[x+1][y]&&map[x+1][y-1]&&map[x][y-1])dfs(x,y,num,1);
        else if(x==n||(y>1&&map[x+1][y]&&map[x+1][y-1]))dfs(x,y-1,num,4);
        else if(y==1||(x<n&&map[x][y-1]&&map[x+1][y-1]))dfs(x+1,y,num,2);
        else if(map[x+1][y-1])dfs(x,y,num,1);
        else dfs(x+1,y-1,num,fx);
    }
    else if(fx==4)
    {
        if(x==1&&y==1)dfs(x,y,num,2);
        else if(map[x-1][y]&&map[x-1][y-1]&&map[x][y-1])dfs(x,y,num,2);
        else if(x==1||(y>1&&map[x-1][y]&&map[x-1][y-1]))dfs(x,y-1,num,3);
        else if(y==1||(x>1&&map[x][y-1]&&map[x-1][y-1]))dfs(x-1,y,num,1);
        else if(map[x-1][y-1])dfs(x,y,num,2);
        else dfs(x-1,y-1,num,fx);
    }
}
signed main()
{
//    freopen("ray0.in","r",stdin);

    cin>>n>>m>>k;
    if(n>1000||m>1000) {cout<<n*m<<endl;exit(0);}
    int a,b;
    for(int i=1;i<=k;i++)
    {
        cin>>a>>b;
        if(n<=1000&&m<=1000)map[a][b]=1;
    }
    cin>>xs>>ys>>te;
    for(int i=0;i<=m+1;i++)map[0][i]=map[n+1][i]=1;
    for(int i=0;i<=n+1;i++)map[i][0]=map[i][m+1]=1;
    if(te[0]=='N')
    {
        if(te[1]=='E')f=1;
        else f=4;//W
    }
    else//S
    {
        if(te[1]=='E')f=2;
        else f=3;//W
    }
    if(n<=1000&&m<=1000)
        dfs(xs,ys,0,f);
}

然后说正解（其实就是优化了暴力）：

确实有点难以理解，对于光的路线，可以发现其实暴力中间枚举了很多无用的状态，怎么解决呢？

有一个比较简单但是不好想的规律，对于斜线，x+y或x-y不变，那么我们就可以用这个数字代表一条斜线，对于每一条斜线开一个set，将这条斜线上的障碍的x插入，那么二分查找就可以实现快速地转移了。

然而这样递归下去还是比较麻烦的，可以用循环。

再说两个规律：光线经过的路径只可能是环而不是环+链（显然），一条路径中至多出现两次原路返回的情况（这个自己想想也不难，其实是我不会证）。

所以循环处理即可，具体见代码。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<set>
#include<map>
#define LL long long
#define MAXN 200010
#define MP(a,b) make_pair(a,b)
#define ma(x) memset(x,0,sizeof(x))
using namespace std;
int n,m,k;
int xs,ys;char te[10];
LL ans=0;
struct rec{int x,y,d;};
set<int> s1[MAXN],s2[MAXN];
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[MP(x,y)];}
void add(int x,int y)
{
    s1[getid(x,y,1)].insert(x);
    s2[getid(x,y,2)].insert(x);
    mp[MP(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--;
        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.d=4,re.y--;
        else if(check(re.x,re.y-1))re.d=2,re.x--;
        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.d=3,re.y++;
        else if(check(re.x,re.y+1))re.d=1,re.x--;
        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.d=2,re.y++;
        else if(check(re.x,re.y+1))re.d=4,re.x++;
        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.d=1,re.y--;
        else if(check(re.x,re.y-1))re.d=3,re.x++;
        else re.d=2;        
    }    
    return MP(re,abs(*it-u.x));
}
bool judge(rec u)
{
    rec re=u;
    do
    {
        pair<rec,int> cur=dfs(u);
        ans+=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;
}

signed main()
{
//    freopen("in.txt","r",stdin);

    cin>>n>>m>>k;
    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 a,b;
    for(int i=1;i<=k;i++)
    {
        cin>>a>>b;
        add(a,b);
    }
    int f;
    cin>>xs>>ys>>te;
    if(te[0]=='N')
    {
        if(te[1]=='E')f=2;
        else f=1;//W
    }
    else//S
    {
        if(te[1]=='E')f=3;
        else f=4;//W
    }
    rec st={xs,ys,f};
    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);
    }
    cerr<<ans<<endl;
    cout<<ans<<endl;
}