1 大数据亚线性空间算法

场景：用二进制存储一个数字N，需要log(N)的空间

问题：如果N特别大而且这样的N又特别的多，该怎么办呢？

思路：减少一些准确性，从而节省更多的空间。

解决办法：使用近似计数算法，每一个数字的存储只需要$loglog(N)$的空间复杂度就行了。

1.1 流模型的计数问题

问题定义

定义一个数据流$<ai>,i\in [1,m],a_i\in [1,n]$，频率向量$<fi>，i\in [1,n],f_i\in [1,m]$。

要求设计空间复杂度为$loglog(N)$的算法，记录其中出现了几个$a_i$

morris算法

1. 将X初始化为0

2. 循环：如果$a_i$出现一次，就以$1/(2^X)$的概率将X增加1

3. 返回$\hat{f}=(2^X-1)$

利用切比雪夫不等式$P[|X-\mu |\ge ϵ]⩽{\sigma }^2/{ϵ}^2$证明

期望$E[2^{X_N}-1]=N$

方差$var[2^{X_N}-1]=\frac{1}{2}{N}^2-\frac{1}{2}N$

令切比雪夫不等式中的$X=Y=2^{X_N}-1$。

最终得到公式 $P[|Y-N|\ge ϵ]⩽\frac{N^2-N}{2{ϵ}^2}$。

morris+算法

1. 运行 k 次 morris 算法
2. 记录记录结果$(X_1,...,X_k)$
3. 返回$\gamma =\frac{1}{k}{\sum }_{i=1}^k(2^{X_i}-1)$

证明

$E[\gamma ]=N$

$D[\gamma ]=\frac{N^2-N}{2k}$。

$P[|\gamma -N|\ge ϵ]⩽\frac{N^2-N}{2k{ϵ}^2}$

morris++算法

1. 重复morris+算法$m=O(log(\frac{1}{\delta }))$次
2. 取$m$个结果的中位数

证明

$E[X_i]=0.9$
$\mu =0.9m$
$P[\sum X_i<0.5m]<\delta$

1.2 不重复元素数

问题定义

定义一个数据流$<a_i>,i\in [1,m],a_i\in [1,n]$，频率向量$<f_i>,i\in [1,n],f_i\in [1,m]$。计算不等于0并且不重复的元素个数

FM算法

1. 随机选取一个哈希函数（$[0,1]$上的均匀分布）
   $h:[n]\mapsto [0,1]$

2. $z=1$

3. 当一个数字 i 出现的时候： z = m i n { z , h ( i ) } z=min\{z,h(i)\} z=min{z,h(i)}

4. 返回$\frac{1}{z}-1$

证明

期望$E[z]=\frac{1}{d+1}$

$var[z]⩽\frac{2}{(d+1)(d+2)}<\frac{2}{(d+1)(d+1)}$

$P[|z-\frac{1}{d+1}|>ϵ\frac{1}{d+1}]<\frac{var[z]}{{\frac{ϵ}{d+1}}^2}<\frac{2}{{ϵ}^2}$

FM+算法

1. 总共运行 q 次FM算法
2. 为每一次的运行随机选取一个哈希函数
   $h_j:[n]\mapsto [0,1]$
3. 初始化$z_j=1$
4. 开始计数：每当 i 出现，更新$z_j=min(z_j,h_j(i))$
5. $Z=\frac{1}{q}{\sum }_{j=1}^q{z}_j$
6. 返回$\frac{1}{Z}-1$

证明

$E[Z]=\frac{1}{d+1}$

$var[Z]⩽\frac{2}{(d+1)(d+2)}\frac{1}{q}<\frac{2}{(d+1)(d+1)}\frac{1}{q}$

$P[|X-d|>{ϵ}^{\prime }d]<\frac{2}{q}(\frac{2}{{ϵ}^{\prime }}+1{)}^2$

计算代价缩小为$O(\frac{1}{{ϵ}^2}log\frac{1}{\delta })$

FM′+算法

1. 随机选取一个哈希函数
   $h:[n]\mapsto [0,1]$
2. $(z_1,z_2,...,z_k)=1$也就是所有的z的初值都设置为1
3. 维护当前看到的最小的k个哈希值
4. 返回$\frac{k}{z_k}$

证明

$P[|\frac{k}{z_k}-d|>ϵd]=P[\frac{k}{(1+ϵ)d}>z_k]+P[\frac{k}{(1-ϵ)d}<z_k]$

$P<\frac{2}{{ϵ}^{2}k}$

PracticalFM算法 和 BJKST算法的准备知识

若我们无法存储实数，则采用PracticalFM算法 和 BJKST算法
$$\begin{gathered} 若\forall j_1,...,j_k\in [b],\forall j_1,...,j_k\in [a], \\ p[h(i_1)=j_1\wedge ...\wedge h(i_k)=j_k]=\frac{1}{b^k} \\ 则:一个从[a]映射到[b]的哈希函数是k-wise的 \end{gathered}$$

$$\begin{gathered} zeros(h(j))=max(i:p\%2^i=0) \\ 也就是展开成二进制后末尾0的个数， \\ 比如8对应的二进制是1000，则zeros(8)=3。 \end{gathered}$$

PracticalFM算法

1. 从$2-wiseindependent$哈希函数族中随机选取 $h:[n]\mapsto [n]$

2. $z=0$

3. 如果$zeros(h(j))>z$

   $z=zeros(h(j))$

4. 返回$\hat{d}=2^{z+\frac{1}{2}}$

算法解释

$1-\frac{2\sqrt{2}}{C}$概率满足$d/C\le \hat{d}\le Cd$。

证明

$E[Y_r]=\frac{d}{2^r}$

$var[Y_r]\le \frac{d}{2^r}$。

最终正确的概率应该大于$1-\frac{2\sqrt{2}}{C}$。

BJKST算法

1. 随机选择$2-wiseindependent$哈希函数 $h:[n]\to [n]$

2. 随机选择$2-wiseindependent$哈希函数 $g:[n]\to [bϵ-4log2n]$

