Codeforces983E. NN country

新鲜出炉！

$n \leq 200000$的树，给$m \leq 200000$条链，$q \leq 200000$个询问，每次问一条询问链最少用m条中的几条给定链覆盖其所有边，可能无解。

首先确定一种贪心策略：$low_x$表示$x$能通过一条链跳到的最高的点（这里吐槽一下，题解描述时的树是反过来的，树根在地上！反人类啊，然后他后面所有的“高”“矮”描述全是反过来的！！！无良出题人），假设询问俩点$u,v$，lca即为$t$，那么先从$u$一直沿着$low$跳到$t$下面一点点，$v$一直沿着$low$跳到$t$下面一点点，这样的步数分别为$a$和$b$，然后答案为$a+b+2$或者$a+b+1$，取决于最后跳到那俩点是否能在一条链上。$low$的计算dfs一次就行（我TM还跑去看代码了），建出$low$的st表之后上面操作可以倍增出，现在开始$v$和$u$表示他们最后跳到比$t$下面一点点的那俩点。

现在问：一棵树好多链，每次问一个点对有没有可能在一条链上。

这不是二维数点嘛hhh，dfs序搞出来，然后如果两个询问点子树内有同个链的端点，那就存在。dfs搜一遍（第一维），搜一个点之后，先查询下他对应的另一询问点的子树（第二维），然后把这个点上的“链端点”加到树状数组，然后搜子树（第一维），然后回来再查一次另一询问点的子树（第二维），看两次查的一不一样。

 //#include<iostream>
 #include<cstring>
 #include<cstdio>
 //#include<time.h>
 //#include<complex>
 //#include<set>
 //#include<queue>
 #include<vector>
 #include<algorithm>
 #include<stdlib.h>
 using namespace std;

 #define LL long long
 int qread()
 {
     char c; int s=,f=; while ((c=getchar())<'' || c>'') (c=='-') && (f=-);
     do s=s*+c-''; while ((c=getchar())>='' && c<=''); return s*f;
 }

 //Pay attention to '-' , LL and double of qread!!!!

 int n,m,lq;
 #define maxn 200011
 struct Edge{int to,next;}edge[maxn<<]; int first[maxn],le=;
 void in(int x,int y) {Edge &e=edge[le]; e.to=y; e.next=first[x]; first[x]=le++;}

 int top[maxn],dep[maxn],fa[maxn],size[maxn],ll[maxn],rr[maxn],Time=,hea[maxn];
 void dfs1(int x)
 {
     size[x]=; hea[x]=; Time++; ll[x]=Time;
     for (int i=first[x];i;i=edge[i].next)
     {
         Edge &e=edge[i];
         fa[e.to]=x; dep[e.to]=dep[x]+; dfs1(e.to); size[x]+=size[e.to];
         if (size[hea[x]]<size[e.to]) hea[x]=e.to;
     }
     rr[x]=Time;
 }
 void dfs2(int x,int tt)
 {
     top[x]=tt;
     if (hea[x]) dfs2(hea[x],tt);
     for (int i=first[x];i;i=edge[i].next) if (edge[i].to!=hea[x]) dfs2(edge[i].to,edge[i].to);
 }
 int lca(int x,int y)
 {
     while (top[x]!=top[y])
     {
         if (dep[top[x]]<dep[top[y]]) x^=y^=x^=y;
         x=fa[top[x]];
     }
     if (dep[x]<dep[y]) return x; return y;
 }

 int low[maxn][];
 void dfslow(int x)
 {
     for (int i=first[x];i;i=edge[i].next)
     {
         Edge &e=edge[i]; dfslow(e.to);
         low[x][]=dep[low[x][]]<dep[low[e.to][]]?low[x][]:low[e.to][];
     }
 }
 void makelow()
 {
     for (int j=;j<=;j++)
         for (int i=;i<=n;i++)
             low[i][j]=low[low[i][j-]][j-];
 }

 struct Node{int x,y,t,ans;}a[maxn],q[maxn];
 vector<int> va[maxn],vb[maxn];
 void ina(int x,int y) {va[x].push_back(y);}
 void inb(int x,int y) {vb[x].push_back(y);}

 int XX;
 int find(int x,int t)
 {
     if (dep[low[x][]]>dep[t]) {XX=-0x3f3f3f3f; return -;}
     if (x==t) {XX=-; return -;}
     int ans=;
     for (int j=;~j;j--) if (dep[low[x][j]]>dep[t]) x=low[x][j],ans|=(<<j);
     XX=ans; return x;
 }

 struct BIT
 {
     int n,a[maxn];
     void clear(int N) {n=N;}
     void add(int x,int v) {for (;x<=n;x+=x&-x) a[x]+=v;}
     int query(int x) {int ans=; for (;x;x-=x&-x) ans+=a[x]; return ans;}
 }t;
 int pp[maxn];
 void dfs(int x)
 {
     for (int sz=vb[x].size(),i=;i<sz;i++)
     {
         int u=vb[x][i];
         pp[u]=t.query(rr[q[u].y])-t.query(ll[q[u].y]-);
     }
     for (int sz=va[x].size(),i=;i<sz;i++)
     {
         int u=va[x][i];
         if (x==a[u].x) t.add(ll[a[u].y],);
         else t.add(ll[a[u].x],);
     }
     for (int i=first[x];i;i=edge[i].next) dfs(edge[i].to);
     for (int sz=vb[x].size(),i=;i<sz;i++)
     {
         int u=vb[x][i];
         if (t.query(rr[q[u].y])-t.query(ll[q[u].y]-)!=pp[u]) q[u].ans--;
     }
 }

 int main()
 {
     n=qread();
     for (int i=,x;i<=n;i++) {x=qread(); in(x,i);}
     dep[]=; dfs1(); dfs2(,);

     for (int i=;i<=n;i++) low[i][]=i;
     m=qread();
     for (int i=;i<=m;i++)
     {
         a[i].x=qread(); a[i].y=qread();
         a[i].t=lca(a[i].x,a[i].y);
         low[a[i].x][]=dep[low[a[i].x][]]<dep[a[i].t]?low[a[i].x][]:a[i].t;
         low[a[i].y][]=dep[low[a[i].y][]]<dep[a[i].t]?low[a[i].y][]:a[i].t;
         ina(a[i].x,i); ina(a[i].y,i);
     }
     dfslow(); makelow();

     lq=qread();
     for (int i=;i<=lq;i++)
     {
         q[i].x=qread(); q[i].y=qread();
         q[i].t=lca(q[i].x,q[i].y);
         q[i].ans=;
         int x=find(q[i].x,q[i].t); q[i].ans+=XX;
         int y=find(q[i].y,q[i].t); q[i].ans+=XX;
         if (x> && y>) {q[i].x=x; q[i].y=y; inb(x,i);}
     }

     t.clear(n);
     dfs();
     for (int i=;i<=lq;i++) printf("%d\n",q[i].ans<?-:q[i].ans);
     return ;
 }