Algorithm Review 9 数学相关

概率与期望

• 结论1 设 $x$ 为离散随机变量，且 $x\in \mathbb{N}$，则$E(x)=\sum _{i=1}^{\infty }i\cdot P(x=i)=\sum _{i=1}^{\infty }P(x\ge i)$。

树上随机游走

• 给定一棵树，从树中的某点 $x$ 出发，设其子树大小为 ${\text{size}}_x$，结点的度数为 ${\text{deg}}_x$，每次等概率地选择一条相邻的边游走，$\text{w}(u,v)$ 表示 $u$ 到 $v$ 的边权（距离），${\text{son}}_x$ 表示其子结点集合，${\text{sibling}}_x$ 表示其兄弟结点集合。
• 设其第一次游走到其父结点 ${\text{fa}}_x$ 的期望距离为 $f_x$，不难得到：
  $$f_x=\frac{\text{w}(x,{\text{fa}}_x)+\sum _{y\in {\text{son}}_x}(\text{w}(x,y)+f_y+f_x)}{{\text{deg}}_x}$$
• 移项得：
  $$f_x=\text{w}(x,{\text{fa}}_x)+\sum _{y\in {\text{son}}_x}\text{w}(x,y)+\sum _{y\in {\text{son}}_x}{f}_y$$
• 特别地，若 $\text{w}$ 恒为 1，$f_x=2{\text{size}}_x-1$。
• 类似地，设 $g_x$ 表示从 ${\text{fa}}_x$ 走到 $x$ 的期望距离，不难得到：
  $$g_x=\frac{\text{w}(x,{\text{fa}}_x)+(\text{w}({\text{fa}}_x,{\text{fa}}_{{\text{fa}}_x})+g_{{\text{fa}}_x}+g_x)+\sum _{y\in {\text{sibling}}_x}(\text{w}({\text{fa}}_x,y)+f_y+g_x)}{{\text{deg}}_{{\text{fa}}_x}}$$
• 化简得 $g_x=g_{{\text{fa}}_x}+f_{{\text{fa}}_x}-f_x$。

min-max容斥

• 常见结论如下：

$$\begin{gathered} \underset{i\in S}{\max }{x}_i=\sum _{T\subseteq S}(-1{)}^{|T|-1}\underset{i\in T}{\min }{x}_i \\ \underset{i\in S}{\min }{x}_i=\sum _{T\subseteq S}(-1{)}^{|T|-1}\underset{i\in T}{\max }{x}_i \\ E(\underset{i\in S}{\max }{x}_i)=\sum _{T\subseteq S}(-1{)}^{|T|-1}E(\underset{i\in T}{\min }{x}_i) \\ E(\underset{i\in S}{\min }{x}_i)=\sum _{T\subseteq S}(-1{)}^{|T|-1}E(\underset{i\in T}{\max }{x}_i) \\ \text{kth}\underset{i\in S}{\max }{x}_i=\sum _{T\subseteq S}(-1{)}^{|T|-k}(\genfrac{}{}{0ex}{}{|T|-1}{k-1})\underset{i\in T}{\min }{x}_i \\ \text{kth}\underset{i\in S}{\min }{x}_i=\sum _{T\subseteq S}(-1{)}^{|T|-k}\left(\genfrac{}{}{0ex}{}{|T|-1}{k-1}\right)\underset{i\in T}{\max }{x}_i \\ E(\text{kth}\underset{i\in S}{\max }{x}_i)=\sum _{T\subseteq S}(-1{)}^{|T|-k}(\genfrac{}{}{0ex}{}{|T|-1}{k-1})E(\underset{i\in T}{\min }{x}_i) \\ E(\text{kth}\underset{i\in S}{\min }{x}_i)=\sum _{T\subseteq S}(-1{)}^{|T|-k}\left(\genfrac{}{}{0ex}{}{|T|-1}{k-1}\right)E(\underset{i\in T}{\max }{x}_i) \\ \underset{i\in S}{\mathrm{lcm}}{x}_i=\prod _{T\subseteq S}{\left(\underset{i\in T}{\gcd }{x}_i\right)}^{(-1{)}^{|T|-1}} \end{gathered}$$

