[JZOJ3106]锻炼

题目大意：
　　给你一个$n\times m(n,m\leq 50)$的网格图，其中有一个四连通的障碍物。给定起点和终点，每次你可以走到和当前位置八连通的一个方格内，问绕障碍物一圈最短要走几格？

思路：
　　BFS求一下最短路，然后当一个点被访问两次时，把两次的最短路加起来即可。
　　然而这样显然是错的，因为并不能保证两次的路径刚好把障碍物包住，因此我们还需知道每条路径是从障碍物哪边绕过来的。
　　一种方法是使用扫描线，当两条路径会合时，从障碍物内一点发射一条扫描线，如果和最短路橡胶的次数时奇数，那么肯定是将障碍物包住了。
　　这样据说已经能过了，不过还有一种更妙的方法。
　　可以在BFS最短路时，同时记录这条最短路与扫描线相交的次数的奇偶性。
　　具体方法是，每次最短路往外扩展一格时，判断一下本次扩展是否经过了扫描线。
　　最后两条最短路会合时，只需要判断一下两个最短路经过次数加起来是否为奇数，如果是，则说明将障碍物包起来了，更新答案。

 #include<queue>
 #include<cstdio>
 #include<cctype>
 inline int getint() {
     register char ch;
     while(!isdigit(ch=getchar()));
     register int x=ch^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 inline char getblock() {
     register char ch;
     do {
         ch=getchar();
     } while(ch!='.'&&ch!='X'&&ch!='*');
     return ch;
 }
 typedef std::pair<int,int> Block;
 const int N=;
 const int inf=0x7fffffff;
 const int dx[]={-,-,-,,,,,},dy[]={-,,,-,,-,,};
 Block s;
 bool f[N][N];
 int n,m,dis[N][N];
 std::queue<Block> q;
 inline bool check(const Block &u) {
     return ~u.first&&u.first<n&&~u.second&&u.second<m&&~dis[u.first][u.second];
 }
 inline bool calc(const Block &u,const Block &v) {
     return (u.first==s.first&&u.second>s.second&&v.first<s.first)||(v.first==s.first&&v.second>s.second&&u.first<s.first);
 }
 int main() {
     n=getint(),m=getint();
     for(register int i=;i<n;i++) {
         for(register int j=;j<m;j++) {
             const char ch=getblock();
             if(ch=='*') q.push((Block){i,j});
             if(ch=='X') {
                 s=(Block){i,j};
                 dis[i][j]=-;
             }
             if(ch=='.') dis[i][j]=inf;
         }
     }
     int ans=inf;
     while(!q.empty()) {
         const Block u=q.front();
         q.pop();
         for(register int i=;i<;i++) {
             const Block v=(Block){u.first+dx[i],u.second+dy[i]};
             if(!check(v)) continue;
             if(dis[v.first][v.second]==inf) {
                 q.push(v);
                 dis[v.first][v.second]=dis[u.first][u.second]+;
                 f[v.first][v.second]=f[u.first][u.second]^calc(u,v);
             } else {
                 if(f[u.first][u.second]^calc(u,v)^f[v.first][v.second]) {
                     ans=std::min(ans,dis[u.first][u.second]+dis[v.first][v.second]+);
                 }
             }
         }
     }
     printf("%d\n",ans);
     return ;
 }