【数学 矩阵快速幂】P7108 移花接木|普及+

本文涉及知识点

数学
【矩阵快速幂】封装类及测试用例及样例

移花接木

题目背景

遥远的圣地生长着一棵不为人知的灵树，或有万山之高。

但有一日，藏匿于根系的腐朽力量爆发，灵树已无法支撑往日屹立冲天的高度。

题目描述

灵树最初的形态可以看作一棵高度为 ${10}^{{10}^{{10}^{10}}}$ 的满 $a$ 叉树，高度定义为根结点到叶子结点之间的边数。

受腐朽力量影响，灵树只能维持高度恰好为 $h$ 的满 $b$ 叉树形态。为了转换至该形态，灵树有两种魔法：

• 移花：选择一条边 $u\to v$（$u$ 是 $v$ 的父结点），移除这条边以及以 $v$ 为根的整棵子树。
• 接木：选择一条边 $u\to v$（$u$ 是 $v$ 的父结点）和一个结点 $w$（$w$ 不能是 $v$ 子树中或已移除的结点），将这条边原先 $u$ 一端改接到 $w$。该魔法只能在根结点到 $\mathbf{u}$ 之间的边数 $\le 10^{10^{10}}$ 时使用。

灵树累积的魔法力量有限，它不得不用最少次数的魔法完成转换。这是个漫长的过程，即使次数最少也会显得异常大，你只需要求出最少次数对 $10^9+7$ 取模的结果。

输入格式

输入首行给定数据组数 $T$。

接下来 $T$ 行，每行包含三个整数 $a,b,h$，表示一组数据。

输出格式

对于每组数据输出一行一个整数，表示该数据的答案对 $10^9+7$ 取模的结果。

样例 #1

样例输入 #1

2
1 2 1
3 2 1

样例输出 #1

2
7

提示

【样例解释 #1】

下为 $a=1$，$b=2$，$h=1$ 时的两步转换过程，图中高度极大的冗余子树已用省略号代替。

可以证明，该数据的答案不可能低于 $2$。

---

【数据规模与约定】

本题采用捆绑测试。你必须通过 Subtask 中所有的测试点才能获得该 Subtask 的分数。

• Subtask #1 (3 points)：$h=0$。
• Subtask #2 (4 points)：$a=b$。
• Subtask #3 (8 points)：$a=1$。
• Subtask #4 (8 points)：$b=1$。
• Subtask #5 (17 points)：$h\le 10$。
• Subtask #6 (15 points)：$h\le 10^6$，各测试点存在 $\overline{a},\overline{b}$，其数据满足 $a=\overline{a}$，$b=\overline{b}$。
• Subtask #7 (15 points)：$h\le 10^6$。
• Subtask #8 (30 points)：无特殊限制。

所有测试点（样例除外）均含有 $10^6$ 组数据，即 $T=10^6$。请务必采用较快的 IO（输入/输出）方式。

对于所有的数据，保证 $1\le a,b\le 10^9$，$0\le h\le 10^9$。

分类讨论

原始树和目标树都是满叉。原始树层次无限，目标树层次h。原始树除叶子节点，其它都a个子节点；目标树除叶子节点，都有b个子节点。
层次从0开始，根节点是第0层。

a >= b

情况一：a=b，断开所有k+1层节点和其父节点的联系。
情况二：a>b。
操作一同情况一的操作。
操作二：每个0到k-1层节点都删除a-b个子节点。
下面详细讨论：
c叉树，第0层1个节点，第1层c个节点，第2层cc个节点，即第i层节点数为：cⁱ
0到i层的节点为：f(c,i) = ${\sum }_{j:0}^i{c}^j$
则
三种情况的操作一统一为： a* b^h 可以用快速乘法幂
操作二统一为：s = abs(a-b) * f(b,h-1)，根据等比求和公式：
如果b不为1：abs(a-b) * (1-b^h)/(1-b)
如果b为1：abs(a-b)*h

a < b

方法一：
先进行接木：
第0层的每个节点，接b-a个 h层的子树。
第1层的每个节点，接b-a个 h-1层的子树。
$⋮$
第h-1层的每个节点，接b-a个1层的子树。
原始树0到h-1层的节点，都接b-a个节点。与情况一、情况二的操作操作二相同。
原始树h+1层都需要删除：即a^h+1
方法二：
解木需要删除k+1层子树。
s +(b^h*a-s)=b^h * a ,即情况一的操作一。
方法一减去方法二：abs(a-b) * f(b,h-1)+a^h+1-ba^h
= (b-a)f(b,h-1)+(a-b)a^h = (b-a)(1+b+…+b^h-1-a^h)
如果不知道等比数量求和公式，可以用快速矩阵幂。