• 证明待补充。

博弈论

• 待补充。

Nim Game

• 给定 $n$ 堆石子，第 $i$ 堆石子有 $a_i$ 个，两名玩家轮流行动，每次可以任选一堆，取走任意多个石子，但不能不取，取走最后一个石子者获胜。
• 结论1 两人均采用最优策略，若 $\underset{i=1}{\overset{n}{⨁}}{a}_i=0$ 则先手必败，否则先手必胜。

证明 显然末态（全 0 局面）满足先手必败条件，我们只需证明对于任意 $\underset{i=1}{\overset{n}{⨁}}{a}_i\ne 0$ 的局面，一定存在一种操作使其能转变为 $\underset{i=1}{\overset{n}{⨁}}{a}_i=0$ 的局面。

设此时 $\underset{i=1}{\overset{n}{⨁}}{a}_i=k\ne 0$，$k$ 在二进制下最高位的 1 在第 $x$ 位，则一定有奇数个 $a_i$ 在二进制下第 $x$ 位为 1。找到其中一个 $a_i$，则 $a_i\oplus k<a_i$， 取 $a_i-(a_i\oplus k)$ 个石子，则局面转变为 $\underset{i=1}{\overset{n}{⨁}}{a}_i=0$。

• 结论2 先手必败的玩家总能使接下来的操作每次只取一个石子。

证明 先手必败的玩家在 $\text{lowbit}(a_i)$ 最小的石子堆中取走恰好一个，则先手必胜的玩家也必须在另一堆 $\text{lowbit}(a_i)$ 最小的石子堆中取走恰好一个。

Bash Game

• 给定一堆石子，石子总个数为 $n$，两名玩家轮流行动，每次至少取 1 个，至多取 $m$ 个，取走最后一个石子者获胜。
• 结论 两人均采用最优策略，若 $(m+1)|n$ 则先手必败，否则先手必胜。

证明 显然末态（0）满足先手必败条件，对于任意 $(m+1)\nmid n$ 的局面，先手取 $n$ 模 $m+1$ 的余数个石子，一定能使其转变为 $(m+1)|n$ 的局面。

Wythoff Game

• 给定两堆石子，石子数分别为 $a,b(a<b)$，两名玩家轮流行动，每次可以在一堆中取石子，或从两堆中取走相同个数的石子，数量不限，取走最后一个石子者获胜。
• 结论 两人均采用最优策略，若满足 $a=\lfloor \frac{\sqrt{5}+1}{2}k\rfloor ,b=a+k,k\in \mathbb{N}$ 则先手必败，否则先手必胜。

证明 待补充。

Fibonacci Game

• 给定一堆石子，石子总个数为 $n$，两名玩家轮流行动：

  • 先手不能一次取完所有石子，至少取 1 个。
  • 之后每次取的石子数至少为 1，至多为对手取的石子数的 2 倍。

• 取走最后一个石子者获胜。

• 结论 两人均采用最优策略，若 $n$ 为 $\text{Fibonacci}$ 数则先手必败，否则先手必胜。

证明 待补充。

SG 函数

• 在有向图游戏中，规定对于所有出度为 0 的点 $x$，$SG(x)=0$。
• 对于其余的点 $x$，设其后继结点分别为 $y_1,y_2,\dots ,y_k$，则 $SG(x)=\text{mex}\{SG(y_i)\},1\le i\le k$。
• $SG(x)=0$ 为必败态， $SG(x)\ne 0$ 为必胜态。
• 定义相互独立的有向图游戏 $G_1,G_2,\dots ,G_m$ 的和 $G$：
  • 在游戏进行的过程中，游戏者可以任意挑选其中的一个游戏进行决策，最终无法决策者判负。
  • $SG(G)=\underset{i=1}{\overset{m}{⨁}}SG(G_i)$，证明类似 Nim Game。
