BZOJ 1906. 树上的蚂蚁

传送门

发现蚂蚁不多，所以考虑两两枚举然后判断

那么首先要求出两条链的公共部分，然后根据之间在公共链的时间段和是同向还是反向进行判断

思路简单但是细节很多......

首先求链的公共部分，设两种蚂蚁为 $a,b$，路径分别为 $As,At$，$Bs,Bt$

那么经过一波手玩分类讨论，公共部分的两端点就是 $LCA(As,Bs),LCA(As,Bt),LCA(At,Bs),LCA(At,Bt)$ 之间 $dfs$ 序较大的两个

记得之前要先把不在两条链上的点去掉，然后如果最后只有一个点合法则公共部分只有一个点

然后每只蚂蚁在公共链的起点就是距离比较近的那个，判断是否同向只要看看公共链起点是否相等即可

判断点是否在某条链上，因为边权不为 $0$ ，所以可以用点到链两端点的距离和是否等于链长来判断

然后如果两只蚂蚁同向，那么只要判断先到达公共链起点的后到达公共链终点即可

如果不同向，那么要判断它们在公共链的时间区间是否有交

为了避免除法所以移项变成乘法，注意乘会爆 $int$

因为多次求 $LCA$，所以要 $RMQ$ $O(1)$ 求 $LCA$

具体实现我感觉自己代码还挺好看的...

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;
inline int read()
{
    int x=,f=; char ch=getchar();
    while(ch<''||ch>'') { if(ch=='-') f=-; ch=getchar(); }
    while(ch>=''&&ch<='') { x=(x<<)+(x<<)+(ch^); ch=getchar(); }
    return x*f;
}
const int N=2e5+,INF=1e9+;
int n,m,S[N],T[N],V[N],Ans;
int fir[N],from[N<<],to[N<<],val[N<<],cntt;
inline void add(int a,int b,int c)
{
    from[++cntt]=fir[a]; fir[a]=cntt;
    to[cntt]=b; val[cntt]=c;
}
int dep[N],dfn[N],cnt,st[N<<],pos[N<<],Top;
void dfs(int x,int fa)
{
    dfn[x]=++cnt; st[++Top]=x; pos[x]=Top;
    for(int i=fir[x];i;i=from[i])
    {
        int &v=to[i]; if(v==fa) continue;
        dep[v]=dep[x]+val[i]; dfs(v,x); st[++Top]=x;
    }
}
int F[N<<][],Log[N<<];
void pre()
{
    Log[]=-; for(int i=;i<=Top;i++) Log[i]=Log[i>>]+;//
    for(int i=;i<=Top;i++) F[i][]=st[i];
    for(int i=;(<<i)<=Top;i++)
        for(int j=;j+(<<i-)<=Top;j++)
        {
            if( dfn[F[j][i-]] < dfn[ F[j+(<<i-)][i-] ] ) F[j][i]=F[j][i-];
            else F[j][i]=F[j+(<<i-)][i-];
        }
}
inline int query(int x,int y)
{
    int l=pos[x],r=pos[y],k; if(l>r) swap(l,r);
    k=Log[r-l+];
    if(dfn[F[l][k]]<dfn[F[r-(<<k)+][k]]) return F[l][k];
    else return F[r-(<<k)+][k];
}
inline ll dis(int x,int y) { return dep[x]+dep[y]-*dep[query(x,y)]; }
inline bool cmp(const int &A,const int &B) { return dfn[A]>dfn[B]; }
inline bool in_chain(int x,int y,int a) { return dis(x,a)+dis(y,a)==dis(x,y); }
inline bool pd(ll l,ll r,ll x) { return x>=l && x<=r; }
inline bool solve(int As,int At,int Bs,int Bt,int Av,int Bv)
{
    int x[],tot=,p=query(As,Bs);
    if(in_chain(As,At,p)&&in_chain(Bs,Bt,p)) x[++tot]=p;
    p=query(As,Bt);
    if(in_chain(As,At,p)&&in_chain(Bs,Bt,p)) x[++tot]=p;
    p=query(At,Bs);
    if(in_chain(As,At,p)&&in_chain(Bs,Bt,p)) x[++tot]=p;
    p=query(At,Bt);
    if(in_chain(As,At,p)&&in_chain(Bs,Bt,p)) x[++tot]=p;
    if(!tot) return ;
    sort(x+,x+tot+,cmp); if(tot==) x[]=x[];
    int Al=(dis(As,x[])<dis(As,x[]) ? x[] : x[]),Ar=(Al==x[] ? x[] : x[]);
    int Bl=(dis(Bs,x[])<dis(Bs,x[]) ? x[] : x[]),Br=(Bl==x[] ? x[] : x[]);
    ll Asl=dis(As,Al)*Bv,Bsl=dis(Bs,Bl)*Av,Asr=dis(As,Ar)*Bv,Bsr=dis(Bs,Br)*Av;
    if(Al==Bl)
    {
        if(Asl<=Bsl && Asr>=Bsr) return ;
        if(Asl>=Bsl && Asr<=Bsr) return ;
        return ;
    }
    if(pd(Asl,Asr,Bsl)||pd(Asl,Asr,Bsr)) return ;
    if(pd(Bsl,Bsr,Asl)||pd(Bsl,Bsr,Asr)) return ;
    return ;
}
int main()
{
    int TT=read();
    while(TT--)
    {
        cntt=Top=cnt=Ans=; for(int i=;i<=n;i++) fir[i]=;
        n=read(); int a,b,c;
        for(int i=;i<n;i++)
        {
            a=read(),b=read(),c=read();
            add(a,b,c); add(b,a,c);
        }
        m=read();
        for(int i=;i<=m;i++) S[i]=read(),T[i]=read(),V[i]=read();
        dfs(,); pre();
        for(int i=;i<=m;i++)
            for(int j=i+;j<=m;j++)
                if(solve(S[i],T[i],S[j],T[j],V[i],V[j])) Ans++;
        printf("%d\n",Ans);
    }
    return ;
}