bzoj 3757: 苹果树

Description

    神犇家门口种了一棵苹果树。苹果树作为一棵树，当然是呈树状结构，每根树枝连接两个苹果，每个苹果都可以沿着一条由树枝构成的路径连到树根，而且这样的路径只存在一条。由于这棵苹果树是神犇种的，所以苹果都发生了变异，变成了各种各样的颜色。我们用一个到n之间的正整数来表示一种颜色。树上一共有n个苹果。每个苹果都被编了号码，号码为一个1到n之间的正整数。我们用0代表树根。只会有一个苹果直接根。

有许许多多的人来神犇家里膜拜神犇。可神犇可不是随便就能膜拜的。前来膜拜神犇的人需要正确回答一个问题，才能进屋膜拜神犇。这个问题就是，从树上编号为u的苹果出发，由树枝走到编号为v的苹果，路径上经过的苹果一共有多少种不同的颜色（包括苹果u和苹果v的颜色）？不过神犇注意到，有些来膜拜的人患有色盲症。具体地说，一个人可能会认为颜色a就是颜色b，那么他们在数苹果的颜色时，如果既出现了颜色a的苹果，又出现了颜色b的苹果，这个人只会算入颜色b，而不会把颜色a算进来。

神犇是一个好人，他不会强人所难，也就会接受由于色盲症导致的答案错误（当然答案在色盲环境下也必须是正确的）。不过这样神犇也就要更改他原先数颜色的程序了。虽然这对于神犇来说是小菜一碟，但是他想考验一下你。你能替神犇完成这项任务吗？

Input

输入第一行为两个整数n和m，分别代表树上苹果的个数和前来膜拜的人数。

接下来的一行包含n个数，第i个数代表编号为i的苹果的颜色Coli。

接下来有n行，每行包含两个数x和y，代表有一根树枝连接了苹果x和y（或者根和一个苹果）。

接下来有m行，每行包含四个整数u、v、a和b，代表这个人要数苹果u到苹果v的颜色种数，同时这个人认为颜色a就是颜色b。如果a=b=0，则代表这个人没有患色盲症。

Output

输出一共m行，每行仅包含一个整数，代表这个人应该数出的颜色种数。

Sample Input

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

Sample Output

2
1
2

HINT

0<=x,y,a,b<=N

N<=50000

1<=U,V,Coli<=N

似乎和树这种东西不兼容。。这题折腾了3个多小时。。从dfs序到分块到莫队几乎每个地方都重写了一遍。

1、求出dfs序转化成类似括号序列的序列进行分块

2、按照括号序列转化询问的左右端点

3、转换成和序列一样的莫队做法

差不多就是以上三步了。。

【我试了各种分块方法。。有一次估计就超时了2秒左右。最后还是换成这种才过的】