3. $z=0,B=\varnothing$

   若$zeros(h(j))>z$

   1. $B=B\cup (g(j),zeros(h(j)))$
   2. 若$|B|>\frac{c}{{ϵ}^2}$
      1. $z=z+1$
      2. 从B中删除$(\alpha ,\beta )$，其中$\beta <z$

4. return $\hat{d}=|B|2^z$

算法解释

要想清楚地解释这个算法，只需要清楚两点即可。

• 当出现的一个新的元素时
  • 如果$zeros(h(j))>z$
    • 则将相应的二元组插入到B中；
    • 如果B中的元素数量超过了某个大小：
      • z的值相应的就增加1
      • 就将其中第二项小于z的元素从中删除。

证明

该算法可以实现至少2/3概率保证(1+ϵ)近似。

$E[Y_r]=\frac{d}{2^r}$

$var[Y_r]\le \frac{d}{2^r}$

最终$P[FAIL]<1/6$。

再加上之前出去算法假设造成的错误概率，最终总的错误概率在1/3之内。

评价

空间复杂度为$O(logn+\frac{1}{{ϵ}^2}(log\frac{1}{ϵ}+loglogn))$。

1.3 点查询

问题定义

定义一个数据流$<ai>，i\in [1,m],a_i\in [1,n]$，频率向量$<fi>,i\in [1,n],f_i\in [1,m]$。计算流中所有的元素出现次数

知识准备

• 范数：$l_p={\Vert x\Vert }_p={({\sum }_i|x_i{|}^p)}^{\frac{1}{p}}$
• $l_p$点查询（频度估计）
  给定数据流$\sigma$和$a_i$输出$\widehat{f_i}$满足$\widehat{f_i}=f_i\pm ϵ\left||\text{f}\right|{|}_p$
  $\left||x\right|{|}_1\ge \left||x\right|{|}_2\ge ...\ge \left||x\right|{|}_{\infty }$，p越大，估计越准确
  $\Vert x{\Vert }_0$是不同元素的数目
  $\Vert x{\Vert }_1$是流的长度
  $\Vert x{\Vert }_{\infty }$是最大频度

Misra_Gries算法

维护一个集合A，其中的元素是$(i,\widehat{f_i})$

1. $A\leftarrow \varnothing$

2. 对每一个数据流中的元素e

   if e∈A，令$(e,\widehat{f_e})\to (e,\widehat{f_e}+1)$

   else if $|A|<\frac{1}{ϵ}$：将(e,1)插入A

   else

   1. 将所有A中计数减 1
   2. if $\widehat{f_j}=0$：从A中删除(j,0)

3. 对于查询 i，如果$i\in A$，返回$\widehat{f_i}$，否则返回 0

证明

对任意的查询 i，返回 $\widehat{f_i}$ 满足$f_i-ϵm\le \widehat{f_i}\le f_i$。

证明

结合算法过程，总共有两种情况。

如果不发生减1的情况，那么$\widehat{f_i}=f_i$
如果发生了减1的情况，有$\widehat{f_i}<f_i$
假设发生了c次减1的情况，总数减少$\frac{c}{ϵ}\le m$，每个计数至多减少c，$\widehat{f_i}\ge f_i-c\ge f_i-ϵm$。

算法的空间代价是$O({ϵ}^{-1}logn)$

Metwally算法

维护一个集合A，集合中的元素是$(i,\widehat{f_i})$

1. A←∅
2. 对每一个数据流中的元素e
   1. if e∈A：令$(e,\widehat{f_i})\leftarrow (e,\widehat{f_i}+1)$
   2. else if $|A|<\frac{1}{ϵ}$：将(e,1)插入A
   3. else 将(e,MIN+1)插入A，并删除一个满足$\widehat{f_e}=MIN$
3. 查询 i，如果$i\in A$，返回$\widehat{f_i}$，否则返回MIN

证明的目标

对任意的查询 i，返回$f_i\le \widehat{f_i}\le f_i+ϵm$

证明

① 如果不发生删除的情况，那么$\widehat{f_i}=f_i$。

② 如果删除，计数一定不大于删除后的MIN，有$\widehat{f_i}\ge f_i$，A中元素总是m，$MIN\frac{1}{ϵ}\le m\Rightarrow MIN\le ϵm$，每个元素至多超出真实值MIN，$\widehat{f_i}\le f_i+ϵm$。

算法的空间代价是$O({ϵ}^{-1}logn)$

新的定义

Sketch

定义在数据流σ上的数据结构DS(σ)是一个Sketch

如果存在一个Space−Efficient的合并算法COMB使得$COMB(DS({\sigma }_1),DS({\sigma }_2))=DS({\sigma }_1\circ {\sigma }_2)$，其中∘是数据流的连接操作。

Linear Sketch

定义在[n]上的数据流σ上的sketching输出sk(σ)，如果sk(σ)取值为维度l=l(n)的向量，并且是f(σ)的线性函数，那么sk(σ)是一个Linear Sketch，l是这个sketch的维度。

Count-Min算法

1. $C[\mathrm{1...}t][\mathrm{1...}k]\leftarrow \text{0},k=\frac{2}{ϵ},t=\lceil log\frac{1}{\delta }\rceil$

2. 随机选择 t 个2−wise独立哈希函数 $h_i:[n]\to [k]$

3. 对每一个出现的更新(j,c)进行如下操作

   for i=1 to t

   ​ $C[i][h_i(j)]=C[i][h_i(j)]+c$

4. 针对对于a的查询，返回 $\widehat{f_a}={\min }_{1\le i\le t}C[i][h_i(a)]$

算法解释

在算法开始时，构造一个 t 行 k 列 的空数组，可以认为每一行是独立的，算法在运行时同时记录了t个这样的数组。在每出现一个流数据的时候，对每一个数组进行一次更新，注意元素的第二个下标用的是数据的哈希值。

算法在运行的过程中可能产生冲突，也就是两个不同的流数据的哈希值可能相同，这个时候就会导致结果偏大，但是因为有相当于t次的重复计算，通过取最小值的方法来进行一些弥补

证明

该算法以1−δ概率给出$l_1$点查询问题的(1+ϵ)近似

