Problem B

Complete Tree Labeling!

Input: standard input

Output: standard output

Time Limit: 45 seconds

Memory Limit: 32 MB

A complete k-ary tree is a k-ary tree in which all leaves have same depth and all internal nodes have degree k. This k is also known as the branching factor of a tree. It is very easy to determine the number of nodes of such a tree. Given the depth and branching factor of such a tree, you will have to determine in how many different ways you can number the nodes of the tree so that the label of each node is less that that of its descendants. You should assume that for numbering a tree with N nodes you have the (1, 2, 3, N-1, N) labels available.

Input

The input file will contain several lines of input. Each line will contain two integers k and d. Here k is the branching factor of the complete k-arytree and d is the depth of the complete k-ary tree (k>0, d>0, k*d<=21).

Output

For each line of input, produce one line of output containing a round number, which is the number of ways the k-ary tree can be labeled, maintaining the constraints described above.

Sample Input:

2 2

10 1

Sample Output:

```#include <stdio.h>
#include <string.h>
#include <math.h>

#define max(a,b) (a)>(b)?(a):(b)
#define min(a,b) (a)<(b)?(a):(b)

const int MAXSIZE = 10000;

struct bign {
int s[MAXSIZE];
bign ()	{memset(s, 0, sizeof(s));}
bign (int number) {*this = number;}
bign (const char* number) {*this = number;}

void put();
bign mul(int d);
void del();
void init() { memset(s, 0, sizeof(s)); }

bign operator =  (char *num);
bign operator =  (int num);

bool operator <  (const bign& b) const;
bool operator >  (const bign& b) const { return b < *this; }
bool operator <= (const bign& b) const { return !(b < *this); }
bool operator >= (const bign& b) const { return !(*this < b); }
bool operator != (const bign& b) const { return b < *this || *this < b;}
bool operator == (const bign& b) const { return !(b != *this); }

bign operator + (const bign& c);
bign operator * (const bign& c);
bign operator - (const bign& c);
int  operator / (const bign& c);
bign operator / (int k);
bign operator % (const bign &c);
int  operator % (int k);
void operator ++ ();
bool operator -- ();
};

bign f[25][25];
int node[25][25];
int n, m;

bign c(int n, int m) {
bign ans = 1;
m = min(m, n - m);
for (int i = 0; i < m; i ++) {
bign save = (n - i);
ans = ans * save / (i + 1);
}
return ans;
}

void init() {
int i, j, k;
for (i = 1; i <= 21; i ++) {
f[i][0] = 1; node[i][0] = 1;
for (j = 1; j <= 21 / i; j ++) {
f[i][j] = 1;
for (k = 0; k < i; k ++) {
node[i][j] = node[i][j - 1] * i + 1;
f[i][j] = f[i][j] * c(node[i][j] - 1 - k * node[i][j - 1], node[i][j - 1]) * f[i][j - 1];
}
}
}
}

int main() {
init();
while (~scanf("%d%d", &n, &m)) {
f[n][m].put();
printf("\n");
}
return 0;
}

bign bign::operator = (char *num) {
init();
s[0] = strlen(num);
for (int i = 1; i <= s[0]; i++)
s[i] = num[s[0] - i] - '0';
return *this;
}

bign bign::operator = (int num) {
char str[MAXSIZE];
sprintf(str, "%d", num);
return *this = str;
}

bool bign::operator < (const bign& b) const {
if (s[0] != b.s[0])
return s[0] < b.s[0];
for (int i = s[0]; i; i--)
if (s[i] != b.s[i])
return s[i] < b.s[i];
return false;
}

bign bign::operator + (const bign& c) {
int sum = 0;
bign ans;
ans.s[0] = max(s[0], c.s[0]);

for (int i = 1; i <= ans.s[0]; i++) {
if (i <= s[0]) sum += s[i];
if (i <= c.s[0]) sum += c.s[i];
ans.s[i] = sum % 10;
sum /= 10;
}
return ans;
}

bign bign::operator * (const bign& c) {
bign ans;
ans.s[0] = 0;

for (int i = 1; i <= c.s[0]; i++){
int g = 0;

for (int j = 1; j <= s[0]; j++){
int x = s[j] * c.s[i] + g + ans.s[i + j - 1];
ans.s[i + j - 1] = x % 10;
g = x / 10;
}
int t = i + s[0] - 1;

while (g){
++t;
g += ans.s[t];
ans.s[t] = g % 10;
g = g / 10;
}

ans.s[0] = max(ans.s[0], t);
}
ans.del();
return ans;
}

bign bign::operator - (const bign& c) {
bign ans = *this;
int i;
for (i = 1; i <= c.s[0]; i++) {
if (ans.s[i] < c.s[i]) {
ans.s[i] += 10;
ans.s[i + 1]--;;
}
ans.s[i] -= c.s[i];
}

for (i = 1; i <= ans.s[0]; i++) {
if (ans.s[i] < 0) {
ans.s[i] += 10;
ans.s[i + 1]--;
}
}

ans.del();
return ans;
}

int bign::operator / (const bign& c) {
int ans = 0;
bign d = *this;
while (d >= c) {
d = d - c;
ans++;
}
return ans;
}

bign bign::operator / (int k) {
bign ans;
ans.s[0] = s[0];
int num = 0;
for (int i = s[0]; i; i--) {
num = num * 10 + s[i];
ans.s[i] = num / k;
num = num % k;
}
ans.del();
return ans;
}

int bign:: operator % (int k){
int sum = 0;
for (int i = s[0]; i; i--){
sum = sum * 10 + s[i];
sum = sum % k;
}
return sum;
}

bign bign::operator % (const bign &c) {
bign now = *this;
while (now >= c) {
now = now - c;
now.del();
}
return now;
}

void bign::operator ++ () {
s[1]++;
for (int i = 1; s[i] == 10; i++) {
s[i] = 0;
s[i + 1]++;
s[0] = max(s[0], i + 1);
}
}

bool bign::operator -- () {
del();
if (s[0] == 1 && s[1] == 0) return false;

int i;
for (i = 1; s[i] == 0; i++)
s[i] = 9;
s[i]--;
del();
return true;
}

void bign::put() {
if (s[0] == 0)
printf("0");
else
for (int i = s[0]; i; i--)
printf("%d", s[i]);
}

bign bign::mul(int d) {
s[0] += d;
int i;
for (i = s[0]; i > d; i--)
s[i] = s[i - d];
for (i = d; i; i--)
s[i] = 0;
return *this;
}

void bign::del() {
while (s[s[0]] == 0) {
s[0]--;
if (s[0] == 0) break;
}
}
```

