Runtime Error (STACK_OVERFLOW) 已经查出问题了是哪个地方了

本地测试样例没问题，HDU数据会RE。

具体在：在第231行的dfs(代码中注释的地方)进行修改操作会RE。但是奇怪的是我在初始化也用的这个函数不会RE，在后面调用就会RE。而且测试过我初始化完成之后重新跑一侧DFS也会RE。

#pragma comment(linker, "/STACK:202400000,202400000")
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#define int long long
// #define ONLINE_JUDGE
#define INPUT_DATA_TYPE int
#define OUTPUT_DATA_TYPE long long
INPUT_DATA_TYPE read(){register INPUT_DATA_TYPE x=0;register char f=0,c=getchar();while(c<'0'||'9'<c)f=(c=='-'),c=getchar();while('0'<=c&&c<='9')x=(x<<3)+(x<<1)+(c&15),c=getchar();return f?-x:x;}void print(OUTPUT_DATA_TYPE x){register char s[20];register int i=0;if(x<0){x=-x;putchar('-');}if(x==0){putchar('0');return;}while(x){s[i++]=x%10;x/=10;}while(i){putchar(s[--i]+'0');}return;}

struct UF{
    int parents[400010];
    void build(int n){
        register int i;
        for(i=0;i<=n;++i) parents[i]=i;
        return;
    }
    int find(int x){return (x==parents[x])?(x):(parents[x]=find(parents[x]));}
    void merge(int u,int v,int root){parents[find(u)]=root,parents[find(v)]=root;}
}U;

struct EDGE{
    int u,v,w;
    bool operator < (const EDGE another) const{
        return w<another.w;
    }
}edges[400010];

struct kNODE{
    int lChild,rChild,val,lit,id,cnttree,par,linktop,dep,color,imgId;
}tree[400010];

struct iNODE{
    int lChild,rChild,par,kid;
    long long max,val;
}imgTree[100010][15];

const int ZSEG_SIZE=400010;

struct ZSEG_TREE{
    long long tree[ZSEG_SIZE<<2];
    int size;

    void clear(){
        memset(tree,0,sizeof(long long)*(size+10)*2);
        size=0;
        return;
    }

    void build(int n){
        register int i;
        int logn=std::__lg(n+2)+1;
        size=1<<logn;
        for(i=1;i<=n;++i) tree[size+i]=0;
        for(i=size;i;--i) tree[i]=tree[i<<1]+tree[i<<1|1];
        return;
    }

    void update(int pos,long long val){
        for(pos+=size;pos;pos>>=1) tree[pos]+=val;
    }

    long long query(int l,int r){
        long long res=0;
        for(l+=size-1,r+=size+1;l^r^1;l>>=1,r>>=1){
            if(~l&1) res+=tree[l^1];
            if(r&1) res+=tree[r^1];
        }
        return res;
    }
}seg;

int cntid,sid[400010];

std::vector<int> imgcur[400010],cur;

void dfsinit(int u,int p){
    if(!u) return;
    tree[u].cnttree=1;
    tree[u].par=p;
    tree[u].dep=tree[p].dep+1;
    dfsinit(tree[u].lChild,u);
    dfsinit(tree[u].rChild,u);
    tree[u].cnttree+=tree[tree[u].lChild].cnttree+tree[tree[u].rChild].cnttree;
    if(tree[tree[u].lChild].cnttree<tree[tree[u].rChild].cnttree) tree[u].rChild^=tree[u].lChild^=tree[u].rChild^=tree[u].lChild;
    return;
}

void dfslink(int u,int top){
    if(!u) return;
    tree[u].linktop=top;
    tree[u].id=++cntid;
    sid[tree[u].id]=u;
    dfslink(tree[u].lChild,top);
    dfslink(tree[u].rChild,tree[u].rChild);
    return;
}

int getLca(register int u,register int v){
    while(tree[u].linktop!=tree[v].linktop){
        if(tree[tree[u].linktop].dep<tree[tree[v].linktop].dep) u^=v^=u^=v;
        u=tree[tree[u].linktop].par;
    }
    if(tree[u].dep<tree[v].dep) u^=v^=u^=v;
    return v;
}

void dfsImg(int col,int u){
    if(!u) return;
    dfsImg(col,imgTree[col][u].lChild);
    dfsImg(col,imgTree[col][u].rChild);
    int l=imgTree[col][imgTree[col][u].lChild].max;
    int r=imgTree[col][imgTree[col][u].rChild].max;
    imgTree[col][u].max=std::max(tree[imgTree[col][u].kid].val,std::max(l,r));
    long long cp=-imgTree[col][u].val;
    imgTree[col][u].val=imgTree[col][u].max-l-r;
    cp+=imgTree[col][u].val;
    seg.update(tree[imgTree[col][u].kid].id,cp);
    return;
}

