#BZOJ3700#发展城市(O(1)LCA+分析讨论)

3700: 发展城市

Time Limit: 20 Sec   Memory Limit: 512 MB

Description

 众所周知，Hzwer学长是一名高富帅，他打算投入巨资发展一些小城市。
 Hzwer打算在城市中开N个宾馆，由于Hzwer非常壕，所以宾馆必须建在空中，但是这样就必须建立宾馆之间的连接通道。机智的Hzwer在宾馆中修建了N-1条隧道，也就是说，宾馆和隧道形成了一个树形结构。
 Hzwer有时候会花一天时间去视察某个城市，当来到一个城市之后，Hzwer会分析这些宾馆的顾客情况。对于每个顾客，Hzwer用三个数值描述他：（S， T， V）表示该顾客这天想要从宾馆S走到宾馆T，他的速度是V。
 Hzwer需要做一些收集一些数据，这样他就可以规划他接下来的投资。
 其中有一项数据就是收集所有顾客可能的碰面次数。
 每天清晨，顾客同时从S出发以V的速度前往T（注意S可能等于T），当到达了宾馆T的时候，顾客显然要找个房间住下，那么别的顾客再经过这里就不会碰面了。特别的，两个顾客同时到达一个宾馆是可以碰面的。同样，两个顾客同时从某宾馆出发也会碰面。

Input

 第一行一个正整数T(1<=T<=20)，表示Hzwer发展了T个城市，并且在这T个城市分别视察一次。
 对于每个T，第一行有一个正整数N(1<=N<=10^5)表示Hzwer在这个城市开了N个宾馆。
 接下来N-1行，每行三个整数X，Y，Z表示宾馆X和宾馆Y之间有一条长度为Z的隧道
 再接下来一行M表示这天顾客的数量。
 紧跟着M行每行三个整数（S， T， V）表示该顾客会从宾馆S走到宾馆T，速度为v

Output

 对于每个T，输出一行，表示顾客的碰面次数。

Sample Input

1
3
1 2 1
2 3 1
3
1 3 2
3 1 1
1 2 3

Sample Output

2

HINT

【数据规模】

 1<=T<=20   1<=N<=10^5   0<=M<=10^3   1<=V<=10^6   1<=Z<=10^3

一道很麻烦的题，尤其是分类讨论两个人之间的情况，有很多种，需要合并，并且求相交的路径是关键，详见：http://hzwer.com/6871.html

借鉴了大神的代码，学会了怎么写NlogN预处理，O(1)查询的LCA

Code：

2397816

3700

Accepted

39076 kb

21208 ms

C++/Edit

4245 B

2017-11-02 22:18:36

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;
typedef pair<int, int>pii;

const int Max = 1000;
const int Maxn = 100000;
const int Maxm = Maxn << 1;
const int LG = 18;

int N, M, ecnt, Dfn;
int fir[Maxn + 5], V[Maxm + 5], Len[Maxm + 5], nxt[Maxm + 5];
int S[Max + 5], T[Max + 5], Vs[Max + 5], Dep[Maxn + 5];
int mn[Maxm + 5][LG], an[Maxm + 5][LG];
int ID[Maxn + 5], LOG[Maxm + 5], Bin[LG];
LL Dis[Maxn + 5];

void getint(int & num){
    char c; int flg = 1;    num = 0;
    while((c = getchar()) < '0' || c > '9') if(c == '-')    flg = -1;
    while(c >= '0' && c <= '9'){    num = num * 10 + c - 48;    c = getchar(); }
    num *= flg;
}

void addedge(int a, int b, int c){
    V[++ ecnt] = b, Len[ecnt] = c, nxt[ecnt] = fir[a], fir[a] = ecnt;
}

void Dfs1(int u, int ff){
    Dep[u] = Dep[ff] + 1;
    an[++ Dfn][0] = u;
    mn[Dfn][0] = Dep[u];
    ID[u] = Dfn;
    for(int i = fir[u]; i; i = nxt[i])  if(V[i] != ff){
        Dis[V[i]] = Dis[u] + Len[i];
        Dfs1(V[i], u);
        an[++ Dfn][0] = u;
        mn[Dfn][0] = Dep[u];
    }
}

