[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^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    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=50;
const int inf=0x7fffffff;
const int dx[]={-1,-1,-1,0,0,1,1,1},dy[]={-1,0,1,-1,1,-1,0,1};
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=0;i<n;i++) {
        for(register int j=0;j<m;j++) {
            const char ch=getblock();
            if(ch=='*') q.push((Block){i,j});
            if(ch=='X') {
                s=(Block){i,j};
                dis[i][j]=-1;
            }
            if(ch=='.') dis[i][j]=inf;
        }
    }
    int ans=inf;
    while(!q.empty()) {
        const Block u=q.front();
        q.pop();
        for(register int i=0;i<8;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]+1;
                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]+1);
                }
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}