int find(register int u,register int lit){
    while(lit>=tree[tree[tree[u].linktop].par].lit&&tree[tree[u].linktop].par) u=tree[tree[u].linktop].par;
    register int l=tree[tree[u].linktop].id,r=tree[u].id+1,mid;
    while(l<r){
        mid=(l+r)>>1;
        if(tree[sid[mid]].lit>lit) l=mid+1;
        else r=mid;
    }
    // if(tree[sid[mid]].lit>lit) 
    return sid[l];
}

long long query(int u){
    return seg.query(tree[u].id,tree[u].id+tree[u].cnttree-1);
}

signed main(){
	#ifndef ONLINE_JUDGE
	freopen("name.in", "r", stdin);
	freopen("name.out", "w", stdout);
	#endif

    register int T=read(),n,m,i,q,u,v,w,tot,root,op;
    while(T--){
        n=read();m=read();q=read();
        for(i=1;i<=n;++i) tree[i].color=read(),imgcur[tree[i].color].push_back(i);
        for(i=1;i<=n;++i) tree[i].val=read();
        for(i=0;i<m;++i){
            edges[i].u=read();
            edges[i].v=read();
            edges[i].w=read();
        }
        std::sort(edges,edges+m);
        U.build((n<<1)+10);
        for(i=0,tot=n+1;i<m;++i){
            if(U.find(edges[i].u)!=U.find(edges[i].v)){
                tree[tot].lChild=U.find(edges[i].u);
                tree[tot].rChild=U.find(edges[i].v);
                U.merge(edges[i].u,edges[i].v,tot);
                tree[tot].lit=edges[i].w;
                ++tot;
            }
        }

        root=tot-1;

        dfsinit(root,0);
        dfslink(root,root);

        // for(i=1;i<tot;++i) printf("u%d par%d lc%d rc%d val%d dep%d hson%d top%d\n",i,tree[i].par,tree[i].lChild,tree[i].rChild,tree[i].val,tree[i].dep,tree[i].lChild,tree[i].linktop);

        seg.build(tot-1);

        // for(u=1;u<tot;++u)
        //     for(v=1;v<tot;++v) printf("u%d v%d lca%d\n",u,v,getLca(u,v));

        for(i=1;i<=n;++i){
            if(imgcur[i].empty()) continue;
            std::sort(imgcur[i].begin(),imgcur[i].end(),[](int a,int b){return tree[a].id<tree[b].id;});

            cur=imgcur[i];
            imgcur[i].clear();
            for(u=0;u+1<cur.size();++u){
                imgcur[i].push_back(cur[u]);
                imgcur[i].push_back(getLca(cur[u],cur[u+1]));
            }
            imgcur[i].push_back(cur.back());

            std::sort(imgcur[i].begin(),imgcur[i].end(),[](int a,int b){return tree[a].id<tree[b].id;});
            std::unique(imgcur[i].begin(),imgcur[i].end());

            // tree[imgcur[i][0]].imgId=1;
            // imgTree[i][1].kid=imgcur[i][0];

            for(u=0;u<imgcur[i].size();++u){
                tree[imgcur[i][u]].imgId=u+1;
                imgTree[i][u+1].kid=imgcur[i][u];
                // if(u+2>10||u+1<0) return -1;
            }

            for(u=0;u+1<imgcur[i].size();++u){
                imgTree[i][u+2].par=tree[getLca(imgcur[i][u],imgcur[i][u+1])].imgId;
                if(imgTree[i][imgTree[i][u+2].par].lChild) imgTree[i][imgTree[i][u+2].par].rChild=u+2;
                else imgTree[i][imgTree[i][u+2].par].lChild=u+2;
            }

            // for(u=1;u<=imgcur[i].size();++u) printf("id%d kid%d lc%d rc%d par%d\n",u,imgTree[i][u].kid,imgTree[i][u].lChild,imgTree[i][u].rChild,imgTree[i][u].par);

            // putchar('\n');

            dfsImg(i,1);
        }

        // for(i=1;i<=n;++i){
        //     if(imgcur[i].empty()) continue;
        //     dfsImg(i,1);
        // }

        // for(i=1;i<tot;++i) printf("u%d c%d id%d siz%d lit%d ival%d imgpar%d il%d ir%d\n",i,tree[i].color,tree[i].id,tree[i].cnttree,tree[i].lit,tree[i].imgVal,tree[i].imgpar,tree[i].imgLc,tree[i].imgRc);

        // printf("%d",find(1,4));

        for(i=0;i<q;++i){
            op=read();
            u=read();
            if(op==0){
                tree[u].val=tree[u].val+read();
                // if(imgcur[tree[u].color].empty()) return -1;
                dfsImg(tree[u].color,1);//*****这个地方
            }
            else{
                print(query(find(u,read())));putchar('\n');
            }
        }

        cntid=0;

        for(i=1;i<=n;++i) imgcur[i].clear();
        memset(imgTree,0,sizeof(imgTree));
        // memset(imgTree)
    }

	#ifndef ONLINE_JUDGE
	fclose(stdin);
	fclose(stdout);
	#endif
    return 0;
}