[欧拉序列 LCA 鬼畜暴枚] BZOJ 1906 树上的蚂蚁 && BZOJ 3700 发展城市

搬运题解：http://blog.sina.com.cn/s/blog_ab8386bc0101i146.html

首先求出这颗树的欧拉序列，方便做LCA。。

因为蚂蚁是10^3级别 完全可以枚举两只蚂蚁

那么剩下的问题就是 在很短的时间内判断两只蚂蚁是否会相遇

对于两只蚂蚁 设他们的路径是a→b c→d 我们先找到他们的路径中相同的部分

路径中相同的部分可能是一个点，也可能是很多个点组成的一条路径甚至是没有相同的部分。。

那么从点入手，假设路径有相同的部分 那么很显然 c到路径[a,b]最近的点一定在那个相同部分上面。。

证明似乎很显然了？ 因为有重合的部分，那么这个点p必定在[c,d]路径上 且是开始重合的第一个点。。

那么我们只要找到c距离[a,b]最近的点u，和d距离[a,b]最近的点v

那么我们就找到了路径[u,v]是重合部分//如果u==v说明重合部分只有一个点

如果没有重合部分呢?

很简单 令r=LCA(c,d)若u不在r的子树中即LCA(r,u)!=r那么就没有重合部分了。。

那现在遗留了一个问题：这个最近的点怎么求呢?

我们以c为例：

此时令r=LCA(a,b)，假设c不在r的子树中，即LCA(c,r)!=r那么r就是我们要找的这个点

如果LCA(c,r)==r有三种情况，第一种是LCA(a,c)==LCA(b,c)==r此时依然是r

另一种是LCA(a,c)!=r 那么此时就是LCA(a,c) 还有一种 LCA(b,c)!=r 此时是LCA(b,c)

这个画个图就能理解。。

另外其实不用再分三类，因为如果LCA(a,c)!=r 那么这个点就一定是LCA(b,c)了。。

最后剩下一个问题 即是知道了相同路径如何判断是否相遇?//如果没有相同路径肯定不相遇

那就分情况讨论了，比如说蚂蚁方向相反啦，相同的时候怎么样怎么样啦。。

总之两只蚂蚁到这个相同路径的起始时间和终止时间是确定的 这个是可以O(1)求的//LCA是O(1)

所以虽然我们分了这么一堆情况最后处理两只蚂蚁仍然是O(1)的

最后时间复杂度O(nlogn+m^2) 即预处理LCA的时间加上枚举两只蚂蚁的时间。。

再次吐槽卡精度

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;

inline char nc(){
	static char buf[100000],*p1=buf,*p2=buf;
	if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }
	return *p1++;
}

inline void read(int &x){
	char c=nc(),b=1;
	for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
	for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}

const double eps=1e-10;

inline int dcmp(double a,double b){
	if (fabs(a-b)<eps) return 0;
	if (a<b) return -1; return 1;
}

const int N=400005;
const int K=21;

struct edge{
	int u,v,w,next;
}G[N];
int head[N],inum;

inline void add(int u,int v,int w,int p){
	G[p].u=u; G[p].v=v; G[p].w=w; G[p].next=head[u]; head[u]=p;
}

int lis[N],pnt,depth[N],pos[N]; int dis[N];
#define V G[p].v
inline void dfs(int u,int fa){
	lis[++pnt]=u; depth[u]=depth[fa]+1; pos[u]=pnt;
	for (int p=head[u];p;p=G[p].next)
		if (V!=fa)
			dis[V]=dis[u]+G[p].w,dfs(V,u),lis[++pnt]=u;
}

inline int Min(int a,int b){
	return depth[a]<depth[b]?a:b;
}

int a[N][K],Log[N];

inline void Pre(){
	for (int i=2;i<=pnt;i++) Log[i]=Log[i>>1]+1;
	for (int i=1;i<=pnt;i++) a[i][0]=lis[i];
	for (int k=1;k<K;k++)
		for (int i=1;i<=pnt;i++){
			a[i][k]=a[i][k-1];
			if (i+(1<<(k-1))<=pnt)
				a[i][k]=Min(a[i][k-1],a[i+(1<<(k-1))][k-1]);
		}
}

inline int Query(int l,int r){
	if (l>r) swap(l,r);
	int t=Log[r-l+1];
	return Min(a[l][t],a[r-(1<<t)+1][t]);
}

inline int LCA(int u,int v){
	return Query(pos[u],pos[v]);
}

inline int Dist(int u,int v){
	return dis[u]+dis[v]-2*dis[LCA(u,v)];
}

int n,m,ans;
int s[N],t[N],v[N];

inline int Calc(int a,int b,int c){
	int r=LCA(a,b),t1=LCA(a,c),t2=LCA(b,c);
	if (LCA(c,r)!=r) return r;
	if (t1==t2 && t2==r) return r;
	if (t1!=r) return t1; else return t2;
}

inline bool Solve(int x,int y){
	double t1,t2,t3,t4; int t5=LCA(s[x],t[x]),t6=LCA(s[y],t[y]);
	if (depth[t5]>depth[t6]) swap(x,y),swap(t5,t6);
	int a=s[x],b=t[x],c=s[y],d=t[y],v1=v[x],v2=v[y];
	int f1,f2;
	int u=Calc(a,b,c),v=Calc(a,b,d);
	if (LCA(t6,u)!=t6) return 0;
	t1=(double)Dist(s[x],u)/v1; t2=(double)Dist(s[x],v)/v1;
	if (t1>t2) swap(t1,t2),f1=1; else f1=0;
	t3=(double)Dist(s[y],u)/v2; t4=(double)Dist(s[y],v)/v2;
	if (t3>t4) swap(t3,t4),f2=1; else f2=0;
	if (u==v){
		return dcmp(t1,t3)==0;	
	}else if (f1^f2){
		if (dcmp(max(t1,t3),min(t2,t4))>0) 
			return 0;
		return 1;
	}else{
		if (v1==v2){
			return dcmp(t1,t3)==0;
		}
		double t=(double)(v1*t1-v2*t3)/(v1-v2);
		if (dcmp(max(t1,t3),t)<=0 && dcmp(t,min(t2,t4))<=0) 
			return 1;
		return 0;
	}
}

int main()
{
	int T,iu,iv,iw;
	freopen("t.in","r",stdin);
	freopen("t.out","w",stdout);
	read(T);
	while (T--){
		read(n);
		for (int i=1;i<n;i++)
			read(iu),read(iv),read(iw),add(iu,iv,iw,++inum),add(iv,iu,iw,++inum);
		dfs(1,0);
		Pre();
		read(m);
		for (int i=1;i<=m;i++)
			read(s[i]),read(t[i]),read(v[i]);
		ans=0;
		for (int i=1;i<=m;i++)
			for (int j=i+1;j<=m;j++)
				if (Solve(i,j))
					ans++;
		printf("%d\n",ans);
		cl(head); inum=0; pnt=0;
	}
}