算法设计与分析——平摊分析

基本思想（聚集方法需要精细分析，会计方法需要一步一步猜，势能方法需要构思势能函数）

聚集方法：分析整体的时间复杂度，每一步都假设代价相同，然后除以n
一般需要精细分析，并不是看一眼就行了的那种

会计方法：为不同的操作赋予不同的代价，然后按每一步的操作分析代价
设$c_i$和${\alpha }_i$是操作$i$的实际代价和平摊代价${\sum }_{1\le i\le n}{\alpha }_i-{\sum }_{1\le i\le n}{c}_i\ge 0$必须对于任意$n$个操作序列都成立

势能方法：为不同的操作赋予不同的代价，然后对整个问题分析代价
考虑在初始数据结构$D_0$上执行$n$个操作，对于操作$i$，操作$i$的实际代价为$c_i$，操作$i$将数据结构$D_{i-1}$变为$D_i$，数据结构$D_i$的势能是一个实数$\varphi (Di)$，$\varphi$是一个正函数，操作$i$的平摊代价：${\alpha }_i＝c_i+\varphi (D_i)-\varphi (D_{i-1})$，$n$个操作的总平摊代价（必须是实际代价的上界）${\sum }_{i=1}^n{\alpha }_i＝{\sum }_{i=1}^n(c_i+\varphi (D_i)-\varphi (D_{i-1}))={\sum }_{i=1}^n{c}_i+\varphi (D_n)-\varphi (D_0)$

基本例题

1.栈的操作

操作$Multipop(S,k)$: 去掉$S$的$k$个顶对象, 当$|S|<k$时弹出整个栈
$$\begin{gathered} Multipop(S,k) \\ (1)WhilenotSTACK-EMPTY(S)andk\ne 0Do \\ (2)Pop(S); \\ (3)k\leftarrow k-1. \end{gathered}$$
假设$Pop$的代价是1，那么$Multipop(S,k)$的代价就是min{∣S∣,k}min\{|S|,k\}min{∣S∣,k}

初始栈为空的$n$个栈操作序列的分析$n$个栈操作序列由$Push$、$Pop$和$Multipop$组成

聚集方法：
（1）粗略分析：最坏情况下，每个操作都是$Multipop$，每个$Multipop$的代价最坏是$O(n)$，操作系列的最坏代价为$T(n)＝O(n^2)$，平摊代价为$T(n)/n＝O(n)$
（2）精细分析：一个对象在每次被压入栈后至多被弹出一次，在非空栈上调用$Pop$的次数(包括在$Multipop$内的调用)至多为$Push$执行的次数, 即至多为$n$，最坏情况下操作序列的代价为$T(n)\le 2n＝O(n)$，平摊代价$=T(n)/n=O(1)$

会计方法：
$Cost(PUSH)=2$一个1用来支付$PUSH$的开销，另一个1存储在压入栈的元素上，预支$POP$的开销，$Cost(POP)=0$，$Cost(MULTIPOP)=0$这样${\sum }_{1\le i\le n}{\alpha }_i-{\sum }_{1\le i\le n}{c}_i\ge 0$就成立了

势能方法：
$\varphi (D_m)$定义为栈$D_m$中对象的个数，$\varphi (D_0)＝0$，$D_0$是空栈 $\varphi (D_i)\ge 0=\varphi (D_0)$, 因为栈中对象个数不会小于0。栈操作的平摊代价（设栈$D_{i-1}$中具有$s$个对象）$PUSH$: ${\alpha }_i=c_i+\varphi (D_i)-\varphi (D_{i-1})=1+(s+1)-s=2$；$POP:{\alpha }_i=c_i+\varphi (D_i)-\varphi (D_{i-1})=1+(s-1)-s=0$；$MULTIPOP(S,k)$: 设$k^{\prime }＝min(k,s)$，${\alpha }_i=c_i+\varphi (D_i)-\varphi (D_{i-1})=k’+(s-k’)-s=k’-k’=0$

2.计数器加1算法