## 10247 - Complete Tree Labeling(递推高精度）的更多相关文章

1. PKU 2506 Tiling(递推+高精度||string应用)

题目大意:原题链接有2×1和2×2两种规格的地板,现要拼2×n的形状,共有多少种情况,首先要做这道题目要先对递推有一定的了解.解题思路:1.假设我们已经铺好了2×(n-1)的情形,则要铺到2×n则只能 ...

2. 递推+高精度+找规律 UVA 10254 The Priest Mathematician

题目传送门 /* 题意:汉诺塔问题变形,多了第四个盘子可以放前k个塔,然后n-k个是经典的汉诺塔问题,问最少操作次数 递推+高精度+找规律:f[k]表示前k放在第四个盘子,g[n-k]表示经典三个盘子 ...

3. [BZOJ1089][SCOI2003]严格n元树(递推+高精度)

题目:http://www.lydsy.com:808/JudgeOnline/problem.php?id=1089 分析: 第一感觉可以用一个通式求出来,但是考虑一下很麻烦,不好搞的.很容易发现最 ...

4. 【BZOJ】1002: [FJOI2007]轮状病毒 递推+高精度

1002: [FJOI2007]轮状病毒 Description 给定n(N<=100),编程计算有多少个不同的n轮状病毒. Input 第一行有1个正整数n. Output 将编程计算出的不同 ...

5. BZOJ 1002 FJOI2007 轮状病毒 递推+高精度

题目大意:轮状病毒基定义如图.求有多少n轮状病毒 这个递推实在是不会--所以我选择了打表找规律 首先执行下面程序 #include<cstdio> #include<cstring& ...

6. 【BZOJ】1089: [SCOI2003]严格n元树（递推+高精度/fft）

http://www.lydsy.com/JudgeOnline/problem.php?id=1089 题意:求深度为d的n元树数目.(0<n<=32, 0<=d<=16) ...

7. 递推+高精度 UVA 10497 Sweet Child Makes Trouble（可爱的孩子惹麻烦）

题目链接 题意: n个物品全部乱序排列(都不在原来的位置)的方案数. 思路: dp[i]表示i个物品都乱序排序的方案数,所以状态转移方程.考虑i-1个物品乱序,放入第i个物品一定要和i-1个的其中一个 ...

8. Uva10328 dp(递推+高精度)

题目链接:http://vjudge.net/contest/136499#problem/F 题意:给你一个硬币,抛掷n次,问出现连续至少k个正面向上的情况有多少种. 一个比较好理解的题解:原题中问 ...

9. HUD 5086 Revenge of Segment Tree（递推）

http://acm.hdu.edu.cn/showproblem.php?pid=5086 题目大意: 给定一个序列,求这个序列的子序列的和,再求所有子序列总和,这些子序列是连续的.去题目给的第二组 ...

## 随机推荐

1. Fiddler内置命令

我猜你肯定忽略了下边这个小黑框: 虽然它不是很显眼,但用好它,会让你的工作效率提高 N 倍! 这跟喜欢 Linux 的朋友一样,肯定更倾向于用一两个命令代替鼠标不断的点点点操作. Fiddler 将每 ...

2. heap和stack有什么区别

1.heap是堆,stack是栈. 2.stack的空间由操作系统自动分配和释放,heap的空间是手动申请和释放的,heap常用new关键字来分配. 3.stack空间有限,heap的空间是很大的自由 ...

3. bigData Ecosystem Unscramble

主题>>: cloudEra hadoop Ecosystem sim Unscramble; ruiy哥个人理解总结,其实我无非也还是站在那"砖家/叫兽"的肩上瞎扯扯 ...

4. unity3d Hair real time rendering 真实头发实时渲染

先放上效果 惊现塞拉酱 算法是Weta Digital根据siggraph2003的论文加以改进,改进之前使用的是Kajiya and Kay’s 模型,它能量不守恒,也就是说不是基于物理的,不准确 ...

5. 使用CXF+spring创建一个web的接口项目

一.web project整合spring 1.1.打开Myeclipse,建立web project(eclipse为dynamic web project),使用J2EE5.0. 1.2.加入Sr ...

google的guava库是个很不错的工具库,这次来学习其spliiter的用法,它是一个专门用来 分隔字符串的工具类,其中有四种用法,分别来小结 1 基本用法: String str = " ...

7. IDAPython: importing “site” failed

问题:IDA启动时,弹出IDAPython: importing “site” failed对话框. 解决办法:环境变量添加PYTHONHOME,值为python安装路径,比如:C:\Python27

8. MyBatis 的小细节问题

mybatis Result Maps collection already contains value 这是个小功能,我当时没有怎么在意,后来发到了测试环境的时候测试提出了bug,我才慌忙查看原因 ...

9. 使用 zabbix 自动发现监控 MySQL

介绍 使用 zabbix 的 low-level 自动发现功能完成单主机多端口的监控, 详见low_level_discovery, 整体上监控类似 percona 的 zabbix 监控插件, 不过 ...

10. CAS工程用redis集群存储票据ticket Spring整合

maven jar包版本: <dependency> <groupId>redis.clients</groupId> <artifactId>jedi ...