评价

算法的空间代价为$O(\frac{1}{ϵ}log\frac{1}{\delta }(logn+logm))$

Count-Median算法

1. $C[\mathrm{1...}t][\mathrm{1...}k]\leftarrow \text{0},k=\frac{2}{ϵ},t=\lceil log\frac{1}{\delta }\rceil$

2. 随机选择t个2−wise独立哈希函数$h_i:[n]\to [k]$

3. 对每一个出现的更新(j,c)进行如下操作

   for i=1 to t

   ​ $C[i][h_i(j)]=C[i][h_i(j)]+c$

4. 针对对于a的查询，令$|C[x][h_x(a)]|=media{n}_{1\le i\le t}|C[i][h_i(a)]|$

5. 返回$\widehat{f_a}=|C[x][h_x(a)]|$

算法解释

与Count−MinSketch算法的计数方法完全一致，差别就在返回值的获取上，返回的是所有t个数组值的绝对值的中位数对应的原始值。

Count Sketch算法

1. $C[\mathrm{1...}k]\leftarrow 0,k=\frac{3}{{ϵ}^2}$

2. 随机选择1个2−wise独立哈希函数$h:[n]\to [k]$

3. 随机选择1个2−wise独立哈希函数$g:[n]\to -1,1$

4. 对于每一个更新(j,c)

   $C[h(j)]=C[h(j)]+c\ast g(j)$

5. 针对查询a，返回$\hat{f}=g(a)\ast C[h(j)]$

Count Sketch+算法

1. $C[\mathrm{1...}t][\mathrm{1...}k]\leftarrow \text{0},k=\frac{3}{{ϵ}^2},t=O(log\frac{1}{\delta })$

2. 随机选择1个2−wise独立哈希函数 $h_i:[n]\to [k]$

3. 随机选择1个2−wise独立哈希函数 g i : [ n ] → { − 1 , 1 } g_i:[n] \rightarrow \{-1,1\} gi​:[n]→{−1,1}

   对于每一个更新(j,c)

   ​ 对于$i:1\to t$

   ​ $C[h_i(j)]=C[h_i(j)]+c\ast g_i(j)$

4. 返回$\hat{f}=median1\le i\le tgi(a)C[i][h_i(a)]$

算法解释

相当于是将Count Sketch算法运行了t次，最后取了中值。利用齐尔诺夫不等式可以解决，令Xi=1⇔第i次运行成功，成功概率是2/3，最后只要成功的个数超过一半即可。最终是通过t控制了δ。

1.4 频度矩估计

Basic AMS算法

1. $(m,r,a)\leftarrow (0,0,0)$
2. 对于每一个更新 j
   1. $m\leftarrow m+1$
   2. $\beta \leftarrow randombitwithP[\beta =1]=\frac{1}{m}$
   3. if β==1： a=j，r=0
   4. if j==a： $r\leftarrow r+1$
3. 返回$X=m(r^k-(r-1{)}^k)$

算法分析

$E[X]=F_k$

$Var[X]\le k{n}^{1-\frac{1}{k}}{F}_k^2$

利用切比雪夫不等式对结果进行检验$P[|X-E[x]|>ϵE[X]]<\frac{k{n}^{1-\frac{1}{k}}}{{ϵ}^2}$

评价

存储 m 和 r 需要 log n 位
存储 a 需要 log m 位
算法的方差太大，需要进一步的改进，但是其相应的存储代价为$O(logm+logn)$

Final AMS 算法

1. 利用Median‑of‑Mean技术调用Basic AMS算法;
2. 计算$t=clog\frac{1}{\delta }$个平均值，每个平均值是$r=\frac{3k}{{ϵ}^2}{n}^{1-\frac{1}{k}}$次调用的平均值
3. 返回t个数值的中间值

证明

记 { X i j } i ∈ [ t ] , j ∈ [ r ] \{X_{ij}\}_{i \in [t],j \in [r]} {Xij​}i∈[t],j∈[r]​是与X独立同部分的随机变量集合。

$Y_i=\frac{1}{r}{\sum }_{j=1}^r{X}_{ij}$

$Z={\sum }_{i=1}^t{Y}_i$

计算$E[Y_i]=E[X],Var[Y_i]=\frac{Var[X]}{k}$

根据切比雪夫不等式有$P[|Y_i-E[Y_i]|\ge ϵE[Y_i]]\le \frac{Var[X]}{k{ϵ}^{2}E[X{]}^2}$

取值$r=\frac{3Var[X]}{k{ϵ}^{2}E[X{]}^2}$，将期望和方差带入可以计算得到算法中给出的结果

现在$P[|Y_i-E[Y_i]|\ge ϵE[Y_i]]\le \frac{1}{3}$

最后利用Median技术进行处理即可。

评价

算法的空间代价为$O(\frac{1}{{ϵ}^2}log\frac{1}{\delta }k{n}^{1-\frac{1}{k}}(logm+logn))$，当k≥2时代价过大。

Basic F2 AMS 算法

1. 随机选择4−wise独立的哈希函数 $h:[n]\to -1,1$

2. x←0

3. 对于每一个更新(j,c)

   $x\leftarrow x+c\ast h(j)$

4. 返回$x^2$

分析

这个算法本身并没有什么比较好的效果，但是用过median−of−mean技术的优化，可以得到一个(ϵ,δ)的算法。所以在这里的证明中，只计算出结果的期望和方差就行了。

证明

记$Y_j=h(j),j\in [1,n],X={\sum }_{j=1}^n{f}_j{Y}_j$

$E[X^2]={\sum }_{i=1}^n{f}_i{Y}_i\times {\sum }_{j=1}^n{f}_j{Y}_j$

$Var[X^2]=E[X^4]-E[X^2{]}^2$

评价

算法的空间代价是O(logm+logn)，下面先使用mean将犯错概率限制在1/3，再使用median技术对结果进行优化。

1.5 固定大小采样

水库抽样算法

1. m←0
2. 使用数据流的前s个元素对抽样数组进行初始化
   $A[1,...,s],m\leftarrow s$