输入：$A[0..k-1]$，存储二进制数$x$
输出：$A[0..k-1]$，存储二进制数$x+1mod2k$
$$\begin{gathered} INCREMENT(A) \\ (1)i\leftarrow 0 \\ (2)whilei<kandA[i]=1Do \\ (3)A[i]\leftarrow 0; \\ (4)i\leftarrow i+1; \\ (5)Ifi<kThenA[i]\leftarrow 1 \end{gathered}$$

聚集方法：
（1）粗略分析：
每个$Increment$的时间代价最多$O(k)$，$n$个$Increment$序列的时间代价最多$O(kn)$，$n$个$Increment$平摊代价为$O(k)$
（2）精细分析：
一般地，对于$i=0,1,\dots .,lgn$, $A[i]$改变次数为$n/2i$，对于$i>lgn$, $A[i]$不发生改变 (因为$n$个操作结果为$n$，仅涉及$A[0]$至$A[lgn]$位）$T(n)={\sum }_{0\le i\le lgn}n/2i<n{\sum }_{0\le i<\infty }1/2^i=2n=O(n)$，每个$Increment$操作的平摊代价为$O(1)$

会计方法：
每次一位被置1时，付2美元，1美元用于置1的开销 ，1美元存储在该“1”位上，用于支付其被置0时的开销 • 置0操作无需再付款$Cost(Increment)=2$，${\sum }_{1\le i\le n}{\alpha }_i-{\sum }_{1\le i\le n}{c}_i\ge 0$就成立了${\sum }_{1\le i\le n}{c}_i\le 2n$

势能方法：
$\varphi (D_m)$定义为第$m$个操作后计数器中1的个数$b_m$，$\varphi (D_0)＝0$，$D_0$中1的个数为0，$\varphi (D_i)\ge 0=\varphi (D_0)$, 因为计数器中1的个数不会小于0。$INCREMENT$操作的平摊代价，第$i$个$INCREMENT$操作将$t_i$个1置0, 实际代价为$t_i＋1$，计算操作$i$的平摊代价${\alpha }_i=c_i+\varphi (D_i)-\varphi (D_{i-1})$ $If{b}_i＝k$, 操作$i就resets$所有$k$位, 所以$b_{i-1}=t_i=k$，$If{b}_i>0,则b_i＝b_{i-1}-t_i+1$于是$b_i\le b_{i-1}-t_i+1;\varphi (D_i)-\varphi (D_{i-1})=b_i-b_{i-1}\le b_{i-1}-t_i+1-b_{i-1}=1-t_i$平摊代价${\alpha }_i=c_i+\varphi (D_i)-(D_{i-1})\le (t_i+1)+(1-t_i)=2$

3.动态表的平摊分析

插入操作：$$\begin{gathered} TABLE—INSERT(T,x) \\ (1)Ifsize[T]=0Then \\ (2)获取一个大小为1的表table[T]; \\ (3)size[T]\leftarrow 1; \\ (4)Ifnum[T]=size[T]Then \\ (5)获取一个大小为2\times size[T]的新表new-table; \\ (6)将table[T]中元素插入new-table; \\ (7)释放table[T]; \\ (8)table[T]\leftarrow new-table; \\ (9)size[T]\leftarrow 2\times size[T]; \\ (10)将x插入table[T]; \\ (11)num[T]\leftarrow num[T]+1 \end{gathered}$$

聚集方法：
精细分析，第$i$次操作的代价$C_i$，如果$i-1=2^m$，$C_i=i$；否则$C_i=1$；$n$次$TABLE—INSERT$操作的总代价为${\sum }_{i=1}^n{c}_i\le n+{\sum }_{j=1}^{\lfloor logn\rfloor }{2}^j<n+2n=3n$

会计方法：
每次执行$TABLE—INSERT$平摊代价为3；1支付第11步中的基本插入操作的实际代价；1作为自身的存款；1存入表中第一个没有存款的数据上

势能方法：
$\varphi (T)=2\ast num[T]-size[T]$第i次操作的平摊代价，如果发生扩张,$c_i=3$，如果未发生扩张, $c_i=0$

收缩操作：
改进的收缩策略(允许装载因子低于1/2 )满表中插入数据项时，将表扩大一倍；删除数据项引起表不足1/4满时，将表缩小为原表的一半；扩张和收缩过程都使得表的装载因子变为1/2；表的装载因子的下界是1/4
$\varphi (T)=2\cdot num[T]-size[T],\alpha (T)\ge 1/2;size[T]/2-num[T],\alpha [T]<1/2$
作用于一动态表上的$n$个操作的实际时间为$O(n)$

4.斐波那契堆性能平摊分析

一系列树，每棵树均是一个极小堆；一个指针，指向最小元素； 一些标记顶点。用于保持堆的“扁平结构”；标记的具体含义是：$x$被标记，如果它以前是树根，但堆操作过程中变成其他结点的孩子且失去过孩子。
$n$ : 堆$H$中数据元素的个数
$rank(x)$ : 堆中结点$x$的孩子数
$rank(H)$ : 堆$H$的所有结点中的最大孩子数
$t(H)$ :堆$H$中树的棵数
$mark(H)$ :堆$H$中被标记顶点的个数
$\varphi (H)=t(H)+2\cdot mark(H)$：势能函数

插入操作的过程：以新结点为根，创建一棵新树；将新的树插入树根双向链表；如有必要，更新最小元素指针，平摊代价$O(1)$

Delete_min操作过程：删除最小元素；将其所有孩子链入双向链表，更新最小元素指针，实际开销$O(t(H)+rank(x))$；合并双向链表中的树根，使得没有树根具有相同$rank$。平摊代价$O(rank(H))$

键值减小操作：若减小键值后，堆性质仍成立，则仅需减小键值；否则, 将$x$子树剪切下来插入双向链表，若$x$的父结点$p$未标记，标记其父结点，否则，剪切$p$插入双向链表，将$p$置为未标记结点（递归过程）。实际开销$O(c)$，平摊代价$O(1)$，操作完成后的堆记为$H^{\prime }$,操作前的堆记为$H$，$t(H^{\prime })\le t(H)+c$；$mark(H^{\prime })=mark(H)-c+2$;$\Delta \varphi (H)=c+2(-c+2)=4-c$

删除操作的平摊代价$O(rank(H))$：先将节点$x$的键值减小为$-\infty$,则$x$将出现在堆顶，平摊代价$O(1)$；调用$delet{e}_{m}in$删除堆顶元素,平摊代价$O(rank(H))$。

设$x$是斐波那契堆中的任意结点，记$k=rank(x)$。设$y_1,y_2,...,y_k$是结点$x$的所有孩子结点且恰好按其成为$x$的孩子的先后次序列出，则$rank(y_1)\ge 0$,且$rank(y_i)\ge i-2$对$i=2,3,...,k$成立

证明.当$y_i$成为$x$的孩子时， $x$已有孩子$y_1,y_2,...,y_{i-1}$,故$rank(x)=i-1$;$y_i$要成为$x$的孩子，需满足$rank(y_i)=rank(x)=i-1$

设$x$是斐波那契堆中的任意结点，记$k=rank(x)$,则$x$所在的极小堆中至少有$(\frac{1+\sqrt{5}}{2}{)}^{k-2}$个结点

证明：根据引理1，用归纳法统计$x$及其子孙结点的个数有$s_k=1+s_0+s_0+...+s_{k-2}\ge 1+1+F(0)+F(1)+...+F(k-2)\ge 1+F(k)\ge (\frac{1+\sqrt{5}}{2}{)}^{k-2}$

设$H$是含有$n$个结点的斐波那契堆，则$rank(H)=O(logn)$

5.并查集性能平摊分析

$MakeSet(x)$操作执行时定义结点$x$的秩为0
$Find$操作不改变任意顶点的秩
$Union(x,y)$分两种情况修改结点的秩：情形$a$：$rank(x)=rank(y)$。此时，令$x$指向$y$且$y$是并集的代表元素，$rank(y)$增加1，$rank(x)$不变（其他结点的秩也保持不变）；情形$b$：$rank(x)<rank(y)$。此时，令$x$指向$y$且$y$是并集的代表元素，$rank(y)$和$rank(x)$保持不变（其他结点的秩也保持不变）

$$\begin{gathered} UNION(x,y) \\ (1)LINK(FIND(x),FIND(y)) \\ MAKE-SET(x) \\ (1)rank[x]\leftarrow 0 \\ (2)p[x]\leftarrow x \\ FIND(x) \\ (1)Q\leftarrow \varnothing \\ (2)Whilex\ne p[x]Do \\ (3)将x插入Q; \\ (4)x\leftarrow p[x]； \\ (5)For\forall y\in Qdo \\ (6)p[y]\leftarrow x； \\ (7)输出x \\ LINK(x,y) \\ (1)ifrank[x]>rank[y]then \\ (2)p[y]\leftarrow x \\ (3)elsep[x]\leftarrow y \\ (4)ifrank[x]=rank[y]then \\ (5)rank[y]\leftarrow rank[y]+1 \end{gathered}$$

对于含有$n$个结点的并查集，秩具有如下性质:
(1) 如果$x\ne p(x)$，则$rank(x)<rank(p(x))$
(2) $rank(x)$的初始值为0，缓慢递增直到$x$不再是集合的代表 元素，此后保持不变
(3)对于任意$x$, $rank(p(x))$是在操作过程中单调缓慢递增
(4)$rank(x)\le n-1$对任意结点成立

阿克曼函数是定义在$k\ge 0,j\ge 1$上的递归函数
$A_k(j)=\{\begin{array}{rcl}j+1& & 如果k=0\\ A_{k-1}^{(j+1)}(j)& & 如果k\ge 1\end{array}$
$k$层， 层越大，增长越快；$j$迭代次数，迭代次数越大，增长越快

阿克曼函数的逆函数定义为α(n)=min{k∣Ak(1)≥n}\alpha(n) =min \{k | A_k(1)\ge n\}α(n)=min{k∣Ak​(1)≥n}
对并查集中的每个结点$x$,定义
Level(x)=max{k∣rank(p(x))≥Ak(rank(x))}Level(x) = max\{k | rank(p(x)) \ge A_k(rank(x))\}Level(x)=max{k∣rank(p(x))≥Ak​(rank(x))}
Iter(x)=max{i∣ALeve(x)(i)(rank(x))≤rank(p(x))}Iter(x) = max\{i | A_{Leve(x)}^{(i)}(rank(x))\le rank(p(x))\}Iter(x)=max{i∣ALeve(x)(i)​(rank(x))≤rank(p(x))}
$0\le Level(x)<\alpha (n)$, 且$Level(x)$随时间递增
$1\le Iter(x)\le rank(x)$, 且只要$Level(x)$不变则$Iter(x)$不变或增大
只要$Level(x)$不变则$Iter(x)$不变或增大
${\varphi }_q(x)=\{\begin{array}{rcl}\alpha (n)\cdot rank(x)& & 若x是树根或者rank(x)=0\\ [\alpha (n)-Level(x)]\cdot rank(x)-Iter(x)& & 若x不是树根且rank(x)\ge 0\end{array}$
$0\le {\varphi }_q(x)\le \alpha (n)rank(x)$
若$x$不是树根，第$q+1$个操作是$Union$或$Find$，则${\varphi }_{q+1}(x)\le {\varphi }_q(x)$

$Make\_Set$操作的平摊代价为$O(1)$
$Union(y,z)$操作的平摊代价为$\Theta (\alpha (n))$
$Find(x)$操作的平摊代价为$\Theta (\alpha (n))$
在并查集上执行m个操作的时间复杂度为$O(m\alpha (n))$

参考：哈工大算法设计与分析PPT