代码

如果不优化输入输出，将会超时。
如果只优化输出，不优化输入。用几个用例1到1.2s。优化后，全部低于0.3s。

#include <iostream>
#include <sstream>
#include <vector>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<string>
#include<algorithm>
#include<functional>
#include<queue>
#include <stack>
#include<iomanip>
#include<numeric>
#include <math.h>
#include <climits>
#include<assert.h>
#include<cstring>
#include<list>

#include <bitset>
using namespace std;

template<class T1, class T2>
std::istream& operator >> (std::istream& in, pair<T1, T2>& pr) {
	in >> pr.first >> pr.second;
	return in;
}

template<class T1, class T2, class T3 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) ;
	return in;
}

template<class T1, class T2, class T3, class T4 >
std::istream& operator >> (std::istream& in, tuple<T1, T2, T3, T4>& t) {
	in >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
	return in;
}

template<class T = int>
vector<T> Read() {
	int n;
	scanf("%d", &n);
	vector<T> ret(n);
	for(int i=0;i < n ;i++) {
		cin >> ret[i];
	}
	return ret;
}

template<class T = int>
vector<T> Read(int n) {
	vector<T> ret(n);
	for (int i = 0; i < n; i++) {
		cin >> ret[i];
	}
	return ret;
}

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(int llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int((m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = (m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData  - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator/(const C1097Int& o)const
	{
		return *this * o.PowNegative1();
	}
	C1097Int& operator/=(const C1097Int& o)
	{
		*this /= o.PowNegative1();
		return *this;
	}
	bool operator==(const C1097Int& o)const
	{
		return m_iData == o.m_iData;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return (m_iData + MOD) % MOD;
	}
private:
	int m_iData = 0;;
};
class Solution {
public:
	int Ans(int a, int b, int h) {
		C1097Int<> bh = C1097Int<>(b).pow(h);
		static C1097Int<> i1(1);
		C1097Int<> ans = bh * C1097Int<>(a);
		if (a >= b)
		{
			C1097Int<> ab(a - b);
			if (1 == b) {
				ans += ab * C1097Int<>(h);
			}
			else {
				ans += ab * (i1 - bh) / (i1 - b);
			}
		}
		return ans.ToInt();
	}
};
template<int N = 12*1'000'000>
class COutBuff
{
public:
	COutBuff() {
		m_p = puffer;
	}
	inline void write(int x) {
		int num[12], sp = 0;
		if (x < 0)
			*m_p++ = '-', x = -x;

		if (!x)
			*m_p++ = 48;

		while (x)
			num[++sp] = x % 10, x /= 10;

		while (sp)
			*m_p++ = num[sp--] + 48;
	}
	inline void write(char ch)
	{
		*m_p++ = ch;
	}
	inline void ToFile() {
		fwrite(puffer, 1, m_p - puffer, stdout);
	}	
private:
	char  puffer[N], * m_p ;
};

template<int N = 12 * 1'000'000>
class CInBuff
{
public:
	inline CInBuff() {
		fread(buffer, 1, N, stdin);
	}		
	inline int Read() {
		int x(0), f(0);
		while (!isdigit(*S))
			f |= (*S++ == '-');
		while (isdigit(*S))
			x = (x << 1) + (x << 3) + (*S++ ^ 48);
		return f ? -x : x;
	}
private:
	char buffer[N], * S = buffer;
};

int main() {
#ifdef _DEBUG
	freopen("a.in", "r", stdin);
#endif // DEBUG	
	CInBuff<12 * 3 * 1'000'000 + 100> ib;
	int T;
	T = ib.Read();
	COutBuff<> ob;
	for (int i = 0; i < T; i++) {
		int a=ib.Read(), b=ib.Read(), h=ib.Read();
		auto res = Solution().Ans(a, b, h);
		ob.write(res);
		ob.write('\n');
	}
	ob.ToFile();
#ifdef _DEBUG		
	/*printf("a0=%d", a0);*/
	//Out(h, "h=");
#endif // DEBUG		
	return 0;
}

单元测试

	int a, b, h;
		TEST_METHOD(TestMethod1)
		{
			auto res = Solution().Ans(1,2,1);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod2)
		{
			auto res = Solution().Ans(3, 2, 1);
			AssertEx(7, res);
		}

扩展阅读

我想对大家说的话
工作中遇到的问题，可以按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
学习算法：按章节学习《喜缺全书算法册》，大量的题目和测试用例，打包下载。重视操作
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛
失败+反思=成功 成功+反思=成功

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771
如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。