Newcoder 144 F.Squirtle（树形DP+高精度）

Description

定义$16$个映射fi:{0,1}2→0,1f_i:\{0,1\}^2\rightarrow {0,1}fi​:{0,1}2→0,1，假设$i$的二进制表示为$i_3{i}_2{i}_1{i}_0$，那么有
$$f_i(0,0)=i_0,f_i(0,1)=i_1,f_i(1,0)=i_2,f_i(1,1)=i_3$$
给出一棵有$n$个叶子节点的正则二叉树，每个叶子节点的点权等概率选取$0,1$，每个非叶子节点可以选取一个该节点可以使用的若干映射$f_i$，而一个非叶子节点的点权为该节点选取的映射作用在其两个儿子上的函数值，问如何安排每个节点上的映射使得在叶子节点取遍所有权值情况时根节点权值为$1$的次数最多

Input

第一行一整数$T$表示用例组数，每组用例首先输入一整数$n$表示叶子节点数，之后$n-1$行每行输入一个长度为$16$的$01$串表示每个非叶子节点可以使用的函数，最后$2n-2$行输入$2,...,2n-2$节点的父亲节点，保证所给树是正则二叉树

$(1\le T\le 20,2\le n\le 2000)$

Output

输出根节点权值为$1$的最大次数

Sample Input

2
2
0000000010000010
1
1
3
0000000010000010
0000000010000011
1
1
2
2

Sample Output

Case #1: 3
Case #2: 8

Solution

以$dp[u][0/1]$表示以$u$为根的子树在叶子节点取遍所有情况下运算到$u$节点值为$0/1$的最多次数，下面证明$dp[u][0/1]$必然由$dp[ls(u)][0/1]$和$dp[rs(u)][0/1]$转移过来，以$u$点取异或运算为例，其余运算类似

不妨固定左子树$0,1$个数，考虑求$dp[u][1]$

$1.$左子树$0$比$1$多，显然右子树$1$数量最大时$dp[u][1]$最大

$2.$左子树$1$比$0$多，显然右子树$0$数量最大时$dp[u][1]$最大

$3.$左子树$0,1$数量相同，那么无论右子树怎么取$dp[u][1]$值不变

故$dp[u][0/1]$必然可以由$dp[ls(u)][0/1]$和$dp[rs(u)][0/1]$转移得到，每次枚举左右子树分别$0,1$最多的四种情况以及$u$节点可进行的操作来维护$dp[u][0/1]$最优值即可，由于结果很大要用高精度

