BZOJ3700 发展城市题解（LCA）

题目：BZOJ3700.
题目大意：给定一棵$n$个点的带权树，第$i$条边边权为$z_i$.此时$m$个人同时以$v_i$的速度从$u_i$出发去$v_i$，问有多少对人会在路上碰面.初始和在刚走到终点时都算在路上，但走到终点后不算.
数据组数$T\le 20$，$1\le n\le 10^5,1\le m,z_i\le 10^3,1\le v_i\le 10^6$.

考虑大力枚举每一对人，问题转化为判定两个人是否会碰面.

想到碰面一定是在他们走的两条路径的交上，所以我们先求出路径交.

首先考虑如何判断是否有路径交，我们先比较两条路径的LCA深度，假设LCA深度小的路径为$(x_0,y_0)$，LCA为$lc{a}_0$，深度大的为$(x_1,y_1),lc{a}_1$.

容易发现，两条路径若有交，则交一定包含$lc{a}_1$，也就是说两条路径有交的充分必要条件为$lc{a}_1$在路径$(x_0,y_0)$上.

判断是否有交之后，我们考虑如何求交.

很显然，交的端点必然是$(x_0,x_1),(x_0,y_1),(y_0,x_1),(y_0,y_1)$四对点对的LCA中产生的.

具体来说，我们把这四对点的LCA去重并去掉其中深度小于$lc{a}_1$的LCA，取其中dfs序最大的两个（若只有一个就取一个）即可.

然后考虑这两个人分别是从路径交上的那个点进入和退出的，这个东西可以根据走到两个点的距离来判.

得到这个信息后，我们就可以判定他们走的是同向还是异向.如果是同向，那么先走到路径交起点的必然得后走出终点才会相遇；如果是异向，那么只要每个人都在对方走出终点前走进起点就会相遇.

这两种情况都可以通过求他们到达某个点的时间来操作，不过由于除法会损失精度，而速度和距离都没有超过int范围，可以把除式转化为乘式.

同时由于求路径交和距离需要用到大量的求LCA操作，需要使用欧拉序+RMQ做到$O(1)$求LCA.

时间复杂度$O(T(n\log n+m^2))$.

代码如下：

#include<bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N=100000,M=1000,C=20;

int Ri(){
  int x=0,y=1;
  char c=getchar();
  for (;c<'0'||c>'9';c=getchar()) if (c=='-') y=-1;
  for (;c<='9'&&c>='0';c=getchar()) x=x*10+c-'0';
  return x*y;
}

int lg[N*2+9];

void Get_lg(){
  for (int i=2;i<=N<<1;++i) lg[i]=lg[i>>1]+1;
}

void start(){
  Get_lg();
}

int n,m;
struct side{
  int y,next,v;
}e[N*2+9];
int lin[N+9],cs;

void Ins(int x,int y,int v){e[++cs].y=y;e[cs].v=v;e[cs].next=lin[x];lin[x]=cs;}
void Ins2(int x,int y,int v){Ins(x,y,v);Ins(y,x,v);}

int st[M+9],td[M+9],v[M+9];

void into(){
  n=Ri();
  for (int i=1;i<=n;++i) lin[i]=0;
  cs=0;
  for (int i=1;i<n;++i){
	int x,y,v;
	x=Ri();y=Ri();v=Ri();
	Ins2(x,y,v);
  }
  m=Ri();
  for (int i=1;i<=m;++i){
	st[i]=Ri();td[i]=Ri();v[i]=Ri();
  }
}

int dep[N+9],dis[N+9],dfs[N+9],co;
int mn[N*2+9][C];

void Dfs_ord(int k,int fa){
  dep[k]=dep[fa]+1;
  mn[++co][0]=k;
  dfs[k]=co;
  for (int i=lin[k];i;i=e[i].next)
	if (e[i].y^fa){
	  dis[e[i].y]=dis[k]+e[i].v;
	  Dfs_ord(e[i].y,k);
	  mn[++co][0]=k;
	}
}

void Get_mn(){
  for (int i=1;i<C;++i)
	for (int j=1;j+(1<<i)-1<=co;++j){
	  int t0=mn[j][i-1],t1=mn[j+(1<<i-1)][i-1];
	  mn[j][i]=dep[t0]<dep[t1]?t0:t1;
	}
}

int Query_lca(int x,int y){
  if (dfs[x]>dfs[y]) swap(x,y);
  int t=lg[dfs[y]-dfs[x]+1],t0=mn[dfs[x]][t],t1=mn[dfs[y]-(1<<t)+1][t];
  return dep[t0]<dep[t1]?t0:t1;
}

int Query_dis(int x,int y){return dis[x]+dis[y]-2*dis[Query_lca(x,y)];}

bool Check_cross(int x0,int y0,int v0,int x1,int y1,int v1){
  if (x0==x1) return 1;
  int lca0=Query_lca(x0,y0),lca1=Query_lca(x1,y1);
  if (dep[lca0]>dep[lca1]) swap(x0,x1),swap(y0,y1),swap(lca0,lca1),swap(v0,v1);
  if (Query_dis(lca1,x0)+Query_dis(lca1,y0)^dis[x0]+dis[y0]-2*dis[lca0]) return 0;
  int t[4]={Query_lca(x0,x1),Query_lca(x0,y1),Query_lca(y0,x1),Query_lca(y0,y1)},x=0,y=0;
  for (int i=0;i<4;++i)
    if (dfs[t[i]]>dfs[x]&&dep[t[i]]>=dep[lca1]) x=t[i];
  for (int i=0;i<4;++i)
    if (x^t[i]&&dfs[t[i]]>dfs[y]&&dep[t[i]]>=dep[lca1]) y=t[i];
  if (!y) return (LL)v1*Query_dis(x0,x)==(LL)v0*Query_dis(x1,x);
  int d0x=Query_dis(x0,x),d0y=Query_dis(x0,y),d1x=Query_dis(x1,x),d1y=Query_dis(x1,y);
  if ((LL)v1*d0x==(LL)v0*d1x||(LL)v0*d1y==(LL)v1*d0y) return 1;
  if (d0x<d0y==d1x<d1y) return (LL)d0x*v1<(LL)d1x*v0^(LL)d0y*v1<(LL)d1y*v0;
  else{
	if (d0x>d0y) swap(x,y),swap(d0x,d0y),swap(d1x,d1y);
	return (LL)v0*d1x>=(LL)v1*d0x&&(LL)v1*d0y>=(LL)v0*d1y;
  }
}

int ans;

void Get_ans(){
  ans=0;
  for (int i=1;i<=m;++i)
	for (int j=i+1;j<=m;++j) ans+=Check_cross(st[i],td[i],v[i],st[j],td[j],v[j]);
}

void work(){
  co=0;
  Dfs_ord(1,0);
  Get_mn();
  Get_ans();
}

void outo(){
  printf("%d\n",ans);
}

int main(){
  int T=Ri();
  start();
  for (;T--;){
    into();
    work();
    outo();
  }
  return 0;
}