[NOIP模拟测试10]模板

这是道模板题

30分做法：

暴力统计，复杂度$ O(n^2) $，考场上性价比没有70分的高

70分算法：

我们发现有40分算法跟雨天的尾巴很相似，没有时间限制，直接权值线段树动态开点+启发式合并

复杂度$ O(n(log2n)^2) $，考场上我很沙雕地认为它的复杂度是$ O(n^2) $的所以没敢打，以后得多学一学复杂度分析包括内存分析了。

100分算法：

跟树链剖分的思想有些类似，首先dfs扫一边，之后以操作次数为鉴定标准求出重儿子，这个分类标准每个人的代码可能不太一样，拿我的来说这两个时间相差不大(因为我没有像某cow大神mikufun把整个子树全都扫一边)。

这个是以子树大小为标准的。

这个是以操作次数为标准的。（都好慢啊～）

继续继续～

有了重儿子之后事情就简单一些了，我们可以在dfs的时候把轻儿子的信息全部合并到自己身上，之后扫一边重儿子，

把重儿子的信息在扫的过程中塞到线段树里（下标是时间，维护贡献和体积），并且不去删除它，

然后处理当前节点这样就可以保证复杂度了。（很巧妙的运用了树剖的思想）

空间复杂度无法接受每个点都存储信息（最坏大概得三万MB），所以需要及时清空Vector

上面我粘的代码是错误的，因为我这里只是当x不是重儿子时才把重儿子的信息暴力传过去，

但是我没有考虑如果fa的祖先某一个不是重儿子，那么它的父亲就需要它的全部信息来更新线段树，而这些信息却丢失了。

改完之后过了样例开开心心地交了上去却MLE了，改成删一个添一个却又TLE！很是尴尬，

最后我想出 颓NC哥颓出 了一个巧妙的办法：

用一个数组记录某个节点的vector是谁，这样就可以避免低效地传递信息了。

再优化一下：直接把轻儿子的信息传给重儿子（当然，是在处理完重儿子答案之后）

最后我们考虑如何来跟新答案：线段树二分

二分搞满k容量的时间，之后在线段树上区间查询即可。

记得考虑k是零的情况，所以要把二分边界设为L=0，R=m，否则。。。

出题人挺良心的，只有5分是有k==0的节点。

就这样，一道模板题就被我们切啦！