3. 对于每一个更新x
   1. x以$\frac{s}{m+1}$概率随机替换A中的一个元素
   2. m++

证明

假定已经流过的数据量为n，采样池大小为s

考虑最普通的情况，第j个元素进了采样池，之后再也没有被选出去，那么在第n个元素流过之后，这个元素还在采样池中的概率是s/n

计算方法：被选进去的概率是s/j，为保证不被选出去，两种情况：新的元素没有选进来，新的元素选进来了但是该元素没有被替换掉。这两种情况对应着$(1-\frac{s}{j+1})+\frac{s}{j+1}\ast \frac{s-1}{s}=\frac{j}{j+1}$。依次类推最终可以计算得到结果s/n。

1.6 Bloom Filter

给定一个数据集U，从中抽取一个子集S，给定一个数q∈U，判定q∈S是否成立。

近似哈希的方法

1. 令H是一族通用哈希函数：$[U]\to [m]，m=\frac{n}{\delta }$
2. 随机选择 h∈H，并维护数组A[m]，S的大小是n
3. 对每一个 i∈S，$A[h(i)]=1$
4. 给定查询q，返回yes当且仅当$A[h(i)]=1$

证明

如果q∈S，返回的就是yes，如果q∉S，那么本应该返回no，但是有一定的概率返回yes，这就是错误的情况，元素本来不在S中，但是它的哈希值却与其中的某个元素的哈希值相同。${\sum }_{j\in S}P[h(q)=h(j)]\le \frac{n}{m}=\delta$，这样就计算除了m的值，并解决了近似问题。

Bloom Filter方法

1. 令H是一族独立的理想哈希函数：[U]→[m]

2. 随机选取$h_1,...,h_d\in H$，并维护数组A[m]

3. 对于每一个i∈S

   ​ 对于每一个j∈[1,d]

   ​ $A[h_j(i)]=1$

4. 给定查询q，返回yes当且仅当$\forall j\in [d],A[h_j(q)]=1$

证明

失败的概率为$P\le (\frac{n}{m}{)}^d=\delta$，所以最终的代价就是$m=O(nlog\frac{1}{\delta })$

2 大数据亚线性时间算法

2.1 计算图的平均度算法Vertex Cover一

定义

已知：$G=(V,E)$
求：平均度$\bar{d}=\frac{{\sum }_{u\in V}d(u)}{n}$
假设：G是简单图，没有平行边和自环

分析

将具有相似或者相同度数的节点分组，然后估算每个分组的平均度数。

首先将所有的点进行分桶，分成t个桶，第i个桶里的点集合为 B i = { v ∣ ( 1 + β ) ( i − 1 ) < d ( v ) < ( 1 + β ) i } , 0 < i ≤ t − 1 B_i=\{v|(1+\beta)^{(i-1)} < d(v) < (1+\beta)^{i}\},0<i\leq t-1 Bi​={v∣(1+β)(i−1)<d(v)<(1+β)i},0<i≤t−1，其中β是超参数。

于是$B_i$中的点的总度数有上下界如公式所示：$(1+\beta {)}^{(i-1)}|B_i|<d(B_i)<(1+\beta {)}^i|B_i|$

进一步的G的总度数可以表示为：${\sum }_{i=0}^{t-1}(1+\beta {)}^{(i-1)}|B_i|<{\sum }_{u\in V}d(u)<{\sum }_{i=0}^{t-1}(1+\beta {)}^i|B_i|$

于是我们可以得到：$\frac{{\sum }_{i=0}^{t-1}(1+\beta {)}^{(i-1)}|B_i|}{n}<\bar{d}<\frac{{\sum }_{i=0}^{t-1}(1+\beta {)}^i|B_i|}{n}$

于是将问题转化成了对$\frac{B_i}{n}$的估计

算法

1. 从V取出样本集合S
2. $S_i\leftarrow S\cap B_i$
3. ${\rho }_i\leftarrow \frac{S_i}{S}$
4. 返回 $\hat{\bar{d}}={\sum }_{i=0}^{t-1}{\rho }_i(1+\beta {)}^i$

算法的思想其实很简单，将$\frac{B_i}{n}$理解为一种概率，就是随机选一个点，这个点属于Bi的概率，这样理解算法就很简单了。

评价

算法的思想和计算都很简单，只是进行了一个非常巧妙的转化，但是这个算法仍然是有问题的

2.2 计算图的平均度算法二

改进算法

对于较小的桶的${\rho }_i$，假定一个$\bar{d}$的一个下阶$\alpha$。

1. 从V中抽取样本S
2. $S_i\leftarrow S\cap B_i$
3. f o r   i ∈ { 0 , … , t − 1 }   d o \boldsymbol{for}\ i \in \{0,\dots,t-1\}\ \boldsymbol{do} for i∈{0,…,t−1} do
   1. $\mathbf{if}|S_i|\ge {\theta }_{\rho }\mathbf{then}$
   2. ${\rho }_i\leftarrow \frac{|S_i|}{|S|}$
   3. $\mathbf{else}$
      1. ${\rho }_i\leftarrow 0$
4. $\mathbf{return}\hat{\bar{d}}={\sum }_{i=0}^{t-1}{\rho }_i(1+\beta {)}^i$

我们将算法的结果调整为以2/3的概率有$(0.5-ϵ)\bar{d}<\hat{\bar{d}}<(1+ϵ)\bar{d}$。

这里给出一组参数，使得能够满足上述结果：

1. $\beta =\frac{ϵ}{4}$
2. $|S|=\Theta (\sqrt{\frac{n}{\alpha }}\cdot poly(logn,1/ϵ))$
3. $t=\lceil lo{g}_{(1+\beta )}n\rceil +1$
4. ${\theta }_{\rho }=\frac{1}{t}\sqrt{\frac{3}{8}\cdot \frac{ϵ\alpha }{n}}|S|$

2.3 计算图的平均度算法三

算法改进的思想

