BZOJ3251:树上三角形(乱搞)

Description

给定一大小为n的有点权树，每次询问一对点(u,v)，问是否能在u到v的简单路径上取三个点权，以这三个权值为边长构成一个三角形。同时还支持单点修改。

Input

第一行两个整数n、q表示树的点数和操作数

第二行n个整数表示n个点的点权

以下n-1行，每行2个整数a、b，表示a是b的父亲（以1为根的情况下）

以下q行，每行3个整数t、a、b

若t=0，则询问(a,b)

若t=1，则将点a的点权修改为b

n,q<=100000，点权范围[1,2^31-1]

Output

对每个询问输出一行表示答案，“Y”表示有解，“N”表示无解。

Sample Input

5 5
1 2 3 4 5
1 2
2 3
3 4
1 5
0 1 3
0 4 5
1 1 4
0 2 5
0 2 3

Sample Output

N
Y
Y
N

Solution

考虑对于一个询问的一个树链，如果我们自己构造，让他不含三角形我们会怎么构造：

肯定是像$1,2,3,5,8,13$一样，类似斐波那契数列。

而斐波那契又是增长非常快的，所以当询问的树链长度超过一个值(我设的$50$个点)就肯定$Y$，否则就暴力。

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<vector>
 #include<algorithm>
 #define N (100009)
 using namespace std;

 struct Edge{int to,next;}edge[N<<];
 int n,q,a[N],f[N][],Depth[N];
 int head[N],num_edge;
 vector<int>v;

 inline int read()
 {
     int x=,w=; char c=getchar();
     while (c<'' || c>'') {if (c=='-') w=-; c=getchar();}
     while (c>='' && c<='') x=x*+c-'', c=getchar();
     return x*w;
 }

 void add(int u,int v)
 {
     edge[++num_edge].to=v;
     edge[num_edge].next=head[u];
     head[u]=num_edge;
 }

 void DFS(int x,int fa)
 {
     f[x][]=fa; Depth[x]=Depth[fa]+;
     for (int i=; i<=; ++i)
         f[x][i]=f[f[x][i-]][i-];
     for (int i=head[x]; i; i=edge[i].next)
         if (edge[i].to!=fa) DFS(edge[i].to,x);
 }

 int LCA(int x,int y)
 {
     if (Depth[x]<Depth[y]) swap(x,y);
     for (int i=; i>=; --i)
         if (Depth[f[x][i]]>=Depth[y]) x=f[x][i];
     if (x==y) return x;
     for (int i=; i>=; --i)
         if (f[x][i]!=f[y][i]) x=f[x][i], y=f[y][i];
     return f[x][];
 }

 void Solve(int x,int y,int lca)
 {
     v.clear();
     while (x!=lca) v.push_back(a[x]), x=f[x][];
     while (y!=lca) v.push_back(a[y]), y=f[y][];
     v.push_back(a[lca]);
     sort(v.begin(),v.end());
     for (int i=,s=v.size(); i<s-; ++i)
         if (1ll*v[i-]+v[i]>v[i+]) {puts("Y"); return;}
     puts("N");
 }

 int main()
 {
     n=read(); q=read();
     for (int i=; i<=n; ++i) a[i]=read();
     for (int i=;  i<=n-; ++i)
     {
         int u=read(),v=read();
         add(u,v); add(v,u);
     }
     DFS(,);
     while (q--)
     {
         int opt=read(),x=read(),y=read();
         if (opt==)
         {
             int lca=LCA(x,y);
             if (Depth[x]-Depth[lca]+Depth[y]-Depth[lca]+>) puts("Y");
             else Solve(x,y,lca);
         }
         else a[x]=y;
     }
 }