分治策略

##Merge Sort##
输入：数组 A[p…r}
输出:元素从小到大排序的数组A

 1. if p<r
2.then q<-(p+r)/2的下界
 2. Merge Sort(A,p,q)
 3. Merge Sort(A,q+1,r)
 4. Merge(A,p,q,r)

列表内容

BinarySearch

input:排好序的数组T，数x
output：j

1.L<-1,.R<-n;
2.while L<=R do
3.  m=[(L+N)/2]下界
4.  if T[m]=x then return m;
5.  else if T[m]>x then  R<- m-1
6.  else L<- m+1;
7.return 0;

算法Hanoi（A,C,N)//n 个盘子A到C

1.if n==1 then move(A,C)
2.else Hanoi (A,B,N-1)
3.  move(A,C)
4.  Hanoi(B,C,N-1)

芯片测试

输入： N 片芯片，好芯片至少比坏芯片多1 片
设计一种方法挑出一片好的芯片，要求最小的测试次数

问题：A,判定A的好坏
方法：用 n-1的芯片对A测试
n为奇数，好芯片数>=(n+1)/2
A好，（n-1)/2报告好芯片
A坏，（n+1）/2报告“坏”

结论： 至少一半报好，A为好芯片
超过一半报坏，A为坏芯片

n 为偶数 n/2+1
A好， n/2 报好
A坏，n/2+1 报坏

蛮力算法
O(n²）
test（n）

1.k<-n
2.while  k>3_do
3. 芯片分成[k/2]下界组，//轮空处理
4.     for i=1 to [k/2]  do 
5.          if  两片好hen 任取一片
6.          else  2片同时丢掉  
7.     k<-剩下的芯片数
8. if k=3  then
9.    任取2片芯片测试
10.   if 1 好 1 坏then 取剩下的那个
11.  else 任取一片被测芯片
12.if k=2 or 1 then 任取1片

w（n)=w(n/2)+O(n)
w(3)=1,w(2)=w(1)=0;

w(n)=O(n);

快速排序

QuickSort(A,p,r)
输入：A[p…r]
输出：排序

1. if p<r 
2.  then q<- Partition (A,p,r)
3.          A[p]<-A[q]
4.          Quicksort (A,p,q-1)
5.          QuickSort(A,q+1,r)

Partition(A,p,r)
输入：数组A
输出：J,A的首元素在排好序的数组中

1.x<-A[P]
2.i<- p
3.j<- r+1
4.while true do
5.     repeat j<- j-1
6.     until    A[j]<=x
7.     repeat i<- i+1
8.     until     A[i]>=x
9.      if i<j
10.    then A[i]<->A[j]
11.    else  return j

w(n)=w(n-1)+n-1
w(n)=n(n-1)/2
最好的划分：T(n)=2T(n/2)+n-1
T(n)=紧的界（nlogn）

C 语言实现整个快速排序的过程

#include <stdio.h>
 int a[101],n;
void quicksort(int left,int right){
    int i,j,t,temp;
    if(left>right)
        return;

    temp=a[left];
    i=left;
    j=right;
    while(i!=j){
        while(a[j]>=temp && i<j)
            j--;
        while(a[i]<=temp && i<j)
            i++;

        if(i<j){
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }

    }
    a[left]=a[j];
    a[j]=temp;
    quicksort(left,j-1);
    quicksort(j+1,right);
    return;
}
int main (){
    int i,j;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
        scanf("%d",&a[i]);
    quicksort(1,n);
    for(i=1;i<=n;i++)
        printf("%d ",a[i]);

    return 0;
}

幂乘

w（n)=w(n/2)+紧的界（1）
w(n)=紧的界（log n)
Fibonacci数列
Fn=Fn-1+Fn-2
T(n)=紧的界（n）

M=[ 1 1
1 0] ,用乘幂算法计算法M^n;
T(n)=紧的界（log n）

减少子 问题的个数

W(n）=aW(n/b)+d(n)
a:子问题数，n/b：子问题规模
d（n)：划分与综合工作量
当a较大，b较小，d(n)不大时候，方程解：
W(n）=紧的界（n^logb a)
减少a是降低函数W（n）的jie的途径

for example 1： 整数位乘
输入：X,Y是n位二进制数，n=2^k
输出： XY
O（n^2)次位乘运算
划分：
X： A B
Y： C D
X=A*2^(n/2)+B;Y=C*2^(n/2)+D
X*Y=AC*2^(n)+(AD+BC)*2^(n/2)+BD;
W(n)=4W(n/2)+O(n)
W(n)=O(n²)；

AD+BC=(A-B)(D-C)+AC+BD
减少为三个子问题！
W(n）=3W(n/2)+cn
W(1)=1

W(n)=O(n^(log3);

例2： 矩阵相乘
分治后依旧为O(n^3)

利用Strassen矩阵乘法

W(n）=7W（n/2)+18(n/2)^2
W(1)=1
W(n）=O（n^log7)=O(n^2.8075)
上界O(n^2.376)
下界O（n^2)

适合用于子问题个数多，划分和综合工作量不大，时间复杂度W(n）=紧的界（n^(logb a))
综合解的工作量可能会增加，但增加的工作量不影响W（n）的阶；

增加预处理

例子：平面点对问题
C（n,2) ->O(n²）

分治：P划分为PL,PR
1.计算PL,PR中最近点对

2.计算PL和PR中各一个点的最近点对

3.上述情况中的最近点对是解

根据算法顺序 ：cbafde

324154为解的顺序