• 许多博弈题目的 $SG(x)$ 有特殊规律，可以打表得出。

二分图博弈

• 给定一个二分图和起始点，两名玩家轮流行动，每次选择移动到一个与当前点相邻且未经过的点，不能选择点的玩家算输。
• 结论 两人均采用最优策略，若最大匹配一定包含起始点，则先手必胜，否则先手必败。

证明 若最大匹配一定包含起始点，则先手始终可以沿着匹配边移动，后手不可能选到非匹配点。若后手选到一个非匹配点 $P_n$，设路径为 $P_1\to P_2\to \cdots \to P_n(n为奇数)$，则现有匹配为 $\{P_1-P_2,\dots ,P_{n-2}-P_{n-1}\}$，则可得到另一个最大匹配 $\{P_2-P_3,\dots ,P_{n-1}-P_n\}$，与最大匹配一定包含起始点矛盾。

若最大匹配不一定包含起始点，取其中一个不包含起始点的最大匹配 $M$，先手每次移动一定会移动到某个匹配点上，否则图中存在增广路，与最大匹配矛盾，后手只需沿匹配边移动即可。

删边博弈

• 以下内容摘自《组合游戏略述——浅谈SG游戏的若干拓展及变形》
  
  
  
  

线性代数

高斯消元

解实数方程组

• 模拟手动消元过程即可。

inline bool Gauss()
{ 
    for (int i = 1; i <= n; ++i)
    {
        int l = i;
        for (int j = i + 1; j <= n; ++j) 
			if (fabs(f[l][i]) < fabs(f[j][i])) 
				l = j;
        if (l != i)
       		for (int j = 1; j <= n + 1; ++j) 
				std::swap(f[l][j], f[i][j]);
        if (fabs(f[i][i]) <= eps) 
			return false;
		ld tmp = f[i][i];
		for (int j = 1; j <= n + 1; ++j)
			f[i][j] /= tmp;
        for (int j = 1; j <= n; ++j)
			if (j != i)
			{
				ld tmp = f[j][i];
			   	for (int k = i; k <= n + 1; ++k)
					f[j][k] -= f[i][k] * tmp;
            }
    }
    return true;
}

解异或方程组

• 大致流程类似，可用 bitset 优化。
• 因为系数只有 0/1，题目常常要求计算自由元个数，进而能求出解的组数，注意实现的细节。

bitset<N> f[N];

inline int Guass() //返回自由元个数
{
    // n 为未知量个数，m 为方程数
    int ans = 0;
    for (int i = 1; i <= n; ++i)
    {
        int pos = 0;
        for (int j = 1; j <= m; ++j)
            if (!vis[j] && f[j][i])
            {
                pos = j;
                break;
            }
        if (pos)
        {
            if (pos != i)
                swap(f[pos], f[i]);
            vis[i] = true;
            for (int j = 1; j <= m; ++j)
                if (!vis[j] && f[j][i]) f[j] ^= f[i];
        }
        else 
            ++ans; //统计自由元个数
    }
	
	for (int i = 1; i <= m; ++i) 
	{
		bool flag = false;
		for (int j = 1; j <= n; ++j)
			if (f[i][j])
			{
				flag = true;
				break;
			}
		if (!flag && f[i][n + 1]) //无解情况
			return -1;
	}
    return ans;
}

求行列式

• 消成上三角矩阵直接计算即可。
• 若模数为质数，可以直接求逆元，否则消元的过程可通过辗转相除法实现。
• $f_{i,i}>0$ 时每次迭代至少减少一半，实际的时间复杂度为 $\mathcal{O}(n^2\log w+n^3)$，同样的原理也可以用于分析区间 $\text{gcd}$，实际上合并线段树上 $\mathcal{O}(\log n)$ 个区间的答案总迭代次数也是 $\mathcal{O}(\log w)$。