我们将算法出现的误差归结到边上，让我们来看看究竟是哪些边导致了这样的错误。将节点分为U,V/U两部分，其中U是度数较小的节点，V/U是度数较大的节点，E(U,V/U)表示连接两个集合的边的集合。于是，我们断言出现误差就是因为E(U,V/U)中的边我们只计算了一次，关于这一点我们回忆一下之前举的例子就很好理解了。于是我们只要找到每次抽样的时候这部分的边的比例就可以了。

改进算法

利用$E[{\Delta }_i]$的$1+ϵ$估计，可以得到${\Delta }_i{\rho }_i(1+\beta {)}^i$是$\frac{T_i}{n}的(1+ϵ)(1+\beta )$估计。于是乎，经过改造的算法如下所示：

1. 从V中抽取样本S，$|S|=\tilde{O}(\frac{L}{\rho {ϵ}^2}),L=poly(\frac{logn}{ϵ}),\rho =\frac{1}{t}\sqrt{\frac{ϵ}{4}\cdot \frac{\alpha }{n}}$
2. $S_i\leftarrow S\cap B_i$
3. f o r   i ∈ { 0 , … , t − 1 }   d o \boldsymbol{for}\ i \in \{0,\dots,t-1\}\ \boldsymbol{do} for i∈{0,…,t−1} do
   1. $\mathbf{if}|S_i|\ge {\theta }_{\rho }\mathbf{then}$
      1. ${\rho }_i\leftarrow \frac{|S_i|}{|S|}$
      2. $estimate{\Delta }_i$
   2. $\mathbf{else}$
      1. ${\rho }_i\leftarrow 0$
4. $\mathbf{return}\hat{\bar{d}}={\sum }_{i=0}^{t-1}(1+{\Delta }_i){\rho }_i(1+\beta {)}^i$

2.4 计算图的平均度算法四

Alg III

利用$E[{\Delta }_i]$的$1+ϵ$估计，可以得到${\Delta }_i{\rho }_i(1+\beta {)}^i$是$\frac{T_i}{n}的(1+ϵ)(1+\beta )$估计。于是乎，经过改造的算法如下所示：

1. 从V中抽取样本S，$|S|=\tilde{O}(\frac{L}{\rho {ϵ}^2}),L=poly(\frac{logn}{ϵ}),\rho =\frac{1}{t}\sqrt{\frac{ϵ}{4}\cdot \frac{\alpha }{n}}$
2. $S_i\leftarrow S\cap B_i$
3. f o r   i ∈ { 0 , … , t − 1 }   d o \boldsymbol{for}\ i \in \{0,\dots,t-1\}\ \boldsymbol{do} for i∈{0,…,t−1} do
   1. $\mathbf{if}|S_i|\ge {\theta }_{\rho }\mathbf{then}$
      1. ${\rho }_i\leftarrow \frac{|S_i|}{|S|}$
      2. $estimate{\Delta }_i$
   2. $\mathbf{else}$
      1. ${\rho }_i\leftarrow 0$
4. $\mathbf{return}\hat{\bar{d}}={\sum }_{i=0}^{t-1}(1+{\Delta }_i){\rho }_i(1+\beta {)}^i$

Alg IV

1. $\alpha \leftarrow n$
2. $\hat{\bar{d}}<-\infty$
3. $\mathbf{while}\hat{\bar{d}}<\alpha \mathbf{do}$
   1. $\alpha \leftarrow \alpha /2$
   2. $\mathbf{if}\alpha <\frac{1}{n}\mathbf{then}$
      1. $\mathbf{return}0;$
   3. $\hat{\bar{d}}\leftarrow AlgII{I}_{\sim \alpha }$
4. $\mathbf{return}\hat{\bar{d}}$

算法相关指标

近似比：$(1+ϵ)$

运行时间：$\tilde{O}(\sqrt{n})\cdot poly({ϵ}^{-1}logn)\sqrt{n/\bar{d}}$

2.5 近似最小支撑树

定义

已知：$G=(V,E),ϵ,d=deg(G)$，边(u,v)的权重是 w u v ∈ { 1 , 2 , … , w } ∪ { ∞ } w_{uv}∈\{1,2,…,w\}∪\{∞\} wuv​∈{1,2,…,w}∪{∞}

求：$\hat{M}$满足$(1-ϵ)M\le \hat{M}\le (1+ϵ)M$，令M为$mi{n}_{TspansG}W(T)$

分析

定义：

G的子图$G^{(i)}=(V,E^{(i)})$
$E(i)=\{(u,v)|w_{uv}\le i\}$
连通分量的个数为C(i)

定理：若M为所有这样的子图的连通分量的数目的和，$M=n-w+{\sum }_{i=1}^{w-1}{C}^{(i)}$

证明：设图G的一个最小生成树为$MST=(V,E^{\prime })$，MST的子图$MS{T}^{(i)}=(V^{\prime },E^{\prime (i)}),V^{\prime }=V,E^{\prime (i)}=\{(u,v)|(u,v)\in E^{(i)}\&(u,v)\in E^{\prime }\}$

设${\alpha }_i$为MST 中权重为i的边的数目

${\sum }_{i>1}{\alpha }_i$表示MST中所有边权大于1的边的个数，这个数值加1，应该就是在MST中将这些边从MST中去掉之后得到的$MS{T}^{(l)}$中的连通分量的个数

$MS{T}^{(l)}$的连通分量的个数应该与G(i)是一致的，于是我们得到了下面的式子：${\sum }_{i>1}{\alpha }_i=C^{(l)}-1$。

于是我们就可以用如下的方法计算M了：
$$\begin{array}{rl}M& =\sum _{i=1}^{w}i\cdot {\alpha }_i=\sum _{i=1}^w{\alpha }_i+\sum _{i=2}^w{\alpha }_i+\cdots +\sum _{i=w}^w{\alpha }_i\\ & =C^{(0)}-1+C^{(1)}-1+\cdots +C^{(w-1)}-1\\ & =n-1+C^{(1)}-1+\cdots +C^{(w-1)}-1\\ & =n-w+\sum _{i=1}^{w-1}{C}^{(i)}\end{array}$$

时间复杂度

运行w次求解连通分量个数的时间复杂度：$w\cdot O(d/{ϵ}^3)=O(d{w}^4/{ϵ}^{\prime 3})$。