#include<queue>
#include<cmath>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
struct line
{
     int s,t;
     int next;
}a[200001];
int head[100001];
int edge;
inline void add(int s,int t)
{
	 a[edge].next=head[s];
     head[s]=edge;
     a[edge].s=s;
     a[edge].t=t;
}
struct que
{
     int u,v,a,b;
     int p;
     int x;
}ask[100001];
//--------------------------LCA
int deep[100001];
int fa[100001];
bool v[100001];
int ans[100001][22];
inline void bfs(int r)
{
     int i,j;
     deep[r]=1;
     for(i=0;i<=21;i++)
          ans[r][i]=r;
     queue <int>Q;
     while(!Q.empty())
          Q.pop();
     Q.push(r);
     v[r]=true;
     while(!Q.empty())
     {
          int d=Q.front();
          Q.pop();
          for(i=head[d];i!=0;i=a[i].next)
          {
               int t=a[i].t;
               if(!v[t])
               {
                    v[t]=true;
                    Q.push(t);
                    fa[t]=d;
                    deep[t]=deep[d]+1;
                    ans[t][0]=d;
                    int dt;
					long long dc;
                    for(j=1;j<=21;j++)
                    {
                    	 dt=ans[t][j-1];
                         ans[t][j]=ans[dt][j-1];
                    }
               }
          }
     }
}
inline int swim(int x,int y)
{
     while(deep[x]!=deep[y])
     {
          int i=0;
          while(deep[ans[y][i]]>deep[x])
               i++;
          if(i!=0)
               i--;
          y=ans[y][i];
     }
     return y;
}
inline long long lca(int x,int y)
{
     if(deep[x]>deep[y])
     {
          int t=x;
          x=y;
          y=t;
     }
     y=swim(x,y);
     int i=21;
     while(x!=y)
     {
          while(ans[x][i]==ans[y][i]&&i>0)
               i--;
          x=ans[x][i];
          y=ans[y][i];
     }
     return x;
}
//-------------------------LCA
int col[200001];
int tot;
int dline[300001];
int ld[200001],rd[200001];
int tag[300001],pos[200001];
inline bool cmp1(que x,que y)
{
     if(pos[x.u]==pos[y.u])
     {
          if(x.v<y.v)
               return true;
          return false;
     }
     if(pos[x.u]<pos[y.u])
          return true;
     return false;
}
inline bool cmp2(que x,que y)
{
     if(x.p<y.p)
          return true;
     return false;
}
inline void dfsx(int d)
{
     int i,j;
     for(i=head[d];i!=0;i=a[i].next)
     {
     	  int t=a[i].t;
          if(!v[t])
          {
               v[t]=true;
               tot++;
               dline[tot]=t;
               ld[t]=tot;
               dfsx(t);
               tot++;
               dline[tot]=t;
               rd[t]=tot;
          }
     }
}
int sum,sa[100001];
inline void reverse(int x)
{
     if(!v[x])
	 {
	      v[x]=true;
		  sa[col[x]]++;
		  if(sa[col[x]]==1)
		       sum++;
	 }
     else
	 {
	      v[x]=false;
		  sa[col[x]]--;
		  if(sa[col[x]]==0)
		       sum--;
	 }
}
int main()
{
	 freopen("apple.in","r",stdin);
	 freopen("apple.out","w",stdout);
     int n,m;
     scanf("%d%d",&n,&m);
     int i;
     int s,t;
     for(i=1;i<=n;i++)
          scanf("%d",&col[i]);
     for(i=1;i<=n;i++)
     {
          scanf("%d%d",&s,&t);
          edge++;
          add(s,t);
          edge++;
          add(t,s);
     }
     bfs(0);
     memset(v,false,sizeof(v));
     v[0]=true;
     tot++;
     dline[1]=0;
     ld[0]=1;
     dfsx(0);
     tot++;
     dline[tot]=0;
     rd[0]=tot;
     int nt=int(sqrt(tot));
     for(i=1;i<=tot;i++)
          pos[i]=(i-1)/nt+1;
     for(i=1;i<=m;i++)
     {
          scanf("%d%d%d%d",&ask[i].u,&ask[i].v,&ask[i].a,&ask[i].b);
     	  if(ld[ask[i].u]>ld[ask[i].v])
     	       swap(ask[i].u,ask[i].v);
     	  ask[i].u=rd[ask[i].u];
     	  ask[i].v=ld[ask[i].v];
     	  if(ask[i].u>=ask[i].v)
     	       ask[i].u=ld[dline[ask[i].u]];
          ask[i].p=i;
     }
     sort(ask+1,ask+1+m,cmp1);
     memset(v,false,sizeof(v));
     sa[0]=1;
     //int l=ask[1].u,r=l;
     //reverse(dline[l]);
     int l=1,r=0;
     for(i=1;i<=m;i++)
     {
          while(l<ask[i].u)
          {
	           reverse(dline[l]);
	           l++;
	      }
	      while(l>ask[i].u)
	      {
	           l--;
	           reverse(dline[l]);
	      }
          while(r<ask[i].v)
          {
     	       r++;
	           reverse(dline[r]);
	      }
	      while(r>ask[i].v)
	      {
	           reverse(dline[r]);
	           r--;
	      }
          t=lca(dline[l],dline[r]);
          int flag=false;
          if(dline[ask[i].u]!=t&&dline[ask[i].v]!=t)
          {
		       reverse(t);
		       flag=true;
		  }
          ask[i].x=sum;
          if(sa[ask[i].a]&&sa[ask[i].b]&&ask[i].a!=ask[i].b)
	           ask[i].x--;
	      if(flag)
               reverse(t);
     }
     sort(ask+1,ask+1+m,cmp2);
     for(i=1;i<=m;i++)
          printf("%d\n",ask[i].x);
     return 0;
}