UVa Problem 10247 Complete Tree Labeling （完全树标号）

// Complete Tree Labeling （完全树标号）
// PC/UVa IDs: 110605/10247, Popularity: C, Success rate: average Level: 2
// Verdict: Accepted
// Submission Date: 2011-06-06
// UVa Run Time: 0.172s
//
// 版权所有（C）2011，邱秋。metaphysis # yeah dot net
//
// 如何得到递推关系？设 T（K，D）表示分支因子为 K，深度为 D 的 K 叉树标号的方案数。又设
// N（K，D）表示分支因子为 K，深度为 D 的完全 K 叉树所包含的节点数。根据完全 K 叉树的定义，
// 深度为 D 的完全 K 叉树包含了 K 个深度为 （D - 1） 的完全 K 叉数，其包含的节点数可以
// 表示为 N（K，D - 1），有 K * N（K，D - 1） + 1 = N（K，D）。每个子树的标号方案数为
// T（K，D - 1），则问题转化为下面的问题：N（K，D） - 1 个节点，编号为 1 - （N（K，D） - 1），
// 划分为 K 个子集，每个子集有 N（K，D - 1）个节点，这种划分方法有多少？因为只要确定了划分
// 方法数，则由于知道了 T（K，D - 1），只要将每种划分方法得到的子集和每棵子树一一对应，每个
// 子集的元素可以与 T（K，D - 1） 中的标号形成一一映射，设总的划分方法数为X，则有以下关系：
//
// T（K，D） = X * (T（K，D - 1) ^ K)	（1）
//
// 而集合的划分种数 X 相当与每次从 N（K，D） - 1 个节点中取 N（K，D - 1）个节点，共取 K 次
// 所能得到的不同取法总数。设 A = （N（K，D） - 1），B = N（K，D - 1），A = K * B，有：
//
// X = C（A，B） * C（A - B，B） * …… * C（A - T * B，B），0 <= T <= K - 1	（2）
//
// 根据组合数的定义可将（2）式化简为：
//
// X = （A！） / （（B！） ^ K ）	（3）
//
// 最终有：
//
// T（K，D） = （（（N（K，D） - 1）！ / （（N（K，D - 1）！） ^ K）） * T（K，D - 1)
// ^ K （4）
//
// 容易知道 T（K，0） = 1，N（K，D） = （K ^ （D + 1） - 1） / （K - 1）。则可进一步化简得
// 到：
//
// T（K，D） = （N（K，D） - 1）！ / N（K，D - 1） ^ K / N（K，D - 2） ^ （K ^ 2) /.../ 
// N（K，1） ^ （K ^ （D - 1）） （5）
//
// 可以看出涉及到大数的乘以及除运算。
	
#include <iostream>
#include <vector>
#include <iomanip>
#include <algorithm>
	
using namespace std;
	
class integer
{
	friend ostream& operator<<(ostream&, const integer&);
	
public:
	integer() { };
	
	// 将无符号整数转换为大整数。
	integer(unsigned int a)
	{
		if (a == 0)
			digits.push_back(0);
		else
		{
			while (a)
			{
				digits.push_back(a % base);
				a /= base;
			}
		}
	};
	
	~integer() { };
	
	integer operator*(const integer&);
	integer& operator*=(unsigned int);
	integer& operator*=(const integer&);
	integer operator/(integer&);
	
	bool is_zero(void)
	{
		return digits.empty();
	};
	
private:
	void zero_justify(void);
	bool less_equal(integer&, unsigned int &, integer&);
	
	vector < unsigned int > digits;		// 数位。
	static unsigned int const base = 10000;	// 基数。
	static unsigned int const width = 4;	// 数位宽度。
};
	
// 重载输出符号 <<。
ostream& operator<<(ostream& os, const integer& number)
{
	os << number.digits[number.digits.size() - 1];
	for (int i = number.digits.size() - 2; i >= 0; i--)
		os << setw(number.width) << setfill('0') << number.digits[i];
	return os;
}
	
// 移除大数运算产生的前导 0。
void integer::zero_justify(void)
{
	for (int i = digits.size() - 1; i >= 1; i--)
	{
		if (digits[i] == 0)
			digits.erase(digits.begin() + i);
		else
			break;
	}
}
	
integer& integer::operator*=(const integer& b)
{
	return *this = *this * b;
}
	
// 大数乘以无符号整数。
integer& integer::operator*=(unsigned int b)
{
	if (b >= base)
	{
		*this *= integer(b);
		return *this;
	}
	
	unsigned int carry = 0;
	for (int i = 0; i < digits.size(); i++)
	{
		digits[i] = digits[i] * b + carry;
		carry = digits[i] / base;
		digits[i] %= base;
	}
	
	if (carry)
		digits.push_back(carry);
	
	return *this;
}
	
// 乘法。
integer integer::operator*(const integer& b)
{
	integer c;
	
	// 预先分配足够空间。
	c.digits.resize(digits.size() + b.digits.size());
	fill(c.digits.begin(), c.digits.end(), 0);
	
	// 一行一行算，逐行相加。
	for (int i = 0; i < b.digits.size(); i++)
		for (int j = 0; j < digits.size(); j++)
		{
			c.digits[i + j] += digits[j] * b.digits[i];
			c.digits[i + j + 1] += c.digits[i + j] / base;
			c.digits[i + j] %= base;
		}
	
	// 去掉前导0。
	c.zero_justify();
	return c;
}
	
