《算法導論》讀書筆記之第15章 動態規划—最優二叉查找樹

　　1、前言：

　　接着學習動態規划方法，最優二叉查找樹問題。二叉查找樹參考http://www.cnblogs.com/Anker/archive/2013/01/28/2880581.html。如果在二叉樹中查找元素不考慮概率及查找不成功的情況下，可以采用紅黑樹或者平衡二叉樹來搜索，這樣可以在O(lgn)時間內完成。而現實生活中，查找的關鍵字是有一定的概率的，就是說有的關鍵字可能經常被搜索，而有的很少被搜索，而且搜索的關鍵字可能不存在，為此需要根據關鍵字出現的概率構建一個二叉樹。比如中文輸入法字庫中各詞條（單字、詞組等）的先驗概率，針對用戶習慣可以自動調整詞頻——所謂動態調頻、高頻先現原則，以減少用戶翻查次數，使得經常用的詞匯被放置在前面，這樣就能有效地加快查找速度。這就是最優二叉樹所要解決的問題。

2、問題描述

　   給定一個由n個互異的關鍵字組成的有序序列K={k₁<k₂<k₃<,……,<k_n}和它們被查詢的概率P={p₁,p₂,p₃,……,p_n}，要求構造一棵二叉查找樹T，使得查詢所有元素的總的代價最小。對於一個搜索樹，當搜索的元素在樹內時，表示搜索成功。當不在樹內時，表示搜索失敗，用一個“虛葉子節點”來標示搜索失敗的情況，因此需要n+1個虛葉子節點{d₀<d₁<……<d_n}，對於應d_i的概率序列是Q={q₀,q₁,……,q_n}。其中d₀表示搜索元素小於k₁的失敗結果，d_n表示搜索元素大於k_n的失敗情況。d_i（0<i<n）表示搜索節點在k_i和k_(i+1)之間時的失敗情況。因此有如下公式：

　　由每個關鍵字和每個虛擬鍵被搜索的概率，可以確定在一棵給定的二叉查找樹T內一次搜索的期望代價。設一次搜索的實際代價為檢查的節點個數，即在T內搜索所發現的節點的深度加上1。所以在T內一次搜索的期望代價為：

需要注意的是：一棵最優二叉查找樹不一定是一棵整體高度最小的樹，也不一定總是把最大概率的關鍵字放在根部。

（3）動態規划求解過程

1）最優二叉查找樹的結構

　　如果一棵最優二叉查找樹T有一棵包含關鍵字k_i，……，k_j的子樹T'，那么這棵子樹T’對於對於關鍵字k_i，……k_j和虛擬鍵d_i-1，……，d_j的子問題也必定是最優的。

2）一個遞歸解

　　定義e[i,j]為搜索一棵包含關鍵字ki，……，kj的最優二叉查找樹的期望代價，則分類討論如下：

當j=i-1時，說明此時只有虛擬鍵d_i-1，故e[i,i-1] = q_i-1

當j≥i時，需要從k_i，……，k_j中選擇一個跟k_r，然后用關鍵字k_i，……，k_r-1來構造一棵最優二叉查找樹作為左子樹，用關鍵字k_r+1，……，k_j來構造一棵最優二叉查找樹作為右子樹。定義一棵有關鍵字k_i，……，k_j的子樹，定義概率的總和為：

因此如果k_r是一棵包含關鍵字k_i，……，k_j的最優子樹的根，則有：

 

故e[i,j]重寫為：

最終的遞歸式如下：

3）計算一棵最優二叉查找樹的期望搜索代價

　　將e[i,j]的值保存到一個二維數組e[1..1+n,0..n]中，用root[i,j]來記錄關鍵字ki，……，kj的子樹的根，采用二維數組root[1..n,1..n]來表示。為了提高效率，防止重復計算，需要個二維數組w[1..n+1,0...n]來保存w(i,j)的值，其中w[i,j] = w[i,j-1]+p_j+q_j。數組給出了計算過程的偽代碼：

OPTIMAL_BST(p,q,n)
    for i=1 to n+1    //初始化e和w的值
       do e[i,i-1] = qi-1;
          w[i,i-1] = qi-1;
     for l=1 to n
        do for i=1 to n-l+1
                  do j=i+l-1;
                       e[i,j] = MAX;
                       w[i,j] = w[i,j-1]+pj+qj;
                       for r=i to j
                               do t=e[i,r-1]+e[r+1,j]+w[i,j]
                                    if t<e[i,j]
                                         then e[i,j] = t;
                                              root[i,j] = r;