2.6 求点集合的直径

定义：

已知：有m个点，点与点之间的距离使用邻接矩阵表示，则Dij表示点i到点j的距离，D是一个对称矩阵，并且满足三角不等式$D_{ij}\le D_{ik}+D_{kj}$。

求出：点对(i,j)使得Dij是最大的，则Dij是这m个点的集合的直径。

求解算法：The Indyk’s Algorithm

1. 任选$k\in [1,m]$
2. 选出$l$，使得$\forall i,D_{ki}\le D_{kl}$
3. 返回$(k,l),D_{kl}$

算法分析之近似比分析

最优解记为 opt，是点 i 和点 j 之间的距离

则有$\frac{opt}{2}\le D_{kl}\le opt$

算法分析之近似比证明不等式

关于不等式的右侧易证，左侧的证明如下所示：
$$\begin{array}{rl}opt=& D_{ij}\\ \le & D_{ik}+D_{kj}\\ \le & D_{kl}+D_{kl}\\ \le & 2D_{kl}\end{array}$$

算法评价

算法的时间复杂度为$O(m)=O(\sqrt{n})$。

2.7 求连通分量的数目

定义

已知：$G=(V,E),ϵ,d=deg(G)$，图G用邻接表表示，其中d表示所有节点中度最大的节点的度，$|V|=n,|E|=m\le d\cdot n$

求出：一个y，使得$C-ϵ\cdot n\le y\le C+ϵ\cdot n$，其中C为使用线性算法求解得到的标准解

问题分析

记顶点v所属的连通分量中的节点数目为$n_v$，A∈V是一个连通分量的点集合，则存在如下等式关系：${\sum }_{u\in A}\frac{1}{n_u}={\sum }_{u\in A}\frac{1}{|A|}=1$，这个很容易证明，因为同一个连通分量中的每一个点的$n_v$是一样的，都是分量中点的个数的倒数。如此，则最终的结果C可以表示为${\sum }_{u\in V}\frac{1}{n_u}$。因此进一步地，对C的估计可以转化为对$\frac{1}{n_u}$的估计。

求解问题的思想

$n_u$很大，精确计算很难，但是此时$\frac{1}{n_u}$很小，可以用一个很小的常量代替$\frac{1}{n_u}$(0或者$\frac{ϵ}{2}$)，如果我设 n u ^ = m i n { n u , 2 ϵ } \hat{n_u} = min\{n_u,\frac{2}{\epsilon}\} nu​^​=min{nu​,ϵ2​}，则$\hat{C}={\sum }_{u\in V}\frac{1}{\widehat{n_u}}$，使用$\hat{C}$来估计C可以获得很不错的结果。

算法-计算$\widehat{n_u}$

思想很简单，就是一个小型的搜索，如果搜索到的点的个数小于$\frac{2}{ϵ}$就继续搜索，否则直接返回$\frac{2}{ϵ}$。

时间复杂度为$O(d\cdot \frac{1}{ϵ})$，d越大，用的时间越长，$\frac{1}{ϵ}$越大，用的时间越长。

算法-计算$n_u$

从节点集合中随机选出$r=b/{ϵ}^2$个节点构成节点U，对每个节点应用上一个算法，于是最终的$\hat{C}=\frac{n}{r}{\sum }_{u\in U}\frac{1}{\widehat{n_u}}$，时间复杂度为$O(d/{ϵ}^3)$

3 并行计算算法

3.1 基本问题（一）

MapReduce

使用MR模型进行计算有几个要点：

• 计算分轮次进行，每一轮的输入和输出的数据都是形如<key,value>的
• 每一轮分为：Map、Shuffle、Reduce
• Map：每个数据被map函数处理，输出一个新的数据集合，也就是改变了<key,value>
• Shuffle：对编程人员透明，所有在Map中输出的数据，被按照key分组，具备相同key 的数据被分配到相同的reducer
• Reduce：输入<k,v1,v2,…>，输出新的数据集合
• 针对这样的计算框架，我们的设计目标为：更少的轮数、更少的内存、更大的并行度

问题实例

下面我们来看一些具体的问题实例，这些例子都是可以并行的，当然实现的逻辑不止一种，有多种可能性，这里只是给出一种方法。

构建倒排索引

定义：给定一组文档，统计每一个单词出现在哪些文件中

• Map函数：$<docID,content>\to <word,docID>$，在map函数处理的时候对content进行拆分，并将分出来的word都转换成word加上对应的docID输出。
• Reduce函数：$<word,docID>\to <word,listofdocID>$，map函数结束之后，shuffle会自动将key相同的键值对输出到一个机器上，我们直接对这个批次中的数据规整到一起即可。

单词计数

定义： 给定一组文档，统计每一个单词出现的次数

• Map函数：<docID,content>→<word,1>
• Reduce函数：<word,1>→<word,count>

检索

定义：给定行号和相应的文档内容，统计指定单词出现的位置（*行号）

• Map函数：略
• Reduce函数：略

3.2 基本问题（二）

简介

问题实例：矩阵乘法

就是简单的矩阵乘法，我们知道，普通的矩阵乘法的时间复杂度是O(m⋅n⋅d)，对于一个m⋅d和d⋅n的矩阵相乘。通过并行计算框架我们极大加速这个过程的执行，具体的两个方法如下面所示

矩阵乘法1

定义：矩阵A和矩阵B，(A,i,j)指向矩阵A的第i行j列的元素，但并不是真实的这个元素，而是表示一种索引，aij表示的则是这个元素。

• Map：
  • ((A,i,j),aij)→(j,(A,i,aij))
  • ((B,j,k),bjk)→(j,(B,k,bjk))
• Reduce：(j,(A,i,aij)),(j,(B,k,bjk))→((i,k),aij∗bjk)
• Map：nothing（identity）
• Reduce：((i,k),(v1,v2,…))→((i,k),∑vi)

思路剖析：目标矩阵上的每个元素都是由d个中间元素（aij∗bjk）累加得到的，我们先统把这样的所有的元素求出来，然后累加起来即可。对于目标矩阵上的每个元素都是如此。

矩阵乘法2

