就是容易想到维护每个节点的优先队列啦,优先队列的长度为K,每个节点的优先队列为子节点优先队列的合并,一共有n个节点,每个节点合并所需时间为O(nlogn),所以总的时间复杂度为O(n^2logn)不能接受。我们都知道优先队列是用普通的二叉堆实现的,普通的二叉堆又是由普通的二叉树实现的,堆的合并需要nlogn,虽然可以合并,但这是十分慢的。所以我们需要用到另一种可合并堆——左式堆(又叫左偏堆),它是用左式树(又叫左偏树)实现的。这种堆的合并只需要O(logn),因此总的时间复杂度为O(nlogn)可以接受。然后就是一边dfs一边维护左偏树,顺带计算出每个节点的值,加起来就是答案啦。然而,dfs不行,会RE,我还是第一次遇到树的dfs会爆栈的,所以就要从叶子节点往上bfs,这样就可以啦。
关于左偏树,可合并堆的介绍以及模板:
http://blog.csdn.net/theprinceofelf/article/details/7247454
代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int mod = 1000000007;
struct Node
{
int v[maxn];
int l[maxn],r[maxn];
int c[maxn];
void init()
{
memset(v,0,sizeof(v));
memset(l,0,sizeof(l));
memset(r,0,sizeof(r));
memset(c,0,sizeof(c));
}
int merge(int x,int y)
{
if(x==0||y==0) return x|y;
if(v[x]>v[y]) swap(x,y);
r[x]=merge(r[x],y);
swap(l[x],r[x]);
c[x]=c[l[x]]+c[r[x]]+1;
return x;
}
void pop(int &x)
{
x=merge(l[x],r[x]);
c[x]=c[l[x]]+c[r[x]]+1;
}
int top(int x)
{
return v[x];
}
}Heap;
int N,K;
int f[maxn],d[maxn];
int m[maxn],id[maxn];
void dfs(int u,int& x)
{
if(!u) return;
x=1ll*x*Heap.v[u]%mod;
dfs(Heap.l[u],x);
dfs(Heap.r[u],x);
}
void work()
{
Heap.init();
memset(d,0,sizeof(d));
scanf("%d %d",&N,&K);
for(int i=2;i<=N;i++)
{
scanf("%d",&f[i]);
d[f[i]]++;
}
for(int i=1;i<=N;i++)
{
scanf("%d",&Heap.v[i]);
m[id[i]=i]=Heap.c[i]=1;
}
queue<int>Q;
for(int i=1;i<=N;i++) if(!d[i])
Q.push(i);
while(!Q.empty())
{
int now=Q.front();Q.pop();
while(Heap.c[id[now]]>K) Heap.pop(id[now]);
dfs(id[now],m[now]);
id[f[now]]=Heap.merge(id[now],id[f[now]]);
if(!--d[f[now]]) Q.push(f[now]);
}
int ans=0;
for(int i=1;i<=N;i++)
ans=(0ll+ans+m[i])%mod;
printf("%d\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
work();
return 0;
}