复杂度$ O(n(log2n)^2) $

 

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<string>
#include<cstring>
#include<map>
#define m(a) memset(a,0,sizeof(a))
#define AA cout<<"Alita"<<endl
using namespace std;
const int N=1e5+10;
int Q,tot,cnt,n,m,k[N],head[N],to[N*2],ne[N*2],pre[N],size[N],son[N],ans[N],id[N];
vector<int>v[N],g[N];
map<int,int>ma;
struct tree{int l,r,w,s;}a[N*4];
void add(int x,int y)
{
        to[++tot]=y;
        ne[tot]=head[x];
        head[x]=tot;
}
void dfs(int x,int fa)
{
        size[x]=1+v[x].size();
        for(int i=head[x];i;i=ne[i])
        {
                int y=to[i];
                if(y==fa) continue;
                dfs(y,x);
                size[x]+=size[y];
                if(size[y]>size[son[x]]) son[x]=y;
        }
}
void build(int k,int l,int r)
{
        a[k].l=l;
        a[k].r=r;
        if(l==r) return;
        int mid=(l+r)>>1;
        if(l<=mid) build(k<<1,l,mid);
        if(r>mid) build(k<<1|1,mid+1,r);
}
int query_size(int k,int l,int r)
{
        if(a[k].l>=l&&a[k].r<=r) return a[k].s;
        int mid=(a[k].l+a[k].r)>>1,sum=0;
        if(l<=mid) sum+=query_size(k<<1,l,r);
        if(r>mid) sum+=query_size(k<<1|1,l,r);
        return sum;
}
int query_w(int k,int l,int r)
{
        if(a[k].l>=l&&a[k].r<=r) return a[k].w;
        int mid=(a[k].l+a[k].r)>>1,sum=0;
        if(l<=mid) sum+=query_w(k<<1,l,r);
        if(r>mid) sum+=query_w(k<<1|1,l,r);
        return sum;
}
void Plus(int k,int val,int time,int f)
{
        if(a[k].l==a[k].r)
        {
                a[k].w=val;
                a[k].s+=f;
                return;
        }
        int mid=(a[k].l+a[k].r)>>1;
        if(time<=mid) Plus(k<<1,val,time,f);
        else Plus(k<<1|1,val,time,f);
        a[k].w=a[k<<1].w+a[k<<1|1].w;
        a[k].s=a[k<<1].s+a[k<<1|1].s;
}
int get(int x)
{
        int L=0,R=m;
        while(L<R)
        {
                int mid=(L+R+1)>>1;
                if(query_size(1,1,mid)<=k[x]) L=mid;
                else R=mid-1;
        }
        return query_w(1,1,L);
}
void work(int x,int fa)
{
        for(int i=head[x];i;i=ne[i])
        {
                int y=to[i];
                if(y==fa||y==son[x]) continue;
                work(y,x);
        }
        int pos=0;
        if(son[x]) 
        {
                work(son[x],x);
                pos=v[id[son[x]]].size();
                for(int i=0;i<v[id[x]].size();i++)
                {
                        v[id[son[x]]].push_back(v[id[x]][i]);
                        g[id[son[x]]].push_back(g[id[x]][i]);
                }
                id[x]=id[son[x]];
        }
        for(int i=head[x];i;i=ne[i])
        {
                int y=to[i];
                if(y==fa||y==son[x]) continue;
                for(int i=0;i<v[id[y]].size();i++)
                {
                        v[id[x]].push_back(v[id[y]][i]);
                        g[id[x]].push_back(g[id[y]][i]);
                }
                v[id[y]].clear();
                g[id[y]].clear();
        }
        for(int i=pos;i<v[id[x]].size();i++)
        {
                if(pre[v[id[x]][i]])
                {
                        if(pre[v[id[x]][i]]<g[id[x]][i]) Plus(1,0,g[id[x]][i],1);
                        else 
                        {
                                Plus(1,1,g[id[x]][i],1);
                                Plus(1,0,pre[v[id[x]][i]],0);
                                pre[v[id[x]][i]]=g[id[x]][i];
                        }
                }
                else 
                {
                        Plus(1,1,g[id[x]][i],1);
                        pre[v[id[x]][i]]=g[id[x]][i];
                }
        }
        ans[x]=get(x);
        if(son[fa]!=x)
        {
                for(int i=0;i<v[id[x]].size();i++)
                {
                        pre[v[id[x]][i]]=0;
                        Plus(1,0,g[id[x]][i],-1);
                }
        }
}
int main()
{
        //freopen("1.in","r",stdin);
        //freopen("1.out","w",stdout);
        scanf("%d",&n);
        for(int i=1,x,y;i<n;i++)
        {
                scanf("%d%d",&x,&y);
                add(x,y); add(y,x);
        }
        for(int i=1;i<=n;i++) 
        {
                id[i]=i;
                scanf("%d",&k[i]);
        }
        scanf("%d",&m);
        build(1,1,m);
        for(int i=1,x,y;i<=m;i++)
        {
                scanf("%d%d",&x,&y);
                if(!ma[y]) ma[y]=++cnt;
                v[id[x]].push_back(ma[y]);
                g[id[x]].push_back(i);
        }
        dfs(1,0);
        work(1,0);
        scanf("%d",&Q);
        for(int i=1,x;i<=Q;i++)
        {
                scanf("%d",&x);
                printf("%d\n",ans[x]);
        }
        return 0;
}