return e and root;

4）構造一棵最優二叉查找樹

　　根據地第三步中得到的root表，可以遞推出各個子樹的根，從而可以構建出一棵最優二叉查找樹。從root[1,n]開始向下遞推，一次找出樹根，及左子樹和右子樹。

4、編程實現

　　針對一個具體的實例編程實現，現在有5個關鍵字，其出現的概率P={0.15，0.10，0.05，0.10，0.20}，查找虛擬鍵的概率q={0.05，0.10，0.05，0.05，0.05，0.10}。采用C++語言是實現如下：

#include <iostream>
 using namespace std;
 #define N 5
 #define MAX 999999.99999
 void optimal_binary_search_tree(float *p,float *q,int n,float e[N+2][N+1],int root[N+1][N+1]);
 void construct_optimal_bst1(int root[N+1][N+1],int i,int j);
 void construct_optimal_bst2(int root[N+1][N+1],int i,int j);
 int main()
 {
     float p[N+1] = {0,0.15,0.10,0.05,0.10,0.20};
     float q[N+1] = {0.05,0.10,0.05,0.05,0.05,0.10};
     float e[N+2][N+1];
     int root[N+1][N+1];
     int i,j;
     optimal_binary_search_tree(p,q,N,e,root);
     cout<<"各個子樹的期望代價如下所示："<<endl;
     for(i=1;i<=N+1;i++)
     {
         for(j=i-1;j<=N;j++)
             cout<<e[i][j]<<" ";
         cout<<endl;
     }
     cout<<"最優二叉查找樹的代價為: "<<e[1][N]<<endl;
     cout<<"各個子樹根如下表所示："<<endl;
     for(i=1;i<=N;i++)
     {
         for(j=i;j<=N;j++)
             cout<<root[i][j]<<" ";
         cout<<endl;
     }
     cout<<"構造的最優二叉查找樹如下所示："<<endl;
     construct_optimal_bst1(root,1,N);
     cout<<"\n最優二叉查找樹的結構描述如下："<<endl;
     construct_optimal_bst2(root,1,N);
     cout<<endl;
     return 0;
 }
 void optimal_binary_search_tree(float *p,float *q,int n,float e[N+2][N+1],int root[N+1][N+1])
 {
     int i,j,k,r;
     float t;
     float w[N+2][N+1];
     for(i=1;i<=N+1;++i) //主表和根表元素的初始化
     {
         e[i][i-1] = q[i-1];
         w[i][i-1] = q[i-1];
     }
     for(k=1;k<=n;++k)  //自底向上尋找最優子樹
         for(i=1;i<=n-k+1;i++)
         {
             j = i+k-1;
             e[i][j] = MAX;
             w[i][j] = w[i][j-1]+p[j]+q[j];

             for(r=i;r<=j;r++) //找最優根
             {
                 t = e[i][r-1] + e[r+1][j] +w[i][j];

                 if(t < e[i][j])
                 {
                     e[i][j] = t;
                     root[i][j] = r;
                 }
             }
         }
 }
 void construct_optimal_bst1(int root[N+1][N+1],int i,int j)
 {

     if(i<=j)
     {
         int r = root[i][j];
         cout<<r<<" ";
         construct_optimal_bst1(root,i,r-1);
         construct_optimal_bst1(root,r+1,j);
     }
 }
 void construct_optimal_bst2(int root[N+1][N+1],int i,int j)
 {
      if(i==1 && j== N)
         cout<<"k"<<root[1][N]<<"是根"<<endl;
      if(i<j)
      {
          int r = root[i][j];
          if(r != i)
            cout<<"k"<<root[i][r-1]<<"是k"<<r<<"的左孩子"<<endl;
          construct_optimal_bst2(root,i,r-1);
          if(r!= j)
            cout<<"k"<<root[r+1][j]<<"是k"<<r<<"的右孩子"<<endl;
          construct_optimal_bst2(root,r+1,j);
      }
      if(i==j)
      {
          cout<<"d"<<i-1<<"是k"<<i<<"左孩子"<<endl;
          cout<<"d"<<i<<"是k"<<i<<"右孩子"<<endl;
      }
      if(i>j)
          cout<<"d"<<j<<"是k"<<j<<"右孩子"<<endl;
 }

程序測試結果如下所示：

參考資料：http://www.cnblogs.com/lpshou/archive/2012/04/26/2470914.html