inline int Det()
{
	int res = 1, opt = 0;
	for (int i = 1; i <= n; ++i)
	{
		for (int j = i + 1; j <= n; ++j)
		{
			while (f[i][i])
			{
				int tmp = f[j][i] / f[i][i];
				for (int k = i; k <= n; ++k)
					dec(f[j][k], 1ll * tmp * f[i][k] % mod);
				std::swap(f[i], f[j]); 
				opt ^= 1;
			}
			std::swap(f[i], f[j]);
			opt ^= 1;
		}
		res = 1ll * res * f[i][i] % mod;
		if (!res)
			return 0;
	}
	return opt ? mod - res : res;
}

线性基

• 线性基是一种特殊的基，它具有如下性质：
  • 原集合任意非空子集得到的异或和都能由线性基内某个唯一的非空子集异或得到。
  • 线性基是满足上述性质最小的集合，且没有异或和为 0 的子集。
  • 线性基中每个元素的二进制最高位互不相同。
• 由性质 1 和性质 2，设线性基内元素个数为 $cnt$，则该线性基子集的异或和种数为 $2^{cnt}$，若插入线性基的元素个数为 $n$，（可为空）子集异或和为 0 的方案数为 $2^{n-cnt}$，非空子集异或和为 0 的方案数为 $2^{n-cnt}-1$。
• 由性质 2，若需要判断原集合能否找出一个非空子集异或和为 0，构造其线性基时需要特殊记录（代码中的 flag）。

基础操作

• 只作简要叙述，具体实现见代码。

压位

• 若线性基表示的数字较大，可通过重载 bitset 进行压位优化。

struct bigint
{
	bitset<N> x;
	
	inline void Clear() {x.reset();}
	
	inline void scan(char *s, int n)
	{
		x.reset();
		std::reverse(s, s + n);
		for (int i = 0; i < n; ++i)
			if (s[i] == '1')
				x[N - 1 - i] = 1;
	}
	
	inline bool operator < (const bigint &a) const
	{
		int p = (x ^ a.x)._Find_first();
		if (p == N)
			return false;
		return !x[p];
	}
	
	inline bool operator <= (const bigint &a) const 
	{
		int p = (x ^ a.x)._Find_first();
		return p == N || !x[p];
	}
}

异或上指定数后的最值

• 从高位到低位贪心即可。

子集异或和第 k 小数

• 我们先对构建出的线性基做一次 reBuild 操作，具体来说，从低位到高位，尽量用低位的元素消去高位元素上的 1，只保留线性基中非 0 的元素。
• 这样显然不会破坏线性基的性质，同时我们能保证对于线性基内任意一个子集的异或和以及任意一个不在该子集内的元素，异或上该元素都能使该子集的异或和增大。
• 之后从高位到低位贪心即可。

求有多少个子集异或和小于等于 r

• 同样先做一次 reBuild 操作，只保留线性基中非 0 的元素。
• 初始答案为 1（ $r\ge 0$，而空集一定能够取到 0），从高位到低位贪心，若异或上当前元素仍小于等于 $r$，则异或上当前元素，将答案加上 $2^{线性基中比该数小的非0元素个数}$。
• 设线性基内元素个数为 $cnt$，原集合的元素个数为 $n$，若要求有多少个原集合的子集异或和小于等于 $r$，将上述询问的答案乘上 $2^{n-cnt}$ 即可。

两个线性基的并

• 暴力将其中一个线性基的每个元素插入另一个线性基即可。

两个线性基的交

• 给定两个线性基 $a,b$，求出一个线性基 $c$，使得其任意子集的异或和在 $a,b$ 中均能由子集异或和表示。
• 记线性基 $a,b$ 中元素分别为 $a_0,a_1,\dots ,a_L$ 和 $b_0,b_1,\dots ,b_L$，对于 $c$ 中某一子集的异或和
  $$x=\underset{i=1}{\overset{n}{⨁}}{a}_{p_i}=\underset{i=1}{\overset{m}{⨁}}{b}_{q_i}$$