• Map函数：

  • ((A,i,j),aij)→((i,x),(A,j,aij)) for all x∈[1,n]
  • ((B,j,k),bjk)→((y,k),(B,j,bjk)) for all y∈[1,m]

• Reduce函数：((i,k),(A,j,aij))∧((i,k),(B,j,bjk))→((i,k),∑aij∗bjk)

思路剖析：相对于第一个方法，方法2先不把中间元素求出来，而是把求解每个目标矩阵上要用到的2d个基本元素都放到一起，然后进行点积操作。

3.3 排序算法

问题简介

算法

使用p台处理器，输入$<i,A[i]>$

• Map：$<i,A[i]>\to <j,((i,A[i]),y)>$

  1. 输出$<i\%p,((i,A[i]),0)>$

  2. 以概率T/n为所有$j\in [0,p-1]$输出$<j,((i,A[i]),1)>$

     否则输出$<j,((i,A[i]),0)>$

• Reduce：

  • 将y=1的数据收集为S并排序
  • 构造$(s_1,s_2,...,s_{p-1})$，$s_k$为S中第$k\lceil \frac{|S|}{p}\rceil$
  • 将y=0的数据收集为D
  • (i,x)∈D满足$s_k<x\le s_{k+1}$，输出<k,(i,x)>

• Map：nothing（identity）

• Reduce：$ <j, ((i, A[i]), . . . )>$

  • 将所有$(i,A[i])$根据$ A[i]$排序并输出

思路剖析：整体的思路就是先对整个数据进行一个划分，分成不同的小段，段与段之间的数据具有严格的大小关系，这样每个段内部的数据都是一些很接近的数据，如此我们就可以借助一些高效的排序手段对每个段内部的数据集进行排序。然后**解决问题的一个关键就是，我们对数据的划分的好坏，这一点我们可以通过理论来证明有很大概率可以保证划分的效果。**但是也不绝对，出现某个计算节点上基本没有数据，而另一个计算节点上出现超量的数据也是有可能的，当然这是极小概率事件。

3.4 计算最小支撑树（生成树）

问题简介

已知图G=(V,E)，其中V,E分别是图的点集合和边集合。图G的一个子图$T^{\ast }=(V,E^{\prime })$被称为最小生成树当且仅当$T^{\ast }$是连通的并且 ∑ ( u , v ) ∈ T ∗ w ( u , v ) = min ⁡ T { ∑ ( u , v ) ∈ T w ( u , v ) } \sum_{(u,v)\in T^*}{w(u,v)} = \min_{T}\{\sum_{(u,v)\in T}{w(u,v)}\} ∑(u,v)∈T∗​w(u,v)=minT​{∑(u,v)∈T​w(u,v)}。

在小数据范围内，通常使用Kruskal或Prim算法求解，当图的规模变得较大时，由于这两个算法的复杂度的限制，在有限时间内将无法求解。这时可以借助MapReduce来加速计算。

算法主要思想

利用图划分算法，将图G划分成k个子图，在每个子图中计算最小生成树，具体如下。

1. 将节点分成k部分，对每一个$(i,j)\in [k{]}^2$，令$G_{ij}=(V_i\cup V_j,E_{ij})$为节点$V_i\cup V_j$上的导出子图
2. 在每个Gij上分别求解$M_{ij}=MSF(G_{ij})$
3. 令$H={\cup }_{i,j}{M}_{ij}$，计算$M=MST(H)$

注：MSF指的是最小生成森林，举个例子来说明这个概念，在一个最小生成树中有n−1条边，可以理解为是一个只有一棵树的最小生成森林。同理，在同一个图中也存在有两棵树、三棵树的最小生成森林，只要这个森林是 min ⁡ { ∑ ( u , v ) ∈ F o r e s t w ( u , v ) } \min\{\sum_{(u,v)\in Forest}w(u,v)\} min{∑(u,v)∈Forest​w(u,v)}就可以。

本质上讲，算法的本质就是先在局部算好生成树，然后用剩余的连接这些生成树的边组成一个新的图，并求出这个新的图的最小生成树作为最总的结果。

MR算法

• Map：input:<(u,v),NULL>
  • 转化<(h(u),h(v));(u,v)>
  • 针对上述转化数据，如果h(u)=h(v)，则对所有j∈[1,k]，输出<(h(u),j);(u,v)>
• Reduce：input:<(i,j);Eij>
  • 令Mij=MSF(Gij)
  • 对Mij中的每条边e=(u,v)输出<NULL;(u,v)>
• Map：nothing（identity）
• Reduce：M=MST(H)

其中h是哈希函数，可以用一个取值均匀的随机算法实现（ps：用随机算法生成哈希表，而不是每次运行都随机取值）。

当然在划分时还要考虑各个计算节点的负载均衡问题。

4 外存模型算法

4.1 外存模型

外存模型

到目前为止，按照存储模型，我们学过的算法模型应该分为两种：一种是RAM模型，也就是我们常用的算法的设计模型，另一种是I/O模型，内存比数据量小，外存是无限的。

外存访问与内存访问有一些差异：

• 与外存相比，内存的速度更快
• 外存的连续访问比随机访问代价小，也就是说：以块(block)为单位访问

基于外存模型的基本问题

在I/O模型中，内存的大小为M，页面大小为B，外存大小无限，页面大小为B。

连续读取外存上的N个数据，需要O(N/B)次I/O

如何计算矩阵乘法？

输入两个大小为N×N的矩阵X和Y

1. 将矩阵分为大小为$\sqrt{M}/2\times \sqrt{M}/2$的块
2. 考虑X×Y矩阵中的每个块，显然共有$O((\frac{N}{\sqrt{M}}{)}^2)$个块需要输出
3. 每个块需要扫描$\frac{N}{\sqrt{M}}$对输入块
4. 每次内存计算需要O(M/B)次I/O
5. 共计$O((\frac{N}{\sqrt{M}}{)}^3\cdot M/B)$次I/O

链表

进行三种操作：insert(x,p),remove§,traverse(p,k)

内存模型下各个操作的时间复杂度：updateO(1)，traverseO(k)

