算法导论习题—摊还时间代价分析、栈实现队列、贪心算法近似比、集合覆盖问题
在执行的nnn个操作中，有至多⌈lgn⌉⌈lg n⌉⌈lgn⌉个操作的次序是222的幂，这些操作的次序（即代价）如下
1,2,4,8,⋅⋅⋅,2⌈lgn⌉1, 2, 4, 8, · · · , 2 ⌈lg n⌉ 1,2,4,8,⋅⋅⋅,2⌈lgn⌉
nnn个操作的总代价为
T=∑k=0⌈lgn⌉2k+(n−⌈lgn⌉)×1=2⌈lgn⌉+1−1+(n−⌈lgn⌉)≤2lgn+2+n−lgn=3lgn+n\begin{aligned} T&=\sum^{⌈lg n⌉}_{k=0}2^k + (n − ⌈lg n⌉) × 1\\ &=2^{⌈lg n⌉+1} − 1 + (n − ⌈lg n⌉)\\ &≤2^{\lg n+2} + n − lg n\\ &=3 lg n + n \end{aligned} T=k=0∑⌈lgn⌉2k+(n−⌈lgn⌉)×1=2⌈lgn⌉+1−1+(n−⌈lgn⌉)≤2lgn+2+n−lgn=3lgn+n
因此每个操作的摊还代价是 O(3lgn+nn)=O(1)O ( \cfrac{3 \lg n + n }n ) = O(1)O(n3lgn+n)=O(1)的。
当操作次序是222的幂时，为其赋444的摊还代价，否则为其赋222的摊还代价，则每一个不为222 的幂的操作均会提供111的信用以支付差额，对于一 个nnn个操作组成的操作序列，有
4×⌈lgn⌉+2×(n−⌈lgn⌉)=2×⌈lgn⌉+2n≤3lgn+n≤∑k=0⌈lgn⌉2k+(n−⌈lgn⌉)×1\begin{aligned} &4×⌈\lg n⌉+2×(n−⌈\lg n⌉) \\ &=2×⌈\lg n⌉+2n\\ &≤3\lg n+n\\ &≤\sum^{⌈lg n⌉}_{k=0}2^k+(n−⌈\lg n⌉)×1 \end{aligned} 4×⌈lgn⌉+2×(n−⌈lgn⌉)=2×⌈lgn⌉+2n≤3lgn+n≤k=0∑⌈lgn⌉2k+(n−⌈lgn⌉)×1
每个操作的摊还代价都是常数，因此摊还代价都为O(1)O(1)O(1)。
定义势函数
ΦPhi(Di)={0,i=01,i=1lgi+1,i=2⌊lgi⌋⌊lgi⌋+k,i=2⌊lgi⌋+kΦPhi(D_i) =\left\{ \begin{aligned} & 0, \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 0\\ &1, \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 1\\ & \lg i + 1, \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 2^{⌊\lg i⌋}\\ & ⌊\lg i⌋ + k, \ \ \ \ \ \ \ \ \ \ i = 2^{⌊\lg i⌋} + k \end{aligned} \right. ΦPhi(Di)=⎩⎪⎪⎪⎪⎨⎪⎪⎪⎪⎧0, i=01, i=1lgi+1, i=2⌊lgi⌋⌊lgi⌋+k, i=2⌊lgi⌋+k
则对任意的i，Φ(Di)≥0i，Φ(D_i) ≥ 0i，Φ(Di)≥0，且
Φ(Di)−Φ(Di−1)={1−i,i=2⌊lgi⌋1,i=2⌊lgi⌋+kΦ(D_i) − Φ(D_{i−1}) =\left\{ \begin{aligned} & 1-i, \ \ \ \ \ \ \ \ i = 2^{⌊\lg i⌋}\\ & 1, \ \ \ \ \ \ \ \ \ \ \ \ \ \ i = 2^{⌊\lg i⌋} + k \end{aligned} \right. Φ(Di)−Φ(Di−1)={1−i, i=2⌊lgi⌋1, i=2⌊lgi⌋+k
所以：
∑i=1nc^=∑i=1n1=n\sum^n_{i=1}\hat{c}=\sum^n_{i=1}1=n i=1∑nc^=i=1∑n1=n
因此每个操作的摊还代价是O(1)O(1)O(1)。
使用两个栈实现队列，将两个栈记为左右栈。
ENQUEUE\text{ENQUEUE}ENQUEUE：直接对左栈进行push\text{push}push将元素入队
DEQUEUE\text{DEQUEUE}DEQUEUE：如果右栈非空，对右栈进行pop\text{pop}pop。如果右栈为空，做一个迭代：把左栈元素pop\text{pop}pop出来，push\text{push}push进右栈，直到左栈为空，再执行DEQUEUE\text{DEQUEUE}DEQUEUE。
FIND-MIN\text{FIND-MIN}FIND-MIN：在左右栈基础上再加一个辅助栈，用于记录最小值。每次有元素入左栈时，判断辅助栈为空或辅助栈的栈顶元素比入栈元素更大，则将该元素压入辅助栈中，否则将辅助栈的栈顶元素重复压入辅助栈。左栈需要弹出元素时，辅助栈需要同步弹出栈顶元素。取最小值时，直接将栈顶元素弹出，返回值即最小值。
摊还分析：
设CiC_iCi为第iii个操作的代价（假定每个操作的代价为111）设每次操作的势能D(i)=2*\text{D(i)=2*}D(i)=2*左栈元素个数，设左栈元素个数为kkk。
ENQUEUE：Ci+D(i)-D(i-1)=1+2*(k+1-k)=3\text{ENQUEUE：Ci+D(i)-D(i-1)=1+2*(k+1-k)=3}ENQUEUE：Ci+D(i)-D(i-1)=1+2*(k+1-k)=3，k+1k+1k+1表示入队后的元素，所以入队摊还时间复杂度为O(1)O(1)O(1)
DEQUEUE\text{DEQUEUE}DEQUEUE：
- 如果右栈非空,左栈有kkk个元素：Ci+D(i)-D(i-1)=1+2(k-k)=1\text{Ci+D(i)-D(i-1)=1+2(k-k)=1}Ci+D(i)-D(i-1)=1+2(k-k)=1
- 如果右栈为空,左栈有kkk个元素：Ci+D(i)-D(i-1)=2k+1+2(0-k)=1\text{Ci+D(i)-D(i-1)=2k+1+2(0-k)=1}Ci+D(i)-D(i-1)=2k+1+2(0-k)=1，其中2k2k2k为左栈弹出元素数+右栈压入元素数，111表示出队一个元素，所以出队摊还时间复杂度为O(1)O(1)O(1)
FIND-MIN\text{FIND-MIN}FIND-MIN： 使用聚合法分析，取最小值实际上是对单个辅助栈的操作，考虑整个栈的nnn个操作，一个对象压入栈后，至多弹出一次，则对该栈的nnn个PUSH、POP、MULTIPOP\text{PUSH、POP、MULTIPOP}PUSH、POP、MULTIPOP的操作序列，代价至多是O(n)O(n)O(n)，一个操作的平均时间为O(n)/n=1O(n)/n=1O(n)/n=1，所以摊还复杂度为O(1)O(1)O(1)。
每次迭代添加包含未覆盖元素最多的集合, 直到满足全覆盖条件，时间复杂度为多项式时间Θ(klgn)\Theta(k\lg n)Θ(klgn)
假设全集SSS包含nnn个元素，最优覆盖包含kkk个子集合。那么我们使用的贪心算法最多会选择klnn+1k\ln n+1klnn+1个子集。
证明：
-
uju_juj：在贪心算法第jjj次迭代还没有被覆盖的元素个数
-
OPTOPTOPT：最优解
-
kkk个最优集合必定可覆盖住该uju_juj个元素，故最优集合中至少有一个集合包含至少ujk\cfrac{u_j}kkuj个元素
-
使用贪心算法后，我们可以递推得到
uj+1≤uj−ujk=uj(1−1k)≤uj−1(1−1k)(1−1k)≤…≤u0(1−1k)j+1=n(1−1k)j+1u_{j+1}\le u_j-\frac{u_j}k = u_j(1-\frac{1}k)\le u_{j-1}(1-\frac{1}k)(1-\frac{1}k)\le…\le u_0(1-\frac{1}k)^{j+1}=n(1-\frac{1}k)^{j+1} uj+1≤uj−kuj=uj(1−k1)≤uj−1(1−k1)(1−k1)≤…≤u0(1−k1)j+1=n(1−k1)j+1
所以uj+1≤n(1−1k)j+1u_{j+1}\le n(1-\frac{1}k)^{j+1}uj+1≤n(1−k1)j+1 -
limx→+∞(1+xn)n=ex\displaystyle\lim_{x \rightarrow + \infty}(1 + \frac{x}{n})^n = e^xx→+∞lim(1+nx)n=ex，即存在这样一个式子1−x<=e−x1-x <= e^{-x}1−x<=e−x对所有的xxx都成立
所以
uj≤u0(1−1k)j
当我们选择一个集合之后，删除已经被覆盖的元素。然后我们选择每个单位成本最小的集合直到覆盖所有元素。本质上每次选择覆盖未覆盖元素最多的集合。
CCC：代表到目前为止涵盖的元素集
cost effectiveness , or α\text{cost effectiveness , or α}cost effectiveness , or α：每个新覆盖节点的平均成本
伪代码：
Greedy Method:Initial CWhile C != U:Find the set Si whose cost effectiveness is the smallestthen Set C = C∪Si Let α= wi/|Si-C|For each e∈Si-C : Set price(e) = αend WhileOutput Selected sets
我们每次选取的都是wiSi−C\cfrac{w_i}{S_i-C}Si−Cwi最小的集合SiS_iSi，即每次新添的集合SiS_iSi的新增覆盖率相对于cost\text{cost}cost值都是最大的，从而实现局部最优。
选择的集合按照先后顺序为S1,S2,…,SmS_1 , S _2 , … , S _mS1,S2,…,Sm
nin _ini 是选择SiS_iSi时，其覆盖的新元素个数。
元素被覆盖的顺序e1,e2,…,ene_1,e_2,…,e _ne1,e2,…,en 。
设SjS_jSj第一次覆盖新元素eke_kek 。
C1,...C_1,...C1,...是最优覆盖中的部分集合，覆盖了ek,…,en，ni′e_ k , … , e _n，n _i'ek,…,en，ni′ 是其覆盖的对应元素个数。不仅仅是ek,…,ene_ k ,…,e_ nek,…,en 中的元素。
- ∑ini′≥n−k+1,∑icost(Ci)≤OPT\sum_i n_i'\ge n-k+1, \sum_i cost(C_i)\leq OPT∑ini′≥n−k+1,∑icost(Ci)≤OPT，因为Ci,...C_ i , . . .Ci,...也可能覆盖了其他元素，是从最优覆盖中选择的部分集合。
- C1,....C_1 ,....C1,....没有与S1,...Sj−1S_1,...S_{j-1}S1,...Sj−1重复的。假设某个CiC_iCi 在S1,...Sj−1S_1,...S_{j-1}S1,...Sj−1中，则eke_kek之后的元素会被某个Si(i∈[1,j−1])S_i(i\in[1,j-1])Si(i∈[1,j−1])覆盖，矛盾。
- ∑icost(Ci)∑ini′≤OPTn−k+1⟹\cfrac{\sum_i cost(C_i) }{\sum_i n_i'}≤ \cfrac{O P T}{n − k + 1}\Longrightarrow∑ini′∑icost(Ci)≤n−k+1OPT⟹存在某个cost(Ci)ni′≤OPTn−k+1\cfrac{cost(C_i)}{n_i′}≤ \cfrac{O P T}{n − k + 1}ni′cost(Ci)≤n−k+1OPT。
- 由贪心算法选出的cost(Sj)nj≤cost(Ci)ni′\cfrac{cost(S_j)}{n_j}≤ \cfrac{cost(C_i)}{n_i′}njcost(Sj)≤ni′cost(Ci)。
- 对于每个kkk都存在满足333和444的CiC_iCi
- 每个点被覆盖的代价cost(ek)≤costopt(S)n−k+1cost(e_k)\le \frac {cost_{opt}(S)}{n-k+1}cost(ek)≤n−k+1costopt(S)，所以在整个贪心过程中的总代价为∑cost(ek)≤(1+12+13+⋅⋅⋅1n)⋅costopt=Hn⋅costopt\sum cost(e_k)\le(1+\frac12+\frac13+···\frac1n)·cost_{opt} =H_n·cost_{opt}∑cost(ek)≤(1+21+31+⋅⋅⋅n1)⋅costopt=Hn⋅costopt
- ∑kcost(ek)≤∑kcost(Ci)ni′≤∑kOPTn−k+1∼lnn⋅OPT\sum_kcost(e_k)\leq \sum_k\cfrac{cost(C_i)}{n_i′} \leq \sum_k\cfrac{O P T}{n − k + 1}∼\ln n·OPT∑kcost(ek)≤∑kni′cost(Ci)≤∑kn−k+1OPT∼lnn⋅OPT.
所以近似比为lnn\ln nlnn