• 其中 $0\le p_1<p_2<\cdots <p_n\le L,0\le q_1<q_2<\cdots <q_m\le L$。
• 考虑枚举从高位到低位枚举 $b_{q_1}$，用 $res$ 维护 $a$ 和 $b_{q_1+1},b_{q_1+2},\dots ,b_L$ 组成的线性基的并，同时维护 $res$ 中每个元素包含了 $a$ 中的哪些元素。
• 当插入 $b_{q_1}$ 时，若 $b_{q_1}$ 能由 $res$ 的某个子集异或和表示，则我们通过维护的信息可唯一确定 $x$，将其插入 $c$ 即可。

const int L = 60; 
ll cur[L + 1];
int cm;
 
struct lib
{
	ll g[L + 1];
	bool flag0;
	
	inline void Clear()
	{
		flag0 = false;
		for (int i = 0; i <= L; ++i)
			g[i] = 0;	
	}
	
	inline bool Insert(ll v)
	{
		for (int i = L; i >= 0; --i)
			if (v >> i & 1)
			{
				if (g[i])
					v ^= g[i];
				else
				{
					g[i] = v;
					return true;
				}		
			} 
		flag0 = true;
		return false;
	}
	
    inline int queryCnt()
    {
    	int cnt = 0;
        for (int i = 0; i <= L; ++i)
            cnt += g[i] > 0;
       	return cnt;
	}
    
	inline ll queryMax(ll res = 0)
	{
		for (int i = L; i >= 0; --i)
			if ((res ^ g[i]) > res)
				res ^= g[i];
		return res;
	}
	
	inline ll queryMin(ll res = -1)
	{ // res = -1 时表示询问线性基内子集异或和的最小值
		if (res == -1)
		{
			if (flag0)
				return 0;
			for (int i = 0; i <= L; ++i)
				if (g[i])
					return g[i];
		}
		else
		{
			for (int i = L; i >= 0; --i)
				if (res >> i & 1)
					res ^= g[i];
			return res;
		}
	}
	
	inline void reBuild()
	{ // 使用 queryKth() 之前记得调用
		cm = 0;
		for (int i = 0; i <= L; ++i)
			if (g[i])
			{
				for (int j = 0; j < i; ++j)
					if (g[i] >> j & 1)
						g[i] ^= g[j];
				cur[cm++] = g[i];
			}
	}
	
	inline ll queryKth(ll k)
	{
		if (flag0)
			--k;
		if (!k)
			return 0;
		if (k >= (1ll << cm))
			return -1;
		ll res = 0;
		for (int i = 0; i < cm; ++i)
			if (k >> i & 1)
				res ^= cur[i];
		return res;
	}

	inline ll queryRank(ll r)
	{
    	ll res = 0, cnt = 1;
    	for (int i = cm - 1; i >= 0; --i)
    	{
			ll temp = res ^ cur[i];
        	if (temp <= r)
        	{
            	res = temp;
                cnt += 1ll << i;
            }
    	}	
    	return cnt;
	}

	friend inline lib operator | (const lib &a, const lib &b)
	{
		lib c = a;
		for (int i = L; i >= 0; --i)
			if (b.g[i])
				c.Insert(b.g[i]);
		c.flag0 |= b.flag0;
		return c;
	}
	
	friend inline lib operator & (const lib &a, const lib &b)
	{
		lib c, d, res;
		c.flag0 = a.flag0 && b.flag0;
		for (int i = L; i >= 0; --i)
		{
			res.g[i] = a.g[i];
			d.g[i] = 1ll << i;
		}
		for (int i = L; i >= 0; --i)
			if (b.g[i])
			{
				ll v = b.g[i], k = 0;
				bool flag = true;
				for (int j = L; j >= 0; --j)
					if (v >> j & 1)
					{
						if (res.g[j])
						{
							v ^= res.g[j];
							k ^= d.g[j];
						}
						else
						{
							flag = false;
							res.g[j] = v;
							d.g[j] = k;
							break ;
						}
					}
				if (flag)
				{
					v = 0;
					for (int j = L; j >= 0; --j)
						if (k >> j & 1)
							v ^= a.g[j];
					c.Insert(v);
				}
			}
		return c;
	}
};

