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[];
 bool map[][];
 vector<short> v[][];
 void dfs(int x,int y,int num,int fx)
 {
 //    cout<<x<<" "<<y<<" "<<fx<<endl;
     if(v[x][y].size()==)num++;
     for(int i=;i<v[x][y].size();i++)if(v[x][y][i]==fx){cout<<num<<endl;exit();}
     v[x][y].push_back(fx);
     if(fx==)
     {
         if(x==&&y==m)dfs(x,y,num,);
         else if(map[x-][y]&&map[x-][y+]&&map[x][y+])dfs(x,y,num,);
         else if(x==||(y<m&&map[x-][y]&&map[x-][y+]))dfs(x,y+,num,);
         else if(y==m||(x>&&map[x][y+]&&map[x-][y+]))dfs(x-,y,num,);
         else if(map[x-][y+])dfs(x,y,num,);
         else dfs(x-,y+,num,fx);
     }
     else if(fx==)
     {
         if(x==n&&y==m)dfs(x,y,num,);
         else if(map[x+][y]&&map[x+][y+]&&map[x][y+])dfs(x,y,num,);
         else if(x==n||(y<m&&map[x+][y]&&map[x+][y+]))dfs(x,y+,num,);
         else if(y==m||(x<n&&map[x][y+]&&map[x+][y+]))dfs(x+,y,num,);
         else if(map[x+][y+])dfs(x,y,num,);
         else dfs(x+,y+,num,fx);
     }//A
     else if(fx==)
     {
         if(x==n&&y==)dfs(x,y,num,);
         else if(map[x+][y]&&map[x+][y-]&&map[x][y-])dfs(x,y,num,);
         else if(x==n||(y>&&map[x+][y]&&map[x+][y-]))dfs(x,y-,num,);
         else if(y==||(x<n&&map[x][y-]&&map[x+][y-]))dfs(x+,y,num,);
         else if(map[x+][y-])dfs(x,y,num,);
         else dfs(x+,y-,num,fx);
     }
     else if(fx==)
     {
         if(x==&&y==)dfs(x,y,num,);
         else if(map[x-][y]&&map[x-][y-]&&map[x][y-])dfs(x,y,num,);
         else if(x==||(y>&&map[x-][y]&&map[x-][y-]))dfs(x,y-,num,);
         else if(y==||(x>&&map[x][y-]&&map[x-][y-]))dfs(x-,y,num,);
         else if(map[x-][y-])dfs(x,y,num,);
         else dfs(x-,y-,num,fx);
     }
 }
 signed main()
 {
 //    freopen("ray0.in","r",stdin);

     cin>>n>>m>>k;
     if(n>||m>) {cout<<n*m<<endl;exit();}
     int a,b;
     for(int i=;i<=k;i++)
     {
         cin>>a>>b;
         if(n<=&&m<=)map[a][b]=;
     }
     cin>>xs>>ys>>te;
     for(int i=;i<=m+;i++)map[][i]=map[n+][i]=;
     for(int i=;i<=n+;i++)map[i][]=map[i][m+]=;
     if(te[]=='N')
     {
         if(te[]=='E')f=;
         else f=;//W
     }
     else//S
     {
         if(te[]=='E')f=;
         else f=;//W
     }
     if(n<=&&m<=)
         dfs(xs,ys,,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[];
 LL ans=;
 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==?x-y+m+:x+y;}
 bool same(rec a,rec b){if(a.x==b.x&&a.y==b.y&&a.d==b.d)return ;return ;}
 bool check(int x,int y){return mp[MP(x,y)];}
 void add(int x,int y)
 {
     s1[getid(x,y,)].insert(x);
     s2[getid(x,y,)].insert(x);
     mp[MP(x,y)]=;
 }
 pair<rec,int> dfs(rec u)
 {
     rec re;
     set<int>::iterator it;
     if(u.d==)
     {
         it=s1[getid(u.x,u.y,)].lower_bound(u.x);it--;
         re.x=u.x-(abs(*it-u.x)-);
         re.y=u.y-(abs(*it-u.x)-);
         if(check(re.x-,re.y)&&check(re.x,re.y-))re.d=;
         else if(check(re.x-,re.y))re.d=,re.y--;
         else if(check(re.x,re.y-))re.d=,re.x--;
         else re.d=;
     }
     if(u.d==)
     {
         it=s2[getid(u.x,u.y,)].lower_bound(u.x);it--;
         re.x=u.x-(abs(*it-u.x)-);
         re.y=u.y+(abs(*it-u.x)-);

         if(check(re.x-,re.y)&&check(re.x,re.y+))re.d=;
         else if(check(re.x-,re.y))re.d=,re.y++;
         else if(check(re.x,re.y+))re.d=,re.x--;
         else re.d=;
     }
     if(u.d==)
     {
         it=s1[getid(u.x,u.y,)].lower_bound(u.x);
         re.x=u.x+(abs(*it-u.x)-);
         re.y=u.y+(abs(*it-u.x)-);

         if(check(re.x+,re.y)&&check(re.x,re.y+))re.d=;
         else if(check(re.x+,re.y))re.d=,re.y++;
         else if(check(re.x,re.y+))re.d=,re.x++;
         else re.d=;
     }
     if(u.d==)
     {
         it=s2[getid(u.x,u.y,)].lower_bound(u.x);
         re.x=u.x+(abs(*it-u.x)-);
         re.y=u.y-(abs(*it-u.x)-);

         if(check(re.x+,re.y)&&check(re.x,re.y-))re.d=;
         else if(check(re.x+,re.y))re.d=,re.y--;
         else if(check(re.x,re.y-))re.d=,re.x++;
         else re.d=;
     }
     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 :if(u.d==)return ;break;
             case :if(u.d==)return ;break;
             case :if(u.d==)return ;break;
             case :if(u.d==)return ;break;
         }
         u=cur.first;
     }while(!same(re,u));
     return ;
 }

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

     cin>>n>>m>>k;
     for(int i=;i<=m+;i++)add(,i),add(n+,i);
     for(int i=;i<=n;i++)  add(i,),add(i,m+);
     int a,b;
     for(int i=;i<=k;i++)
     {
         cin>>a>>b;
         add(a,b);
     }
     int f;
     cin>>xs>>ys>>te;
     if(te[]=='N')
     {
         if(te[]=='E')f=;
         else f=;//W
     }
     else//S
     {
         if(te[]=='E')f=;
         else f=;//W
     }
     rec st={xs,ys,f};
     st=dfs(st).first;
     if(!judge(st))//判断第一次反向
     {
         ans--;
         switch(st.d)
         {
             case :st.d=;break;
             case :st.d=;break;
             case :st.d=;break;
             case :st.d=;break;
         }
         judge(st);
     }
     cerr<<ans<<endl;
     cout<<ans<<endl;
 }