国科大计算机算法刘玉贵第三章分治算法笔记

基本思想

将规模为n的问题规约为规模减小的一个或多个子问题，分别求解每个子问题，然后把子问题的解综合，得到原问题的解。

Divide-and-conquer(p)
if |p|≤c then S(p)     //S(p)代表直接求解
  divide p into p1,p2,…pk
    for i=1 to k do 
      yi=divide-and-conque(pi)    //递归求解每个子问题
    end{for}
end{if}
Return Merge(y1,y2,…,yk)    //把子问题的解进行综合

二分查找/折半搜索

 proc BiFind(a,n) 
 //在数组 a[1..n]中搜索 x，数组中的元素满足 a[1] ≤ a[2] ≤ … ≤ a[n]。如果找到 x，则返回所在位置（数组元素的下标），否则返回 –1 
    global a[1..n], n; 
    integer left,right,middle; 
    left:=1; right:=n; 
    while left ≤ right do 
      middle:=(left+right)/2; 
      if x=a[middle] then return(middle); 
      end{if} 
      if x>a[middle] then left:=middle+1; 
      else right:=middle-1; 
      end{if} 
    end{while} 
 return(–1); //未找到 x 
end{BiFind} 

复杂度分析

$$\{\begin{array}{c}T(n)=T\left(\lfloor \frac{n}{2}\rfloor \right)+1\\ T(1)=1\end{array}$$

设n=2^k，T(n)= T(n/2)+1 =T(n/4)+2=T(n/8)+3 =… =T(1)+k=1+logn=Θ(logn)

若用一一比较的算法，则T(n)=O(n)

查找最大最小

MaxMin(i,j,fmax,fmin) 
//A[1:n]是n元数组，参数i，j ：1≤i≤j≤n,使用该过程将数组A[i..j]中的最大最小元分别赋给fmax和fmin。
      global n, A[1..n]; 
      integer i, j;
      if i=j then   
         fmax:=A[i]; fmin:=A[i]; //子数组A[i..j]中只有一个元素
      elseif i=j-1 then //子数组A[i..j]中只有两个元素
         if A[i]<A[j] then
         fmin:=A[i]; fmax:=A[j]；
         else fmin:=A[j]; fmax:=A[i];
         end{if}
      else   //子数组A[i..j]中的元素多于两个
        mid:=⌊(i+j)/2⌋; 
        MaxMin(i, mid, lmax, lmin);//递归
        MaxMin(mid+1, j, rmax, rmin);//递归
        fmax:=max(lmax, rmax)；
        fmin:=min(lmin, rmin)；
      end{if}
     end{MaxMin} 

复杂度分析

$$\mathrm{T}(n)=\{\begin{array}{lc}0& n=1\\ 1& n=2\\ T(\lceil n/2\rceil )+T(\lfloor n/2\rfloor )+2& n>2\end{array}$$

设n=2^k，T(n)=2T(n/2)+2=4T(n/4)+4+2=2k-1+2k-2=3n/2-2

若用一一比较的算法，则T(n)=2(n-1)

排序算法

插入排序

proc InSort(a, n)
//对 a[1..n]进行插入排序
for i from 2 to n do//将a[i]插入a[1..i-1]
   x:=a[i];   integer j;
   for j from i-1 by -1 to 1 do 
     if x<a[j] then a[j+1]:=a[j]; //更小值向后移位
     end{if}
   end{for}
   a[j+1]:=x;//插入更大值之后
end{for}
end{InSort}

T(n)=1+2+…+(n-1) =n(n-1)/2=Θ(n²)

归并排序

proc MergeSort(low, high)
 // A[low .. high]是一个全程数组，含有 high-low+1个待排序的元素。
integer  low, high;
if  low < high  then
       mid:= ⌊(low+high)/2⌋  //求当前数组的分割点
       MergeSort(low, mid)  //将第一子数组排序
       MergeSort(mid+1, high)  //将第二子数组排序
       Merge(low, mid, high)  //归并两个已经排序的子数组
end{if}
end{MergeSort} 

proc Merge(low, mid, high) //已知全程数组 A[low .. high], 其由两部分已经排好序的子数组构成：A[low .. mid]和 A[mid+1 .. high]。本程序的任务是将这两部分子数组合并成一个整体排好序的数组，再存于数组 A[low .. high]. 
integer h, i, j, k, low, mid, high; 
global A[low .. high];  
local B[low .. high]; //借用临时数组 B 
h:=low, i:=low, j:=mid+1;  
 // h, j 是拣取游标, i 是向 B 存放元素的游标 
while h≤mid and j≤high do  //当两个集合都没有取尽时 
    if A[h]≤A[j] then B[i]:=A[h], h:=h+1; 
    else B[i]:=A[j], j:=j+1; 
    end{if} 
      i:＝i+1; 
end{while} 
if h>mid then  //当第一子组元素被取尽，而第二组元素未被取尽时 
  for k from j to high do 
     B[i]:=A[k]; i:=i+1; 
  end{for} 
else //当第二子组元素被取尽，而第一组元素未被取尽时 
  for k from h to mid do 
          B[i]:=A[k]; i:=i+1; 
  end{for} 
end{if} 
 //将临时数组 B 中元素再赋给数组 A 
for k from low to high do  
     A[k]:=B[k]; 
end{for} 
end{Merge} 

时间复杂度

$$T(n)=\{\begin{array}{ll}a& n=1\\ 2T(n/2)+cn& n>1\end{array}$$

令n=2^k ,

$$\begin{array}{rl}T(n)& =2(2T(n/4)+cn/2)+cn\\ & =4T(n/4)+2cn\\ & \cdots \cdots \\ & =2^{k}T(1)+kcn\\ & =an+cn\log n\end{array}$$

当2^k < n ≤ 2^k +1^ ，T (n) = O(nlogn)

快速排序

算法思想：将A[1…n]划分成B[1…p]和B[p+1…n]，使得B[1…p]中的元素均不大于B[p+1…n]中的元素，然后分别对它们排序，最后接起来即可。

首元素划分：选定A中的首元素，将A中的所有元素与之比较，小于等于的元素构成B[1…p]，大于的元素构成B[p+1…n]。

快速排序算法：

proc QuickSort(p,q) //将数组A[1..n]中的元素A[p], A[p+1], ... , A[q] 按不降次序排列，并假定A[n+1]是一个确定数，且大于A[1..n]中所有的数。划分后j成为划分元素的位置。

        integer p,q; 
        global n, A[1..n];
       if p<q then
         j:=q+1;//保持对称性
         Partition(p,j); //首元素划分
         QuickSort(p,j-1); 
         QuickSort(j+1,q); 
       end{if}
      end{QuickSort}

最坏复杂度T(n)=T(n-1)+n-1=T(n-2)+n-2+n-1=1+2+…+n-1=(n-1)(n-2)/2=O(n²)

首元素划分算法：

proc Partition(m,p) 
// 用首元素划分数组A[m,p-1]，划分后首元素放中间。
integer m, p, i;  
global A[m ..p-1]; 
v:=A[m]; i:=m; 
loop 
     loop i:=i+1; until A[i]>v; end{loop} //自左向右查 
     loop p:=p-1; until A[p]≤v; end{loop} //自右向左查 
     if i<p then 
       Swap(A[i],A[p]); //交换 A[i]和 A[p]的位置 
     else go to *； 
     end{if} 
end{loop} 
*: A[m]:=A[p]; A[p]:= v; // 划分元素在位置 p 
end{Partition}

平均复杂度T(n) = 2(n+1)logn=O(nlogn)

选择问题

问题描述：确定数组A[1…n]的第k小元素。

若使用某种排序算法将A按不降次序排序，从排好序的数组中检出第k个元素。最坏时间复杂度O(nlogn)

划分法

proc PartSelect(A, n, k) //在数组 A[1..n]中找第 k 小元素 t，并将其存放于位置 k，即 A[k]=t。而剩下的元素按着以 t 为划分元素的划分规则存放。再令 A[n+1]=+∞. 
 integer n, k, m, r, j; 
 m:=1; r:=n+1; A[n+1]:= +∞； 
 loop 
   j:=r; 
   Partition(m,j);  
   case 
      k=j : return // 返回 j,当前数组的元素 A[j]是第 j 小元素 
      k<j : r:=j; // j 是新的下标上界 
      else : m:=j+1; k:=k-j; //j+1 是新的下标下界 
   end{case} 
end{loop} 
end{PartSelect}

矩阵乘法

矩阵加法和乘法

假定 A, B 都是 n×n 矩阵，它们的 i 行 j 列元素分别记为 A(i,j)和 B(i,j)。
如果用 S 和 C 分别记 A+B 和 A*B, 则有

$$\begin{array}{lc}S(i,j)=A(i,j)+B(i,j)& 1\le i,j\le n\\ C(i,j)={\sum }_{k=1}^{n}A(i,k)\ast B(k,j)& 1\le i,j\le n\end{array}$$

可见，矩阵加法运算的时间复杂度是 Θ(n²) ，而矩阵乘法的时间复杂度是 Θ(n³)

分块矩阵乘法

设n=2^k,将A、B各分为4个n/2阶矩阵

$$T(n)=\{\begin{array}{ll}b& n\le 2\\ 8T(n/2)+d{n}^2& n>2\end{array}$$

$$T(n)=b{n}^3/8+4d\left(n^2-16\right)/3=\Theta (n^3)$$

Strassen矩阵乘法

$$\begin{array}{l}P=\left(A_{11}+A_{22}\right)\left(B_{11}+B_{22}\right)\\ Q=\left(A_{21}+A_{22}\right)B_{11}\\ R=A_{11}\left(B_{12}-B_{22}\right)\\ S=A_{22}\left(B_{21}-B_{11}\right)\\ T=\left(A_{11}+A_{12}\right)B_{22}\\ U=\left(A_{21}-A_{11}\right)\left(B_{11}+B_{12}\right)\\ V=\left(A_{12}-A_{22}\right)\left(B_{21}+B_{22}\right)\\ C_{11}=P+S-T+V\\ C_{12}=R+T\\ C_{21}=Q+S\\ C_{22}=P+R-Q+U\end{array}$$

$$T(n)=\{\begin{array}{ll}b& n\le 2\\ 7T(n/2)+a{n}^2& n>2\end{array}=\Theta (n^{2.81})$$

快速Fourier变换

N 个数据的离散 Fourier 变换

$$A_j=\sum _{0\le k\le N-1}{a}_k{e}^{2\pi ijk/N},0\le j$$

令$\omega =e^{2\pi i/N}$,相当于计算多项式$a(x)={\sum }_{0\le k\le N-1}{a}_k{x}^k$在${\omega }^j$处的值。T(N)=N*2(N-1)

采用分治算法，将求 N = 2n 个数据的 Fourier 变换归结为求两次具有 n 个数据的 Fourier 变换。

$$\begin{array}{l}b(x)=a_1+a_{3}x+a_5{x}^2+\dots +a_{N-1}{x}^{(N-2)/2}\\ c(x)=a_0+a_{2}x+a_4{x}^2+\dots +a_{N-2}{x}^{(N-2)/2}\end{array}$$

$$a(x)=b\left(x^2\right)x+c\left(x^2\right)$$

$$\begin{array}{l}a\left({\omega }^j\right)=b\left({\omega }^{2j}\right){\omega }^j+c\left({\omega }^{2j}\right)\\ a\left({\omega }^{j+n}\right)=-b\left({\omega }^{2j}\right){\omega }^j+c\left({\omega }^{2j}\right)\end{array},j=0,1,\cdots ,n-1$$

时间复杂度

$$T(N)=\{\begin{array}{l}a,\text{ if }N=1\\ 2T(N/2)+cN,\text{ if }N>1\end{array}=O(NlogN)$$

Proc FFT(N,a,w,A)
//N=2n,w是n次单位根，a是已知的N元数组，代表多项式a(x)的系数，A是计算出来的N元数组，A[j]=a(w^j), j=0,1,…,N-1.
 real b[ ], c[ ];  int j;
 complex B[ ], C[ ], wp[ ];
 if  N=1 then A[0]:=a[0]; 
 else 
       n:=N/2;
       for j from 0 to n-1 do
         b[j]:=a[2*j+1];  c[j]:=a[2*j];
       end{for}
 end{if}
 FFT(n,b,w*w,B);
 FFT(n,c,w*w,C);
 wp[0]:=1; 
for j from 0 to n-1 do
      wp[j+1]:=w*wp[j]; 
      A[j]:= C[j]+B[j]*wp[j]; 
      A[j+n]:= C[j]-B[j]*wp[j];  
  end{for}
end{FFT} 

分治算法中常见的递归方程

$$T(n)=\sum _{i=1}^k{a}_{i}T(n-i)+f(n)$$

可用迭代求解、递归树分析求解

$$T(n)=aT(n/b)+f(n)$$

可用主定理分析:

设a≥1,b >1为常数，f(n)为函数，T(n)为非负整数，且

$$T(n)=aT(n/b)+f(n),c=\log b^a$$

则有

$$T\left(n\right)=\{\begin{array}{cc}\begin{array}{l}\Theta \left(n^c\right)\\ \Theta \left(n^c\log n\right)\\ \Theta \left(f\left(n\right)\right)\end{array}& \begin{array}{l}f\left(n\right)=O\left(n^{c-\epsilon }\right)\\ f\left(n\right)=\Theta \left(n^c\right)\\ f\left(n\right)=\Omega \left(n^{c+\epsilon }\right)\end{array}\end{array}$$