分治,动态规划,回溯和分支限界法

introduction

• the master method

T(n) = aT(n/b)+f(n)<其中a>=1,b>1,f(n)为渐近正函数>  
f(n) = O(nlogba-ε),T(n)=O(nlogba)  
f(n) = O(nlogba\*logkn),T(n)=O(f(n)\*logn)  
f(n) = O(nlogba+ε),T(n)=O(f(n))

divide and conquer

• Tower of Hanoi

  • code

     hanoi(n-1,A,C,B);
     move(n,A,B);
     hanoi(n-1,C,B,A);
    

  • time complexity:

    M(1)=1
    M(n)=2M(n-1)+1=2[2M(n-2)+1]+1=2ⁿ-1
    O(n)=2ⁿ

• MergeSort

  • recursion

       mergesort(left,right,**a){
           if(left

  • nonrecursion

     void merge_sort(int *list, int length){
         int i, left_min, left_max, right_min, right_max, next;
    
         int *tmp = (int*)malloc(sizeof(int) * length);
    
         for(i=1;ilength){
                 right_max = length;
             }
    
             next = 0;
             while(left_minlist[right_min]?
                 list[right_min++]:list[left_min++];
             }
             while(left_min < left_max){
                 list[--right_min] = list[--left_max];
             }
             while(next>0){
                 list[--right_min] = tmp[--next];
             }
         }
     }
    

  • time complexity:

    T(n)=2T(n/2)+cn
    O(nlogn)

  • space complexity:

    O(n)

• Strassen’s matrix multiplication

  • the divide and conquer of matrix

    T(n) = 8(T(n/2))+O(n2)  

• QuickSort

  • code

      int Partition(Type a[],int p,int r){
          int j=p;
          int j=r+1;
          Type x=a[p];
          while(true){
              while(a[++i]x&&i

  • time complexity:

    Best case: split in the middle — Θ(nlogn)
    Worst case: sorted array! — Θ( n²)
    Average case: random arrays — Θ(nlogn)

• linear time selection

  • 只要不是选到了首尾,O(n)

Dynamic Programming

• Fibonacci series

 + ![](/Users/za/Desktop/doc/斐波那契数列通项公式.png)

• Matrix-chain Multiplication

  • code

     void MatrixChain(){
         int p[6] = {20,25,10,5,15,20};
         int n = 5;
         int m[10][10];
         int s[10][10];
         int j = 0;
         for (int i=1; i<=n; i++){
             m[i][i]=0;
         };//单个矩阵的计算量
         for (int r=2; r<=n; r++){//r为每次循环矩阵链的长度
             for (int i=1; i<=n-r+1; i++){
                 j=i+r-1;
                 //设置初始值为从第一个元素进行断开
                 m[i][j]= m[i+1][j] + p[i-1]*p[i]*p[j];
                 //设置初始断开位置
                 s[i][j]=i;
                 for (int k=i+1; k

  • analysis

    • 分析最优解结构:M(1,n)=M(1,k)+M(k+1,n)+P₀P_kP_n
      (P₀P_kP_n类型为两个矩阵相乘所需的计算步骤)
    • 1.初始化矩阵链的对角线位置元素 M[a][a]=0
    • 2.确定矩阵链长度 for(r=2;r
    • 3.用i表示起始位置,j表示终止位置 for(i=1;i
    • 4.M(i,j)=M(i,k)+M(k+1,j)+P_iP_jP_k,循环k的值for(k=i+1;k→找到最大值,并将k的值记录下来,存储到**t中

• 0-1 Knapsack Problem

  • code

     void KnapSack(){
         int w[4] = {2,1,3,2};//物品重量
         int v[4] = {12,10,20,15};//物品价值
         int c = 5;//背包容量
         int n = 4;//物品个数
         int m[c][n];//初始化矩阵
         int jMax = 0;
         if(w[n]-1>c){
             jMax=c;
         }else{
             jMax=w[n]-1;
         }
         //使刚开始到最小容量的值直接为0
         for(int j=0;j<=jMax;j++){
             m[n][j] = 0;
         }
         for (int j=w[n]; j1; i--) {
             jMax = min(w[i]-1,c);
             //装不下第i个物品的,直接继承i+1的值
             for(int j=0; j<=jMax; j++){
                m[i][j] = m[i+1][j];
             }
             for(int j=w[i];j<=c;j++){
                m[i][j] = max(m[i+1][j],m[i+1][j-w[i]+v[i]);
             }
         }
         //最后的结果行不用计算之前复杂项了    
         m[1][c] = m[2][c];
         if(c>=w[1]){
                 m[1][c]=max(m[1][c],m[2][c-w[1]]+v[1]);
         }
     }
     
     //判断i和i+1的值相等否可以得出是否放了这个物品
     Template
     Void Traceback(Type **m,int w,int c,int n,int x)
     {
        for(int i=1;i

  • analysis

    • m[i][j] = max(m[i+1][j],m[i+1][j-w[i]+v[i]]);
    • 判定m(i,c)与m(i+1,c)的值是否相等来确定x(i+1)是否为1;

• Optimal Binary Search Trees

  • binary search tree

  e[i,j] = min(e[i,r-1]+e[r+1,j]+w(i,j))

Greedy Algorithms

Backtracking

• Loading Problem

  • analysis

    按深度优先先进行一条线路的遍历,到达底部后重新回溯生成最优解,进行比较到最后生成最后的解

• 0-1 knapsack problem

  • analysis

    最优解的限界为装入尽可能多的物品,并且将最后一部分物品只装入部分产生的限界.

  • time complexity

    O(n2ⁿ)

  • Graph m coloring problem

Branch and bound(在约束条件下找出一个最优解)

• Loading Problem

  • code

     if(Ew+w[i]<=c){ 
        AddLiveNode(H,E,Ew+w[i]+r[i],true,i+1); 
     }
        AddLiveNode(H, E, Ew+r[i], false, i+1); 
        HeapNode N;
        H.DeletMax(N); 
        i = N.level;
        E = N.ptr;
        Ew = N. uweight – r[ i -1 ]; 
    

  • anlysis

    节点的左子树表示将此集装箱装上船，右子树表示不将此集装箱装上船。
    设bestw是当前最优解；Ew是当前扩展结点所相应的重量；r是剩余集装箱的重量。
    则当Ew+r≤bestw时，可将其右子树剪去，因为此时若要船装最多集装箱，就应该把此箱装上船。