常见应用

可删除的线性基

• 强行实现可删除的线性基需要记录原集合的信息，较为麻烦且复杂度不科学，这里略去。
• 线性基的撤回操作实现较为容易，与线段树分治结合即可实现离线的可删除。

区间线性基

• 给定序列 $a$，多次询问 $[l,r]$ 的元素构成的线性基。
  • 显然可以得到线段树或 ST 表的做法。
  • 实际上还有更简便的做法，设 $s_i$ 表示 $[1,i]$ 的元素构成的线性基，同时记录 $p_{i,j}$ 表示 $s_i$ 中第 $j$ 位的元素由 $a$ 中哪个元素构成。构建 $s_i$ 时先令 $s_i=s_{i-1},p_{i,j}=p_{i-1,j}$，若 $a_i$ 能由 $s_i$ 中的元素表示，则删除表示 $a_i$ 的元素中 $p_{i,j}$ 最小的，并由 $a_i$ 顶替。
  • 询问时只需取出 $s_i$ 中 $p_{i,j}\ge l$ 的元素构建线性基即可。

inline bool Insert(int t, ll v)
{
	s[t] = s[t - 1];
	p[t] = p[t - 1];
	ll tmp = t;
	for (int i = L; i >= 0; --i)
		if (v >> i & 1)
		{
			if (p[t].g[i] < tmp)
			{
				std::swap(s[t].g[i], v);
				std::swap(p[t].g[i], tmp);
			}
			v ^= s[t].g[i];			
		}
		else
		{
			s[t].g[i] = v;
			p[t].g[i] = tmp;
			return true;
		}
	s[t].flag0 = true;
	return false;
}

• 给定序列 $a$，多次操作，询问 $[l,r]$ 的元素构成的线性基或区间将 $[l,r]$ 异或上一个数。
  • 设 $b_i=a_i\oplus a_{i-1}$，用线段树维护序列 $b$ 的区间线性基，则区间操作可转化为单点修改，同时还需一棵线段树维护序列 $a$，支持单点查询。
• 给定一棵带点权的树，多次询问两点 $(x,y)$ 路径上点权构成的线性基。
  • 倍增求出 $x,y$ 的 $\text{LCA}$，设为 $z$，设 $an{c}_{x,i}$ 表示 $x$ 往上跳 $2^i$ 步得到的结点，预处理 $f_{x,i}$ 表示 $an{c}_{x,i}\to x$ 这条路径上（不包括 $an{c}_{x,i}$）的点权构成的线性基。
  • 运用 ST 表 的思想，将 $z\to x$ 和 $z\to y$ 两条路径分别处理，将每条路径的线性基拆成两个可重叠且长度为 2 的整数次幂的路径的线性基的并。
  • 设点数为 $n$，询问数为 $q$，可做到时间复杂度 $\mathcal{O}(n\log n{\log }^{2}w+q{\log }^{2}w+q\log n)$。

连通块内任意两点的异或最短路

• 任取连通块中的一棵生成树，对于任意一条非树边，取其与树边构成的环的异或和，则任意两点的异或最短路为它们在生成树上路径的异或和与若干个环的异或和异或的最小值，用线性基维护所有环的异或和即可。
• 若要动态加边和删边可与线段树分治、并查集结合，在任意两点间连边可根据异或的性质转换成在它们并查集祖先间连边。

二阶常系数线性齐次递推式的通项

• 给出递推式 $f_n=a{f}_{n-1}+b{f}_{n-2}$，已知 $f_0,f_1$，求 $f_n$ 的通项公式。