// 判断 b * v <= row 是否成立，成立返回 true，否则返回 false。
bool integer::less_equal(integer& b, unsigned int &v, integer& row)
{
	// 由于本题中存在关系 row.digits.size() = b.digits.size() + 1，故可以加以利用。
	// 若 b * v 的最高位大于 row，则可确定，b * v > row。
	int carry = b.digits[b.digits.size() - 1] * v;
	if ((carry / base) > row.digits[row.digits.size() - 1])
		return false;
	
	// 逐位比较，当两个数位不等时，记录比较结果，最后一次的比较结果决定了 b * v 和 row 的大小
	// 关系。
	bool flag = true;
	carry = 0;	
	for (int i = 0; i < b.digits.size(); i++)
	{
		int tmp = b.digits[i] * v + carry;
		carry = tmp / base;
		tmp %= base;
		if (row.digits[i] != tmp)
			flag = tmp < row.digits[i];
	}
	
	// 进位需要与 row 的最高位比较。
	if (carry != row.digits[row.digits.size() - 1])
		flag = carry < row.digits[row.digits.size() - 1];
	
	return flag;
}
	
// 除法，使用二分法来试除得到商。
integer integer::operator/(integer& b)
{
	integer c;
	integer row;
	
	// 要为商 c 和表示被减数的 row 分配存储空间。
	c.digits.resize(digits.size() - b.digits.size() + 1);
	row.digits.resize(b.digits.size() + 1);
	
	// 初始化值。
	fill(c.digits.begin(), c.digits.end(), 0);
	fill(row.digits.begin(), row.digits.end(), 0);
	
	for (int i = digits.size() - 1; i >= 0; i--)
	{
		// 获取被除数。
		for (int j = row.digits.size() - 1; j > 0; j--)
			row.digits[j] = row.digits[j - 1];
		row.digits[0] = digits[i];
	
		// 通过二分试除法得到对应位的商。
		int high = base - 1;
		int low = 0;
		unsigned int v = (high + low + 1) >> 1;
		while (high > low)
		{
			if (less_equal(b, v, row))
				low = v;
			else
				high = v - 1;
	
			v = (high + low + 1) >> 1;
		}
	
		// 从 row 中减去 v 个 b。
		int borrow, start = 0;
		for (; start < b.digits.size(); start++)
		{
			// 决定借位的数量。
			int t = row.digits[start] - v * b.digits[start];
			if (t < 0)
				borrow = (base - 1 - t) / base;
			else
				borrow = 0;
				
			// 高位减去借位数量。
			row.digits[start + 1] -= borrow;
			
			// 低位加上借位。
			t += base * borrow;
			row.digits[start] = t % base;
		}
			
		// 将对应位的商存入结果中。
		for (int j = c.digits.size() - 1; j > 0; j--)
			c.digits[j] = c.digits[j - 1];
		c.digits[0] = v;
	
	}
	
	// 清除前导 0。
	c.zero_justify();
	return c;
}
	
#define TREEDEEPTH 22
	
// 计算分支因子为 k，深度为 d 的标号方案数。
void cal_tree(vector < int > kd)
{
	// 存储分支因子为 k，深度为 d 的 k 叉数的完全数标号方案数。
	integer tree[TREEDEEPTH][TREEDEEPTH];
	// 存储分支因子为 k，深度为 d 的 k 叉数的节点数。
	unsigned int nodes[TREEDEEPTH][TREEDEEPTH];
	
	// 计算满足 k * d <= 21 的树的节点数。并找到最大的节点数。
	unsigned int max = 0;
	for (int i = 0; i < kd.size(); i += 2)
	{
		nodes[kd[i]][0] = 1;
		for (int j = 1; j <= kd[i + 1]; j++)
		{
			nodes[kd[i]][j] = nodes[kd[i]][j - 1] * kd[i] + 1;
			if (nodes[kd[i]][j] > max)
				max = nodes[kd[i]][j];
		}
	}
	
	// 计算 1 到节点数 max - 1 的阶乘。
	vector < integer > fact(max);
	fact[0] = integer(1);
	for (unsigned int i = 1; i < max; i++)
		fact[i] = fact[i - 1] * i;
	
	// 根据化简的公式（5）计算标号方案数。
	for (int i = 0; i < kd.size(); i += 2)
	{	
		if (tree[kd[i]][kd[i + 1]].is_zero())
		{
			// 计算 N（K，M） ^ （K ^ （D - M）），v = K ^ （D - M）。
			unsigned int v = 1;
			integer t(1);
			for (int d = kd[i + 1]; d > 0; d--)
			{
				v *= kd[i];
				for (int k = 1; k <= v; k++)
					t *= nodes[kd[i]][d - 1];
			}
			
			tree[kd[i]][kd[i + 1]] =
				fact[nodes[kd[i]][kd[i + 1]] - 1] / t;
		}
	
		cout << tree[kd[i]][kd[i + 1]] << endl;
	}
}
	
int main(int ac, char *av[])
{
	int k, d;
	vector < int > kd;
	
	while (cin >> k >> d)
	{
		kd.push_back(k);
		kd.push_back(d);
	}
	
	cal_tree(kd);
	
	return 0;
}