良心の送信サブテーマ（仮想ツリーチャレンジ35E + +最短オフ牛）

トピックリンク

ポータル

問題の意味

あなたの木を与え、そしてちょうどツリーをコピー（K \）\回、その後、追加\（M \）最短のエンドポイントへのあなたの開始点を尋ね、エッジをした後、あなたの開始点と終了点を与えます。

思考

ツリーのコピーので\（K \）アップノード回数後（\ 10 ^ {10}）\、したがって直接コピーを実行することはできません。

私たちは、ことに注意してください（メートル\のLeq 50000 \）\、およびそれ\（M \）にのみ関連するエッジの接合部まで（2メートル\）\（キーポイントと呼ばれる）、その後、我々は引き出すために、これらの点を考慮することができます対象の異なるバージョン間のエッジ点最短ラン、\（M \） 2つの異なるバージョンのエッジ間の距離ようにノード\（1 \）が、同一の2つのバージョン間の接合点どのようにそれを行うには？

直接的な暴力は、同じバージョンのキーポイント間の距離を列挙することができ、容易に縮重に\（4M ^ 2 \） 、他の方法を考慮する必要があるが、仮想木の導入にこの時間は、各ツリーは、仮想ツリーのバージョンを再構築しました、仮想ツリーの辺の長さは、元のツリーの二点間の最短距離です。

仮想ツリーブログのテンプレートを学習し、あなたがこのブログを見ることができます：ブログ

最後に、我々はすべてのバージョンにエッジと被写体に仮想ツリーを置く（M \）\エッジは画像再構築に引き出し、その後、直接最短ラインを実行します。

コード

#include <set>
#include <map>
#include <deque>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <bitset>
#include <cstdio>
#include <string>
#include <vector>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;

typedef long long LL;
typedef pair<LL, LL> pLL;
typedef pair<LL, int> pLi;
typedef pair<int, LL> pil;;
typedef pair<int, int> pii;
typedef unsigned long long uLL;

#define fi first
#define se second
#define lson (rt<<1)
#define rson (rt<<1|1)
#define lowbit(x) x&(-x)
#define name2str(name) (#name)
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
#define FIN freopen("D://Code//in.txt","r",stdin)

const double eps = 1e-8;
const int mod = 1000000007;
const int maxn = 500000 + 7;
const double pi = acos(-1);
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3fLL;

int n, m, k, tot, id, s, x, t, y, cnt;
int head[maxn], dfn[maxn];
vector<int> has[maxn];
unordered_map<LL,int> mp;

int getid(int x, int y) {
    LL tmp = 1LL * (x - 1) * n + y;
    if(mp.count(tmp)) return mp[tmp];
    else return mp[tmp] = ++id;
}

struct edge {
    int v, w, next;
}ed[maxn];

void add(int u, int v, int w) {
    ed[tot].v = v;
    ed[tot].w = w;
    ed[tot].next = head[u];
    head[u] = tot++;
}

struct LCA {
    int tot;
    int deep[maxn], fa[maxn][30], head[maxn], cost[maxn];
    struct edge {
        int v, w, next;
    }ed[maxn<<1];

    void init() {
        tot = 0;
        for(int i = 0; i <= n; i++) {
            head[i] = -1;
            cost[i] = deep[i] = 0;
        }
    }

    void add(int u, int v, int w) {
        ed[tot].v = v;
        ed[tot].w = w;
        ed[tot].next = head[u];
        head[u] = tot++;
    }

    void dfs(int u, int d, int p) {
        deep[u] = d, fa[u][0] = p, dfn[u] = ++cnt;
        for(int i = head[u]; ~i; i = ed[i].next) {
            int v = ed[i].v;
            if(v == p) continue;
            cost[v] = cost[u] + ed[i].w;
            dfs(v, d + 1, u);
        }
    }

