HDU 4297 One and One Story (LCA>RMQ)

题意就是找森林里的LCA，构图完成了这个题基本就没问题了。

已知的是所给的图上是可能有环的。那么可以对这些环进行类似缩点的操作（当然不是tarjan），设一个虚拟根0点，链接环上的每一个点。

对于不在环上的点直接加无向边建树就行。

预处理出每个环包含哪些点，每个环中点的顺序（环是有方向的）

对得到的树进行LCA到RMQ的转化，同时记录当前点到0点的距离，O(nlogn)的时间预处理，O(1)的时间求LCA。

分几种情况：

1、两点的LCA是环上的同一个点，这个直接出结果（根据距离）

2、两点的LCA在同一个环的不同点上，这个要根据环的方向判断一下优弧劣弧。

3、两点的LCA不再同一环上。直接输出-1 -1;

详见代码吧。。。很搓很搓的写了6K+。。。经此一役，DSU， RMQ，LAC的模板都有了。。。

//#pragma comment(linker,"/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <functional>
#include <numeric>
#include <sstream>
#include <stack>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define REP(i, n)       for((i) = 0; (i) < (n); ++(i))
#define FOR(i, l, h)    for((i) = (l); (i) <= (h); ++(i))
#define FORD(i, h, l)   for((i) = (h); (i) >= (l); --(i))
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   x < y ? x : y
#define Max(x, y)   x < y ? y : x
#define E(x)    (1 << (x))
#define iabs(x) (x) < 0 ? -(x) : (x)
#define OUT(x)  printf("%I64d\n", x)
#define lowbit(x)   (x)&(-x)
#define Read()    freopen("data.in", "r", stdin)
#define Write()   freopen("data.out", "w", stdout);

const double eps = 1e-8;
typedef long long LL;
const int inf = ~0u>>2;

using namespace std;

const int N = 500010;
int n;

struct node {
    int to;
    int next;
    node() {}
} g[N<<2];

int head[N], t;
class Graph {    //树。。
public:
    void init() {
        CL(head, -1); t = 0;
    }
    void add(int u, int v) {
        g[t].to = v; g[t].next = head[u]; head[u] = t++;
    }
}G;


int parent[N];
class DSU {    //并查集
public:
    void init(int n) {
        for(int i = 0; i <= n; ++i) parent[i] = i;
    }
    void union_set(int a, int b) {
        parent[a] = b;
    }
    int find(int x) {
        int k, j;
        k = x;
        while(x != parent[x])   x = parent[x];

        while(k != x) {
            j = parent[k];
            parent[k] = x;
            k = j;
        }
        return x;
    }
}DSU;

int D[N], E[N<<1], R[N<<1];
int Min[N<<1][20];

class RMQ {    //RMQ
public:
    void build(int n) {
        int i, j, m;
        for(i = 1; i <= n; ++i) Min[i][0] = i;
        m = int(log(double(n))/log(2.0));
        FOR(j, 1, m) {
            FOR(i, 1, n - (1<<j) + 1) {
                if(D[Min[i][j-1]] < D[Min[i+(1<<(j-1))][j-1]]) {
                    Min[i][j] = Min[i][j-1];
                } else {
                    Min[i][j] = Min[i+(1<<(j-1))][j-1];
                }

            }
        }
    }

    int query(int s, int e) {
        int k = log(double(e - s + 1))/log(2.0);
        if(D[Min[s][k]] < D[Min[e-(1<<k) + 1][k]])   return  Min[s][k];
        else    return Min[e-(1<<k) + 1][k];
    }
} Q;

int dis[N], root[N], cir[N];
int nxt[N];
int cnt;
bool vis[N];

class LCA {    //LCA
public:
    void init() {
        CL(D, 0); CL(dis, 0);
        CL(E, 0); CL(R, 0);
        CL(vis, 0); cnt = 0;
    }
    void dfs(int t, int dep) {
        D[++cnt] = dep;
        E[cnt] = t;

        if(!vis[t]) {
            R[t] = cnt;
            vis[t] = true;
        }
        for(int i = head[t]; i != -1; i = g[i].next) {
            if(vis[g[i].to])    continue;

            dis[g[i].to] = dis[t] + 1;
            dfs(g[i].to, dep + 1);

            D[++cnt] = dep;
            E[cnt] = t;
        }
    }
    /*
    void display() {
        int i;
        for(i = 1; i <= cnt; ++i)
            printf("%-3d", i);
        cout << endl;
        for(i = 1; i <= cnt; ++i)
            printf("%-3d", D[i]);
        cout << endl;
        for(i = 1; i <= cnt; ++i)
            printf("%-3d", E[i]);
        cout << endl;
        for(i = 1; i <= n; ++i) {
            printf("%d ", R[i]);
        }
        cout << endl;
    }
    */
    void solve() {
        init();
        dfs(0, 0);
        Q.build(cnt);
    }

