2018 German Collegiate Programming Contest (GCPC 18) A-Attack on Alpha-Zet

题目链接：https://codeforces.com/gym/102021/attachments

题意：现在有一个迷宫大小为$n\ast m$，你有$q$个点，分别标号为$[1,q]$，你需要按照顺序在迷宫中按顺序经过这$q$个点，并且要求路径和最短。

解题心得：

• 题目中有一句非常关键的话就是在迷宫中任意两点有且仅有一条路径。也就是说可以直接将这个迷宫抽象成一棵树，然后$q$个点就是按照顺序求两两点之间在树上的路径长度。
• 设两点分别为$u$，$v$，这个时候路径长度为$deep[u]+deep[v]-deep[lca(u,v)]\ast 2$。
• 其实这个题最恶心的是地图的处理，里面还包含了空格等问题，仔细观察找出规律来进行处理。

---

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn = 3010;

char s[maxn][maxn];
int n, m, q, depth[maxn*maxn], fa[3001000][25];
vector <int> ve[maxn*maxn];//存树的边
vector <pair<int, int> > query;

void init() {
    scanf("%d%d", &n, &m);
    getchar();
    for(int i=1;i<=n+1;i++) {
        gets(s[i]+1);
    }
    scanf("%d", &q);
    for(int i=1;i<=q;i++) {
        int a, b; scanf("%d%d", &a, &b);
        query.push_back({a, b});
    }
}

int Hash(int x,int y) {//将图上一点标记成数字
    return (x-1)*(m*2+1) + y*2;
}

void build_tree() {//将地图处理成树
    for(int i=2;i<=n+1;i++) {
        for(int j=2;j<=m*2;j+=2) {
            if(s[i][j] == ' ') {
                ve[Hash(i, j)].push_back(Hash(i+1, j));
                ve[Hash(i+1, j)].push_back(Hash(i, j));
            }
            if(s[i][j+1] != '|') {
                ve[Hash(i, j)].push_back(Hash(i, j+2));
                ve[Hash(i, j+2)].push_back(Hash(i, j));
            }
        }
    }
}

void dfs(int prev,int rt){
    depth[rt]=depth[prev]+1;
    fa[rt][0]=prev;
    for (int i=1;i<20;i++)
        fa[rt][i]=fa[fa[rt][i-1]][i-1];
    for (int i=0;i<ve[rt].size();i++) {
        if(prev == ve[rt][i]) continue;
        dfs(rt, ve[rt][i]);
    }
}
int LCA(int x,int y){
    if (depth[x]<depth[y])
        swap(x,y);
    for (int i=19;i>=0;i--)
        if (depth[x]-(1<<i)>=depth[y])
            x=fa[x][i];
    if (x==y)
        return x;
    for (int i=19;i>=0;i--)
        if (fa[x][i]!=fa[y][i])
            x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}


int main() {
    //    freopen("1.in.txt", "r", stdin);
    init();
    build_tree();
    dfs(0, Hash(query[0].first+1, query[0].second*2));
    ll ans = 0;
    for(int i=0;i<query.size()-1;i++) {
        int x = query[i].first;
        int y = query[i].second;

        int num1 = Hash(x+1, y*2);

        x = query[i+1].first;
        y = query[i+1].second;

        int num2 = Hash(x+1, y*2);

        ans += depth[num1] + depth[num2] - depth[LCA(num1, num2)] * 2;
    }
    printf("%lld\n", ans);
    return 0;
}