int LCA(int u, int v){
    int a = ID[u], b = ID[v];
    if(a > b)   swap(a, b);
    int t = LOG[b - a + 1];
    return mn[a][t] < mn[b - Bin[t] + 1][t] ? an[a][t] : an[b - Bin[t] + 1][t];
}

LL Get_d(int a, int b){
    return Dis[a] + Dis[b] - 2 * Dis[LCA(a, b)];
}

int Calclose(int a, int b, int c){
    int r = LCA(a, b), f;
    if(r != LCA(r, c))  return r;
    f = LCA(a, c);  if(f != r)  return f;
    f = LCA(b, c);  if(f != r)  return f;
    return r;
}

pii get_pa(int a, int b, int c, int d){
    int t1 = Calclose(a, b, c), t2 = Calclose(a, b, d), t3 = Calclose(c, d, a), t4 = Calclose(c, d, b);
    if(t1 > t2) swap(t1, t2);
    if(t3 > t4) swap(t3, t4);
    if(t1 != t3 || t2 != t4)    return make_pair(0, 0);
    return make_pair(t1, t2);
}

int solve(int a, int b){
    if(S[a] == S[b])    return 1;
    pii p = get_pa(S[a], T[a], S[b], T[b]);
    if(! p.first)   return 0;
    if(p.first == p.second)
        return Get_d(p.first, S[a]) * Vs[b] == Get_d(p.first, S[b]) * Vs[a];
    else{
        if(p.second == Calclose(p.first, p.second, S[a]))  swap(p.first, p.second);
        if(Calclose(p.first, p.second, S[a]) == Calclose(p.first, p.second, S[b])){
            LL d1 = Get_d(S[a], p.first) * Vs[b], d2 = Get_d(S[b], p.first) * Vs[a];
            if(d1 > d2) swap(a, b);
            else if(d1 == d2)    return 1;
            return Get_d(S[a], p.second) * Vs[b] >= Get_d(S[b], p.second) * Vs[a];
        }
        else return (Get_d(S[a],p.first)*Vs[b] <= Get_d(S[b], p.first)*Vs[a] && Get_d(S[a],p.second)*Vs[b] >= Get_d(S[b], p.second)*Vs[a]);
	}
}

int main(){
    LOG[0] = -1;
    for(int i = 1; i < Maxm; ++ i) LOG[i] = LOG[i >> 1] + 1;
    Bin[0] = 1;
    for(int i = 1; i < LG; ++ i) Bin[i] = Bin[i - 1] << 1;
    int Tt;
    getint(Tt);
    while(Tt --){
        memset(fir, 0, sizeof fir );
        ecnt = Dfn = 0;
        getint(N);
        int u, v, w;
        for(int i = 1; i < N; ++ i){
            getint(u), getint(v), getint(w);
            addedge(u, v, w), addedge(v, u, w);
        }
        Dfs1(1, 0);
        for(int j = 1; j < LG; ++ j)
            for(int i = 1; i <= Dfn; ++ i)  if(i + Bin[j] - 1 <= Dfn){
                if(mn[i][j - 1] <= mn[i + Bin[j - 1]][j - 1])
                    mn[i][j] = mn[i][j - 1],
                    an[i][j] = an[i][j - 1];
                else mn[i][j] = mn[i + Bin[j - 1]][j - 1],
                    an[i][j] = an[i + Bin[j - 1]][j - 1];
            }
        getint(M);
        for(int i = 1; i <= M; ++ i)    getint(S[i]), getint(T[i]), getint(Vs[i]);
        int Ans = 0;
        for(int i = 1; i < M; ++ i)
            for(int j = i + 1; j <= M; ++ j)
                Ans += solve(i, j);
        printf("%d\n", Ans);
    }
    return 0;
}
/*
1
3
1 2 1
2 3 1
3
1 3 2
3 1 1
1 2 3

*/