在外存模型下，将一个链表中连续的元素放在一个大小为B的块中。同时，令每个块大小至少为B/2：

• remove：删除后如果小于B/2，与邻接的块合并，合并后如果大于B，则平均划分
• insert：插入后如果大于B，则平均划分
• traverse：O(2k/B)

搜索结构

进行三种操作：insert(x),remove(x),query(x)

$(a,b)-tree:2\le a\le (b+1)/2$

类似二分查找树$\Rightarrow (p_0,k_1,...,k_c,p_c)$

root节点有0个或者≥2个孩子；除了root，每个非叶子节点的孩子数目∈[a,b]：

• remove：找到对应叶子节点，删除后如果小于a，与邻接的块合并，合并后如果大于b，平均划分，进而在上一层递归删除节点或者调整键值
• insert：找到对应叶子节点，插入后如果大于b，平均划分，递归向上一层插入
• $query:O(lo{g}_a(N/a))$

4.2 外存排序

外存排序问题

考虑外存排序算法的时候要与外存模型紧密地结合起来。

算法

• 给定N个数据，将其分成大小为O(M)的组
• 每一组数据可以在内存排序
• 将每一组数据从外存读进来需要O(M/B)次I/O
• 对所有分组进行以上操作，于是每个分组内部都是已经排好序的数据
• 对这些排好序的分组进行多路归并排序
• 每次可以归并O(M/B)个分组

过程解释

首先需要明白的一点是从外存向内存转移数据的时候，一次只能转移B的数据量。于是，要想一次把内存读慢，相应的I/O次数就是O(M/B)。另外进行多路归并排序时，至多可以归并多少分组。从每个分组读出来一个页面，然后进行排序，所以这里跟每个分组的大小没有关系，只跟内存的大小有关，所以是O(M/B)。

图示

评价

时间复杂度分为两个部分，一个是分组内排序，另一个是分组间归并排序。

1. 对于分组内排序，只需要将每个分组的数据读入内存即可，这部分对应的时间复杂度为$O(N/B)$。
2. 对于归并排序，相应的时间代价应该是每一趟归并的开销之和，而每一趟归并都需要把所有数据都导入到内存中一次，这个时间代价为$O(N/B)$。而归并的趟数可以表示为$O(lo{g}_{M/B}\frac{N}{B})$。综上所述：总的时间开销为：$O(N/B\cdot lo{g}_{M/B}\frac{N}{B})$

4.3 List Ranking

List Ranking

定义

[List Ranking Problem]：给定大小为N的邻接链表L，L存储在数组（连续的外存空间）中，计算每个节点的rank（在链表中的序号）。

[General List Ranking Problem]：给定大小为N的邻接链表L，L存储在数组（连续的外存空间）中，L中的每个节点v上存储权重$w_v$，计算每个节点v的rank（从头节点到v的权重和）

分析

• 如果合并链表上的子序列为一个节点（也就是页面内部合并，将一个页面当作一个节点），将权重和做为该节点的权重，不影响前后节点的rank 值。
• 如果链表大小至多为M，那么利用O(M/B)次I/O可解决这个问题，也就是将所有的数据都读入内存，使用内存算法解决这个问题。

我们通过一个图片来看一下对这个问题的直观理解，如下图所示，相关数据为：N=10,B=2,M=4。最坏的情况下访问代价为O(N)次I/O 。

算法

输入大小为N的外存链表L

1. 寻找L中的一个顶点独立集 X
2. 将X中的节点“跳过”，构建新的、更小的外存链表L′
3. 递归地求解L′
4. 将X中的节点“回填”，根据L′的rank构建L的rank

第1.1.4步骤都可以在$O(sort)=O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$次I/O求解，则构建如下递归方程：

$T(N)=T((1-\alpha )N)+O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$，解方程得：$T(N)=O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$

step~1

按照节点的ID顺序，分为forward(f)链表和backward(b)链表，将f链表按照red,blue间隔染色，将b链表按照green,blue间隔染色。注意这里的f链表和b链表指的是链表的一个连续段，该段内的数据的ID顺序关系要么全部与内存中的位置一致，要么正好相反。显然，一个链表中有多个f链表和b链表。

这一步的实现只需要进行一个外存排序即可实现，因此时间代价为$O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$。

step~2,4

1. $\tilde{L}=copy(L)$
2. 将链表L按照后继节点的地址排序，排序的同时进行如下操作
   1. 在step~2，将后继节点属于X的节点指针和权重重写
   2. 在step~4，将后继节点属于X的节点指针和权重重写，将属于X的节点权重重写
      存，使用内存算法解决这个问题。

我们通过一个图片来看一下对这个问题的直观理解，如下图所示，相关数据为：N=10,B=2,M=4。最坏的情况下访问代价为O(N)次I/O 。

算法

输入大小为N的外存链表L

1. 寻找L中的一个顶点独立集 X
2. 将X中的节点“跳过”，构建新的、更小的外存链表L′
3. 递归地求解L′
4. 将X中的节点“回填”，根据L′的rank构建L的rank

第1.1.4步骤都可以在$O(sort)=O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$次I/O求解，则构建如下递归方程：

$T(N)=T((1-\alpha )N)+O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$，解方程得：$T(N)=O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$

step~1

按照节点的ID顺序，分为forward(f)链表和backward(b)链表，将f链表按照red,blue间隔染色，将b链表按照green,blue间隔染色。注意这里的f链表和b链表指的是链表的一个连续段，该段内的数据的ID顺序关系要么全部与内存中的位置一致，要么正好相反。显然，一个链表中有多个f链表和b链表。

这一步的实现只需要进行一个外存排序即可实现，因此时间代价为$O(\frac{N}{B}lo{g}_{\frac{M}{B}}\frac{N}{B})$。

step~2,4

1. $\tilde{L}=copy(L)$
2. 将链表L按照后继节点的地址排序，排序的同时进行如下操作
   1. 在step~2，将后继节点属于X的节点指针和权重重写
   2. 在step~4，将后继节点属于X的节点指针和权重重写，将属于X的节点权重重写
3. 将L重新按照地址排序