    void lca() {
        for(int i = 1; i <= n; i++) {
            for(int j = 1; (1<<j) <= n; j++) {
                fa[i][j] = -1;
            }
        }
        for(int j = 1; (1<<j) <= n; j++) {
            for(int i = 1; i <= n; i++) {
                if(fa[i][j-1] != -1) {
                    fa[i][j] = fa[fa[i][j-1]][j-1];
                }
            }
        }
    }

    int query(int u, int v) {
        if(deep[u] <= deep[v]) swap(u, v);
        int k;
        for(k = 0; (1 << (1 + k)) <= deep[u]; k++);
        for(int i = k; i >= 0; i--) {
            if(deep[u] - (1<<i) >= deep[v]) {
                u = fa[u][i];
            }
        }
        if(u == v) return u;
        for(int i = k; i >= 0; i--) {
            if(fa[u][i] != -1 && fa[u][i] != fa[v][i]) {
                u = fa[u][i], v = fa[v][i];
            }
        }
        return fa[u][0];
    }

    int dis(int u, int v) {
        return cost[u] + cost[v] - 2 * cost[query(u, v)];
    }
}L;

bool cmp(int x, int y) {
    return dfn[x] < dfn[y];
}

int stk[maxn], top;

void ins(int id, int x) {
    if(top == 1) {
        stk[++top] = x;
        return;
    }
    int fa = L.query(x, stk[top]);
    if(fa == stk[top]) {
        stk[++top] = x;
        return;
    }
    while(top > 1 && dfn[stk[top-1]] >= dfn[fa]) {
        int dis = L.dis(stk[top-1], stk[top]);
        int p1 = getid(id, stk[top-1]), p2 = getid(id, stk[top]);
        add(p1, p2, dis);
        add(p2, p1, dis);
        --top;
    }
    if(stk[top] != fa) {
        int dis = L.dis(fa, stk[top]);
        int p1 = getid(id, fa), p2 = getid(id, stk[top]);
        add(p1, p2, dis);
        add(p2, p1, dis);
        stk[top] = fa;
    }
    stk[++top] = x;
}

void build(int id, vector<int>& vec) {
    sort(vec.begin(), vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
    sort(vec.begin(), vec.end(), cmp);
    stk[top = 1] = 1;
    for(decltype(vec.size()) i = 0; i != vec.size(); ++i) ins(id, vec[i]);
    while(top > 1) {
        int dis = L.dis(stk[top], stk[top-1]);
        int p1 = getid(id, stk[top-1]), p2 = getid(id, stk[top]);
        add(p1, p2, dis);
        add(p2, p1, dis);
        --top;
    }
}

int vis[maxn];
LL dis[maxn];

LL dij(int s, int t) {
    memset(dis, INF, sizeof(dis));
    priority_queue<pLi, vector<pLi>, greater<pLi> > q;
    dis[s] = 0;
    q.push({0, s});
    while(!q.empty()) {
        int u = q.top().se; q.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(int i = head[u]; ~i; i = ed[i].next) {
            int v = ed[i].v, w = ed[i].w;
            if(dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                q.push({dis[v], v});
            }
        }
    }
    if(dis[t] < INF) return dis[t];
    else return -1;
}

int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif
    scanf("%d%d%d", &n, &m, &k);
    L.init();
    memset(head, -1, sizeof(head));
    for(int i = 1; i < n; ++i) {
        scanf("%d%d", &x, &y);
        L.add(x, y, 1);
        L.add(y, x, 1);
    }
    L.dfs(1, 0, 0);
    L.lca();
    for(int i = 1; i <= m; ++i) {
        scanf("%d%d%d%d", &s, &x, &t, &y);
        int p1 = getid(s, x), p2 = getid(t, y);
        has[s].emplace_back(x);
        has[t].emplace_back(y);
        add(p1, p2, 1);
        add(p2, p1, 1);
    }
    scanf("%d%d%d%d", &s, &x, &t, &y);
    int p1 = getid(s, x), p2 = getid(t, y);
    has[s].emplace_back(x);
    has[t].emplace_back(y);
    for(int i = 1; i <= k; ++i) build(i, has[i]);
    printf("%lld\n", dij(p1, p2));
    return 0;
}