Newcoder 38 F.珂朵莉喊你一声大佬（二分+树形DP+强连通分量+拓扑排序）

Description

有$n$种大佬，第$i$种大佬有$a_i$个

珂朵莉想让最少个数的一种大佬的个数最多

你可以创造$m$个任意种类的大佬，并且可以把一些大佬变成另一些大佬$x\to y$意味着可以把任意个$x$类型的大佬变成$y$类型的大佬

一个大佬可以被转换多次

对于每个$y$，最多有一个$x$使得$x\to y$成立

Input

第一行两个数$n,m$

之后一行，第$i$个数$x_i$表示第$i$种大佬可以被哪种大佬转换得到

如果$x_i$为$-1$表示这种大佬不可以被任何大佬转换得到

之后一行，第$i$个数$a_i$表示第$i$种大佬的个数

$(n\le 10^6,m,a_i\le 10^9)$

Output

输出一行一个数表示答案

答案即

你要求让最少个数的一种大佬的个数最多的方案

输出这个方案下最少个数的一种大佬的个数

Sample Input

5 5
-1 1 1 1 1
4 5 1 3 2

Sample Output

3

Solution

以转化关系建有向图，强连通分量缩点后变成一片森林，二分答案，那么儿子缺少的数量只能父亲和祖先们补，以此树形$DP$即可，若最后求出需要额外数量不超过$m$则二分值合理，否则只能尝试更小的答案，注意到$dfs$整个森林比较慢，求出该森林的拓扑序即可把树上$DP$的过程转化为序列上的$DP$，时间复杂度$O(nlogn)$

Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
#include<stack>
using namespace std;
#define maxn 1000005
typedef long long ll;
struct node
{
	int to,next;
}edge[maxn];
int tot,head[maxn];
stack<int>st;  
int n,m,fa[maxn],a[maxn],scc,Index;  
int low[maxn],dfn[maxn],belong[maxn];  
bool instack[maxn];
void init()//初始化 
{  
    scc=Index=0;
	tot=0;
	memset(head,-1,sizeof(head));  
    while(!st.empty())st.pop();  
    memset(dfn,0,sizeof(dfn));  
	memset(instack,0,sizeof(instack));  
    memset(low,0,sizeof(low));
}  
void add(int u,int v)//建u到v的单向边
{
	edge[tot].to=v;edge[tot].next=head[u];head[u]=tot++;
} 
void tarjan(int u)//求强联通分量  
{  
    dfn[u]=low[u]=++Index;  
    instack[u]=1;  
    st.push(u);  
    int v;  
    for(int i=head[u];i!=-1;i=edge[i].next)  
    {  
        v=edge[i].to;  
        if(!dfn[v])  
        {  
            tarjan(v);  
            low[u]=min(low[u],low[v]);  
        }  
        else if(instack[v]) 
            low[u]=min(low[u],dfn[v]);  
    }  
    if(dfn[u]==low[u])  
    {  
        scc++;  
        do  
        {  
            v=st.top();  
            st.pop();  
            belong[v]=scc;  
            instack[v]=0;  
        }while(v!=u);  
    }  
}  
void solve()
{
	for(int i=1;i<=n;i++)
		if(!dfn[i])tarjan(i); 		
} 
ll val[maxn],need[maxn];
int Size[maxn],pre[maxn];
void Top_Sort()
{
	for(int i=1;i<=n;i++)pre[i]=-1;
	for(int i=1;i<=n;i++)
		if(fa[i]!=-1&&belong[i]!=belong[fa[i]])
			pre[belong[i]]=belong[fa[i]];
	n=scc;
	queue<int>que;
	memset(fa,0,sizeof(fa));
	for(int i=1;i<=n;i++)
		if(pre[i]!=-1)fa[pre[i]]++;
	for(int i=1;i<=n;i++)
		if(!fa[i])que.push(i);
	int res=1;
	while(!que.empty())
	{
		int u=que.front();
		que.pop();
		a[res++]=u;
		if(pre[u]!=-1)
		{
			fa[pre[u]]--;
			if(!fa[pre[u]])que.push(pre[u]);
		}
	}
}
bool check(ll mid)
{
	ll last=m;
	for(int i=1;i<=n;i++)
	{
		int u=a[i];
		ll cost=max(0ll,need[u]+(ll)Size[u]*mid-val[u]);
		if(pre[u]==-1)last-=cost;
		else need[pre[u]]+=cost;
		need[u]=0;
	}
	if(last<0)return 0;
	return 1;
}
int main()
{
	scanf("%d%d",&n,&m);
	init();
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&fa[i]);
		if(fa[i]!=-1)add(fa[i],i);
	}
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);
	solve();
	for(int i=1;i<=n;i++)
		Size[belong[i]]++,val[belong[i]]+=a[i];
	Top_Sort();
	ll l=0,r=1e10,mid,ans=0;
	while(l<=r)
	{
		mid=(l+r)/2;
		if(check(mid))ans=mid,l=mid+1;
		else r=mid-1;
	}
	printf("%lld\n",ans);
	return 0;
}