简单高精度模板（bzoj 1089: [SCOI2003]严格n元树）

1089: [SCOI2003]严格n元树

Time Limit: 1 Sec   Memory Limit: 162 MB
Submit: 1831   Solved: 913
[ Submit][ Status][ Discuss]

Description

　　如果一棵树的所有非叶节点都恰好有n个儿子，那么我们称它为严格n元树。如果该树中最底层的节点深度为d
（根的深度为0），那么我们称它为一棵深度为d的严格n元树。例如，深度为２的严格２元树有三个，如下图：

　　给出n, d，编程数出深度为d的n元树数目。

Input

　　仅包含两个整数n, d( 0   <   n   <   =   32,   0  < =   d  < = 16)

Output

　　仅包含一个数，即深度为d的n元树的数目。

Sample Input

2 2

2 3

3 5

Sample Output

3

21

58871587162270592645034001

听说，bzoj，简单递推和高精度更配哦

天哪，不知道为什么好推得递归题答案都那么大，不会JAVA，python真的很伤

忍不住写(copy)了个简单的高精度模板，以后就可以偷懒

dp[i]表示深度<=i的严格n元树数目，d层的严格n元树==1个根节点连接着n棵d-1层的严格n元树

∴dp[i] = dp[i-1]^n+1（加上那一个只有根的情况）

最后答案就是dp[d]-dp[d-1]

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
typedef struct Bnum
{
	int l;
	int s[11000];
	Bnum()
    {
        l = 0;
        memset(s, 0, sizeof(s));
    }
}Bnum;
Bnum dp[20];
Bnum operator + (Bnum x, Bnum y)
{
	int i;
	Bnum z;
	z.l = max(x.l, y.l);
	for(i=1;i<=z.l;i++)
	{
		z.s[i] += x.s[i]+y.s[i];
		if(z.s[i]>9)
		{
			z.s[i+1] += 1;
			z.s[i] %= 10;
		}
	}
	while(z.s[z.l+1])
		z.l++;
	return z;
}
Bnum operator - (Bnum x, Bnum y)
{
	int i;
	Bnum z;
	z.l = max(x.l, y.l);
	for(i=1;i<=z.l;i++)
	{
		if(x.s[i]<y.s[i])
		{
			x.s[i] += 10;
			x.s[i+1]--;
		}
		z.s[i] += x.s[i]-y.s[i];
		if(z.s[i]>9)
		{
			z.s[i+1] += z.s[i]/10;
			z.s[i] %= 10;
		}
	}
	while(z.s[z.l]==0)
		z.l--;
	return z;
}
Bnum operator * (Bnum x, Bnum y)
{
	int i, j;
	Bnum z;
	z.l = x.l+y.l-1;
	for(i=1;i<=x.l;i++)
	{
		for(j=1;j<=y.l;j++)
		{
			z.s[i+j-1] += x.s[i]*y.s[j];
			if(z.s[i+j-1]>9)
			{
				z.s[i+j] += z.s[i+j-1]/10;
				z.s[i+j-1] %= 10;
			}
		}
	}
	while(z.s[z.l+1])
		z.l++;
	return z;
}
Bnum operator ^ (Bnum x, int y)
{
	Bnum z, u;
	z.l = z.s[1] = 1, u = x;
	while(y)
	{
		if(y%2==1)
			z = z*u;
		u = u*u;
		y /= 2;
	}
	return z;
}
void Print(Bnum x)
{
	int i;
	for(i=x.l;i>=1;i--)
		printf("%d", x.s[i]);
	printf("\n");
}
int main(void)
{
	int n, i, d;
	Bnum x;
	while(scanf("%d%d", &n, &d)!=EOF)
	{
		dp[0].l = dp[0].s[1] = 1;
		dp[1].l = dp[1].s[1] = 2;
		x.l = x.s[1] = 1;
		for(i=2;i<=d;i++)
			dp[i] = (dp[i-1]^n)+x;
		Print(dp[d]-dp[d-1]);
	}
	return 0;
}