• 结论 设 $x_1,x_2$ 为方程 $x^2-ax-b=0$ 的两根（可以为复数）。

  • 若 $x_1\ne x_2$，$f_n=A{x}_1^n+B{x}_2^n$。
  • 若 $x_1=x_2$，$f_n=(A+Bn)x_1^n$。
  • 其中 $A,B$ 可以根据 $f_0,f_1$ 列方程组解出。

证明（实际可用基础的生成函数证明，以下是另一种证明方式）
尝试把递推式表示成等比数列的形式：
$$\begin{array}{rl}{f}_n-x_1{f}_{n-1}& =x_2(f_{n-1}-x_1{f}_{n-2})\\ f_n& =(x_1+x_2)f_{n-1}-x_1{x}_2{f}_{n-2}\end{array}$$
可以列出一个方程组：
$$\{\begin{array}{l}{x}_1+x_2=a\\ x_1{x}_2=-b\end{array}$$
由韦达定理得，$x_1,x_2$ 是方程 $x^2-ax-b=0$ 的两根。

设 $c=f_1-x_1{f}_0$，可列出 $n$ 个方程：
$$\{\begin{array}{ll}{f}_1-x_1{f}_0& =c\\ f_2-x_1{f}_1& =c{x}_2\\ f_3-x_1{f}_2& =c{x}_2^2\\ & \dots \\ f_n-x_1{f}_{n-1}& =c{x}_2^{n-1}\end{array}$$
将第 $i$ 个方程乘上 $x_1^{n-i}$，然后将所有方程相加，得到：
$$\begin{array}{r}{f}_n-x_1^n{f}_0=c{x}_1^{n-1}\sum _{i=0}^{n-1}{\left(\frac{x_2}{x_1}\right)}^i\end{array}$$
若 $x_1=x_2$，此时 $A=f_0,B=\frac{c}{x_1}$：
$$\begin{array}{rl}{f}_n-x_1^n{f}_0& =cn{x}_1^{n-1}\\ f_n& =cn{x}_1^{n-1}+x_1^n{f}_0\\ f_n& =\left(f_0+\frac{c}{x_1}n\right)x_1^n\end{array}$$
若 $x_1\ne x_2$，由等比数列求和，$A=f_0-\frac{c}{x_2-x_1},B=\frac{c}{x_2-x_1}$：
$$\begin{array}{rl}{f}_n-x_1^n{f}_0& =c{x}_1^{n-1}\frac{{\left(\frac{x_2}{x_1}\right)}^n-1}{\frac{x_2}{x_1}-1}\\ f_n& =c\frac{x_2^n-x_1^n}{x_2-x_1}+x_1^n{f}_0\\ f_n& =\left(f_0-\frac{c}{x_2-x_1}\right)x_1^n+\frac{c}{x_2-x_1}{x}_2^n\end{array}$$

矩阵的 LU 分解

• 定义 对于 $n$ 阶矩阵 $A$，若存在一个下三角矩阵 $L$ 和一个上三角矩阵 $U$，使得 $A=LU$，则称 $A=LU$ 为 $A$ 的 $LU$ 分解。
• 定理 若 $n$ 阶矩阵 $A$ 的前 $n-1$ 个顺序主子式 $D_k\ne 0(1\le k\le n-1)$，则 $A$ 可以唯一地分解成一个单位下三角矩阵 $L$ 和一个上三角矩阵 $U$。

证明 先证明此时一定存在 $A$ 的分解方案。

• 记 $A_k$ 表示 $A$ 前 $k$ 行 $k$ 列构成的子矩阵，则 $D_k=\text{det}(A_k)$。

• 由行列式的定义可知，若我们每次通过第三种初等行变换将 $A_k(1\le k\le n-1)$ 化为上三角矩阵，则 $A_k$ 对角线上的元素一定不为 0。

• 因此，通过第三种初等行变换我们一定能将 $A$ 化为上三角矩阵 $U$，则有：$$P_l{P}_{l-1}\dots P_{1}A=U\iff A=(P_l{P}_{l-1}\dots P_1{)}^{-1}U$$

• 取 $L=(P_l{P}_{l-1}\dots P_1{)}^{-1}=P_1^{-1}\dots P_{l-1}^{-1}{P}_l^{-1}$，由于第三种初等行变换对应的初等矩阵及其逆均为单位下三角矩阵，故 $L$ 也一定也为单位下三角矩阵，则我们构造出了一组 $A$ 的分解方案。

再证明分解方案的唯一性，分以下两种情况讨论：

• 若 $A$ 可逆，

  • 假设分解不唯一，即 $A=L_1{U}_1=L_2{U}_2$，则 $L_1,U_1,L_2,U_2$ 均可逆，则有 $U_1{U}_2^{-1}=L_1^{-1}{L}_2$，由于 $U_1{U}_2^{-1}$ 是上三角矩阵，$L_1^{-1}{L}_2$ 是单位下三角矩阵，有 $U_1{U}_2^{-1}=L_1^{-1}{L}_2=E$，所以 $L_1=L_2,U_1=U_2$，与假设矛盾。

• 若 $A$ 不可逆，

  • 由分块矩阵相关理论，可知：$$A=\left(\begin{array}{cc}{A}_{n-1}& \alpha \\ {\beta }^T& a_{n,n}\end{array}\right)=\left(\begin{array}{cc}{L}_{n-1}& 0\\ l^T& 1\end{array}\right)\left(\begin{array}{cc}{U}_{n-1}& u\\ 0^T& 0\end{array}\right)$$

  • 因而可得到以下关系式：$$\begin{array}{rl}{A}_{n-1}& =L_{n-1}{U}_{n-1}\\ \alpha =L_{n-1}u& \iff u=L_{n-1}^{-1}\alpha \\ {\beta }^T=l^T{U}_{n-1}& \iff l^T={\beta }^T{U}_{n-1}^{-1}\end{array}$$

  • 由可逆情况的证明，$L_{n-1},U_{n-1}$ 是唯一的，故 $u,l^T$ 也可唯一确定，该情况得证。

• 下面给出 $L,U$ 的计算方法，显然有 $l_{i,j}=u_{j,i}=0(j>i),l_{i,i}=1$。

  • 当 $i\le j$ 时，由 $a_{i,j}=\sum _{k=1}^i{l}_{i,k}{u}_{k,j}=\sum _{k=1}^{i-1}{l}_{i,k}{u}_{k,j}+u_{i,j}$，得 $u_{i,j}=a_{i,j}-\sum _{k=1}^{i-1}{l}_{i,k}{u}_{k,j}$，特别地，当 $i=1$ 时，有 $u_{i,j}=a_{i,j}$。

  • 当 $i>j$ 时，由 $a_{i,j}=\sum _{k=1}^j{l}_{i,k}{u}_{k,j}=\sum _{k=1}^{j-1}{l}_{i,k}{u}_{k,j}+l_{i,j}{u}_{j,j}$，得 $l_{i,j}=\frac{a_{i,j}-\sum _{k=1}^{j-1}{l}_{i,k}{u}_{k,j}}{u_{j,j}}$，特别地，当 $j=1$ 时，有 $l_{i,j}=\frac{a_{i,j}}{u_{j,j}}$。

• 套用上式递推计算即可，时间复杂度 $\mathcal{O}(n^3)$。

inline void LU_Factorization(double (*a)[N], int n)
{
	double b[N][N]; //由于 L,U 均为三角矩阵，可将两者同时存于一个矩阵中
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			if (i <= j)
			{
				b[i][j] = a[i][j];
				for (int k = 1; k < i; ++k)
					b[i][j] -= b[i][k] * b[k][j];
			}
			else 
			{
				b[i][j] = a[i][j];
				for (int k = 1; k < j; ++k)
					b[i][j] -= b[i][k] * b[k][j];
				if (fabs(b[j][j]) <= eps)
				{
					puts("No Solution");
					return ;
				}
				b[i][j] /= b[j][j];
			}
}