Code

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 4005
struct BigInt
{
	const static int mod=10000;
	const static int LEN=4;
	int a[200],len;
	BigInt() 
	{
		memset(a,0,sizeof(a));
		len=1;
	}
	void init(int x)
	{
		memset(a,0,sizeof(a));
		len=0;
		do
		{
			a[len++]=x%mod;
			x/=mod;
		}while(x);
	}
	void Init(const char s[])
	{
		memset(a,0,sizeof(a));
		int l=strlen(s),res=0;
		len=l/LEN;
		if(l%LEN)len++;
		for(int i=l-1;i>=0;i-=LEN)
		{
			int t=0,k=max(i-LEN+1,0);
			for(int j=k;j<=i;j++)t=t*10+s[j]-'0';
			a[res++]=t;
		}
	}
	int Compare(const BigInt &b)
	{
		if(len<b.len)return -1;
		if(len>b.len)return 1;
		for(int i=len-1;i>=0;i--)
			if(a[i]<b.a[i])return -1;
			else if(a[i]>b.a[i])return 1;
		return 0;
	}
	BigInt operator +(const BigInt &b)const
	{
		BigInt ans;
		ans.len=max(len,b.len);
		for(int i=0;i<=ans.len;i++)ans.a[i]=0;
		for(int i=0;i<ans.len;i++)
		{
			ans.a[i]+=((i<len)?a[i]:0)+((i<b.len)?b.a[i]:0);
			ans.a[i+1]+=ans.a[i]/mod;
			ans.a[i]%=mod;
		}
		if(ans.a[ans.len]>0)ans.len++;
		return ans;
	}
	BigInt operator -(const BigInt &b)const
	{
		BigInt ans;
		ans.len=len;
		int k=0;
		for(int i=0;i<ans.len;i++)
		{
			ans.a[i]=a[i]+k-b.a[i];
			if(ans.a[i]<0)ans.a[i]+=mod,k=-1;
			else k=0;			
		}
		while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
		return ans;
	}
	BigInt operator *(const BigInt &b)const
	{
		BigInt ans;
		for(int i=0;i<len;i++)
		{
			int k=0;
			for(int j=0;j<b.len;j++)
			{
				int temp=a[i]*b.a[j]+ans.a[i+j]+k;
				ans.a[i+j]=temp%mod;
				k=temp/mod;
			}
			if(k!=0)ans.a[i+b.len]=k;
		}
		ans.len=len+b.len;
		while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
		return ans;
	}
	BigInt operator /(const int &n)const
	{
		BigInt ans;
		ans.len=len;
		int k=0;
		for(int i=ans.len-1;i>=0;i--)
		{
			k=k*mod+a[i];
			ans.a[i]=k/n;
			k=k%n;
		}
		while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
		return ans;
	}
	void output()
	{
		printf("%d",a[len-1]);
		for(int i=len-2;i>=0;i--)
			printf("%04d",a[i]);
		printf("\n");
	}
}dp[maxn][2],b[maxn],L[2],R[2],temp[2];
vector<int>g[maxn];
int T,Case=1,n,S[maxn][16],Size[maxn];
char s[16];
void Solve(int u,int ls,int rs,int type)
{
	int f[2][2];
	f[0][0]=type&1;
	f[0][1]=(type&2)>>1;
	f[1][0]=(type&4)>>2;
	f[1][1]=(type&8)>>3;
	for(int i=0;i<2;i++)
		for(int j=0;j<2;j++)
		{
			if(i==0)L[0]=dp[ls][0],L[1]=b[Size[ls]]-L[0];
			else L[1]=dp[ls][1],L[0]=b[Size[ls]]-L[1];
			if(j==0)R[0]=dp[rs][0],R[1]=b[Size[rs]]-R[0];
			else R[1]=dp[rs][1],R[0]=b[Size[rs]]-R[1];
			for(int k=0;k<2;k++)temp[k].init(0);
			for(int k=0;k<2;k++)
				for(int l=0;l<2;l++)
					temp[f[k][l]]=temp[f[k][l]]+L[k]*R[l];
			for(int k=0;k<2;k++)
				if(dp[u][k].Compare(temp[k])<0)
					dp[u][k]=temp[k];
		}
}
void dfs(int u)
{
	Size[u]=0;
	if(g[u].size()==0)
	{
		Size[u]=1;
		dp[u][0].init(1),dp[u][1].init(1);
		return ;
	}
	int ls=g[u][0],rs=g[u][1];
	dfs(ls),dfs(rs);
	Size[u]+=Size[ls],Size[u]+=Size[rs];
	for(int i=0;i<16;i++)
		if(S[u][i])
			Solve(u,ls,rs,i);
}
int main()
{
	b[1].init(2);
	for(int i=2;i<=2000;i++)b[i]=b[i-1]*b[1];
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<n;i++)
		{
			scanf("%s",s);
			for(int j=0;j<16;j++)S[i][j]=s[j]-'0';
		}
		for(int i=1;i<=2*n-1;i++)
		{
			g[i].clear();
			dp[i][0].init(0),dp[i][1].init(0);
		}
		for(int i=2;i<=2*n-1;i++)
		{
			int fa;
			scanf("%d",&fa);
			g[fa].push_back(i);
		}
		dfs(1);
		printf("Case #%d: ",Case++);
		dp[1][1].output();
	}
	return 0;
}