    int query(int x, int y) {
        x = R[x]; y = R[y];
        if(x > y)   swap(x, y);
       // printf("%d\n", Q.query(x, y));
        return E[Q.query(x, y)];
    }
}LCA;

void rdfs(int u, int r) {    //把非环上点的根节点都处理出来。
    root[u] = r;
    for(int i = head[u]; i != -1; i = g[i].next) {
        if(root[g[i].to] == -1) {
            rdfs(g[i].to, r);
        }
    }
}

int num;
int pos[N], len[N];    //每个点在环中的位置，每个环的长度

void deal() {    //预处理环的情况
    CL(cir, -1);  CL(pos, -1);
    CL(len, 0);

    DSU.init(n);
    int i, j, cnt, x, y;
    num = 0;
    for(i = 1; i <= n; ++i) {
        x = DSU.find(i);
        y = DSU.find(nxt[i]);
        if(x == y)  cir[i] = ++num;
        DSU.union_set(x, y);
    }

    for(i = 1; i <= n; ++i) {
        if(cir[i] != -1) {
            j = nxt[i];
            cnt = 0;
            pos[i] = ++cnt;
            root[i] = i;
            while(j != i) {
                pos[j] = ++cnt;
                root[j] = j;
                cir[j] = cir[i];
                j = nxt[j];
            }
            len[cir[i]] = cnt;
        }
    }
}


int main() {
    //Read();

    int i, k, p, ra, rb;
    int a, b, x1, y1, x2, y2;
    int ansx, ansy;
    while(~scanf("%d%d", &n, &k)) {
        CL(root, -1);
        for(i = 1; i <= n; ++i) scanf("%d", nxt + i);
        deal();
        G.init();
        for(i = 1; i <= n; ++i) {
            if(root[i] != i) {
                G.add(i, nxt[i]);
                G.add(nxt[i], i);
                //printf("*%d %d\n", i, nxt[i]);
            }
        }
        for(i = 1; i <= n; ++i) {
            if(root[i] == i) {
                rdfs(i, i);
                G.add(0, i);
                G.add(i, 0);
                //printf("*%d %d\n", 0, nxt[i]);
            }
        }
        LCA.solve();
        //LCA.display();
        while(k--) {
            scanf("%d%d", &a, &b);
            p = LCA.query(a, b);
            if(p != 0) {
                printf("%d %d\n", dis[a] - dis[p], dis[b] - dis[p]);
                continue;
            }
            ra = root[a], rb = root[b];
            if(cir[ra] != cir[rb])  {printf("-1 -1\n"); continue;}
            x1 = x2 = dis[a] - 1;
            y1 = y2 = dis[b] - 1;
            //A沿着环的方向靠近B
            if(pos[ra] < pos[rb])   x1 += pos[rb] - pos[ra];
            else    x1 += len[cir[ra]] - (pos[ra] - pos[rb]);
            //B沿着环的方向靠近A
            if(pos[rb] < pos[ra])   y2 += pos[ra] - pos[rb];
            else    y2 += len[cir[rb]] - (pos[rb] - pos[ra]);
            /*
            printf("(x1, y1) = (%d, %d)\n", x1, y1);
            printf("(x2, y2) = (%d, %d)\n", x2, y2);
            */
            if(max(x1, y1) < max(x2, y2))   ansx = x1, ansy = y1;
            else if(max(x1, y1) > max(x2, y2))  ansx = x2, ansy = y2;
            else {
                if(min(x1, y1) < min(x2, y2))   ansx = x1, ansy = y1;
                else    if(min(x1, y1) > min(x2, y2))   ansx = x2, ansy = y2;
                else {
                    if(x1 >= y1)    ansx = x1, ansy = y1;
                    else    ansx = x2, ansy = y2;
                }
            }
            printf("%d %d\n", ansx, ansy);
        }
    }
    return 0;
}