以前用树状数组做过一次，现在用线段树再刷一次。。。

首先必须先离散化。。。

然后建立2颗线段树，第一颗表示往左走，每个节点的值的分布。

      第二颗表示往右走，每个节点的值的分布。

然后根据左右走的关系，判断出x,y的值。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define maxn 110000
#define lmin 1
#define rmax len
#define lson l,(l+r)/2,rt<<1
#define rson (l+r)/2+1,r,rt<<1|1
#define root lmin,rmax,1
#define now l,r,rt
#define int_now int l,int r,int rt
#define INF 999999999999
#define LL long long
#define mod 10007
struct list
{
    int father;
    int l,r;
    int w;
}node[maxn];
vector<int>vec[maxn];
struct listt
{
    int x,y;
    int v;
    int w;
}qq[maxn];
map<int,int>mp;
int len;
int fs[maxn*2];
int st=0;
int sum[maxn*4][2];
void updata(int ll,int rr,int x,int leap,int_now)
{
    if(ll>r||rr<l)return;
    if(ll<=l&&rr>=r)
    {
        sum[rt][leap]+=x;
        return;
    }
    updata(ll,rr,x,leap,lson);
    updata(ll,rr,x,leap,rson);
    sum[rt][leap]=sum[rt<<1][leap]+sum[rt<<1|1][leap];
}
int query(int ll,int rr,int leap,int_now)
{
    if(ll>r||rr<l)return 0;
    if(ll<=l&&rr>=r)return sum[rt][leap];
    return query(ll,rr,leap,lson)+query(ll,rr,leap,rson);
}
void dfs(int x)
{
    for(int i=0;i<vec[x].size();i++)
    {
        int bi=vec[x][i];
        int w=qq[bi].w;
        w=mp[w];
        int nm=query(w,w,0,root)+query(w,w,1,root);
        int ll=query(1,w-1,0,root);
        int lr=query(w+1,len,0,root);
        int rl=query(1,w-1,1,root);
        int rr=query(w+1,len,1,root);
        if(nm!=0)continue;
        qq[bi].x=rl;
        qq[bi].y=(ll+rl)*3+lr+rr;

    }
    int id=mp[node[x].w];
    if(node[x].l!=0)
    {
        updata(id,id,1,0,root);
        dfs(node[x].l);
        updata(id,id,-1,0,root);
    }
    if(node[x].r!=0)
    {
        updata(id,id,1,1,root);
        dfs(node[x].r);
        updata(id,id,-1,1,root);
    }
}
int main()
{
    int T,n,m,u,l,r;
    scanf("%d",&T);
    while(T--)
    {
        st=0;
        memset(sum,0,sizeof(sum));
        memset(node,0,sizeof(node));
        mp.clear();
        scanf("%d",&n);
        len=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&node[i].w);
            fs[++st]=node[i].w;
            vec[i].clear();
        }
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d%d%d",&u,&l,&r);
            node[l].father=node[r].father=u;
            node[u].l=l;
            node[u].r=r;
        }
        node[1].father=-1;
        int q,v,ww;
        scanf("%d",&q);
        for(int i=1;i<=q;i++)
        {
            scanf("%d%d",&v,&ww);
            fs[++st]=ww;
            qq[i].v=v;
            qq[i].w=ww;
            qq[i].x=qq[i].y=-1;
            vec[v].push_back(i);
        }
        sort(fs+1,fs+st+1);
        len=0;
        fs[0]=-1;
        for(int i=1;i<=st;i++)
        {
            if(fs[i]!=fs[i-1])
            {
                if(mp.find(fs[i])==mp.end())
                {
                    mp[fs[i]]=++len;
                }
            }
        }
        dfs(1);
        for(int i=1;i<=q;i++)
        {
            if(qq[i].x==-1)puts("0");
            else
            {
                printf("%d %d\n",qq[i].x,qq[i].y);
            }
        }
    }
    return 0;
}