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

本文涉及知识点

数学

移花接木

题目背景

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

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

题目描述

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

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

移花：选择一条边 $\to v$ （ $u$ 是 $v$ 的父结点），移除这条边以及以 $v$ 为根的整棵子树。
接木：选择一条边 $\to v$ （ $u$ 是 $v$ 的父结点）和一个结点 $w$ （ $w$ 不能是 $v$ 子树中或已移除的结点），将这条边原先 $u$ 一端改接到 $w$ 。该魔法只能在根结点到 $\boldsymbol{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)： $\le 10$ 。
Subtask #6 (15 points)： $\le 10^6$ ，各测试点存在 $\overline{a},\overline{b}$ ，其数据满足 $a=\overline{a}$ ， $b=\overline{b}$ 。
Subtask #7 (15 points)： $\le 10^6$ 。
Subtask #8 (30 points)：无特殊限制。

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

对于所有的数据，保证 $\le a,b \le 10^9$ ， $\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层的子树。
$\vdots$
第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 _DEBUGfreopen("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);}

扩展阅读

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