动态规划之--生成最优二叉查找树

1、概念引入

　　基于统计先验知识，我们可统计出一个数表（集合）中各元素的查找概率，理解为集合各元素的出现频率。比如中文输入法字库中各词条（单字、词组等）的先验概率，针对用户习惯可以自动调整词频——所谓动态调频、高频先现原则，以减少用户翻查次数。这就是最优二叉查找树问题：查找过程中键值比较次数最少，或者说希望用最少的键值比较次数找到每个关键码（键值）。为解决这样的问题，显然需要对集合的每个元素赋予一个特殊属性——查找概率。这样我们就需要构造一颗最优二叉查找树。

事实上：即使按照我们普遍的理解，最高频应该放到靠近树的上层的地方，但是其实这也不对

 

2、问题给出

　　n个键{a1,a2,a3......an},其相应的查找概率为{p1,p2,p3......pn}。构成最优BST,表示为T ₁ ⁿ ，求这棵树的平均查找次数C[1, n]（耗费最低)。换言之，如何构造这棵最优BST，使得C[1, n] 最小。

如何获得最小的期望

3、分段方法（递归定义最优的解方案）

　　 

　　　　动态规划法策略是将问题分成多个阶段，逐段推进计算， 后继实例解由其直接前趋实例解计算得到 。对于最优BST问题，利用减一技术和最优性原则，如果前n-1个节点构成最优BST，加入一个节点 an  后要求构成规模n的最优BST。按 n-1, n-2 , ... , 2, 1 递归，问题可解。自底向上计算：C[1, 2]→C[1, 3] →... →C[1, n]。为不失一般性用

C[i, j] 表示由{a1,a2,a3......an}构成的BST的耗费。其中1≤i ≤j ≤n。这棵树表示为Tij。从中选择一个键ak作根节点，它的左子树为Tik-1，右子树为Tk+1j。要求选择的k 使得整棵树的平均查找次数C[i, j]最小。左右子树递归执行此过程。（根的生成过程）

 4、递推计算式

 

5、基本算法如下

　　

1，问题描述：给定一个有序序列K={k1<k2<k3<,……,<kn}和他们被查询的概率P={p1,p2,p3,……,pn}，要求构造一棵二叉查找树T，使得查询所有元素的总的代价最小。对于一个搜索树，当搜索的元素在树内时，表示搜索成功。当不在树内时，表示搜索失败，用一个“虚叶子节点”来标示搜索失败的情况，因此需要n+1个虚叶子节点{d0<d1<……<dn}。其中d0表示搜索元素小于k1的失败结果，dn表示搜索元素大于kn的失败情况。di（0<i<n）表示搜索节点在ki和k(i+1)之间时的失败情况。对于应di的概率序列是Q={q0,q1,……,qn}。

2，问题分析：

在二叉树中T内搜索一次的期望代价为：

E[T]=

         (depth(ki)+1)*pi  //对每个i=1~n，搜索成功情况

       +(depth(di)+1)*qi //对每个i=0~n，搜索失败情况

3，问题求解：动态规划

步骤一：寻找最优子结构。

一个最优二叉树的子树必定包含连续范围的关键字ki~kj，1<=i<=j<=n，同时也必须含有连续的虚叶子节点di-1~dj。

如果一棵最优二叉查找树T有一棵含有关键字ki~kj的子树T'，那么，T'也是一棵最优查找树，这通过剪贴思想可以证明。

现在开始构造最优子结构：在ki~kj中，选定一个r,i<=r<=j，使以kr为根，ki~k(r-1)和k(r+1)~kj为左右孩子的最优二叉树。注意r=i或者r=j的情况，表示左子树或右子树只有虚叶子节点。

步骤二：一个递归解。

定义e[i,j]为一棵包含关键字ki~kj的最优二叉树的期望代价。当j=i-1时没有真实的关键在，只有虚叶子节点d(i-1)。

于是：

当j=i-1时，e[i,i-1]=q(i-1)。

当j>=i时，需要选择合适的kr作为根节点，然后其余节点ki~K(r-1)和k(r+1)~kj构造左右孩子。这时要考虑左右孩子这些节点成为一个节点的子树后，它的搜索代价的变化：根据E[T]的计算，得知它们的期望代价增加了“子树中所有概率的总和”w。

w[i,j]=

          pl // 对每个l=i~j

        +ql //对每个l=i-1~j

于是当j>=i时，e[i,j]=pr + (e[i,r-1]+w[i,r-1])+(e[r+1,j]+w[r+1,j]) = e[i,r-1] + e[r+1,j]+w[i,j];

步骤三：计算最优二叉树的期望代价

e[i,j]=

          q(i-1)  //如果j=i-1

          min(e[i,r-1] + e[r+1,j]+w[i,j]),如果i<=j，其中i<=r<=j

w[i,j] =

           q(i-1) 如果j=i-1

            w[i,j]=w[i,j-1]+pj+qj 如果i<=j

实现代码如下：

view plaincopy to clipboardprint?
1 #include <iostream>   
2 using namespace std;   
3    
4 #define MAXNUM 100   
5 #define MAX 65536   
6 //p中为有序关键字k1到k5的搜索概率，k1<k2<k3<k4<k5   
7 double p[MAXNUM] = {0.00,0.15,0.10,0.05,0.10,0.20};   
8 double q[MAXNUM] = {0.05,0.10,0.05,0.05,0.05,0.10};   
9 void optimal_bst(double e[][MAXNUM],int root[][MAXNUM],double w[][MAXNUM],int n)   
10 {   
11         int i =0,j=0;   
12         //针对左或右孩子为空树情况初始化   
13         for(i = 1;i<=n+1;i++)   
14         {   
15                 e[i][i-1] = q[i-1];   
16                 w[i][i-1] = q[i-1];   
17         }   
18         int l = 0;   
19         //计算顺序如下：根据计算式：e[i,j] = e[i,r-1]+e[r+1,j   
             首先计算节点个数为1的最优二叉树的代价e[1,1],e[2,2]……   
             接着计算节点个数为1的最优二叉树的代价e[1,2],e[2,3]……   
             ……   
             最后计算结点个数为n的最优二叉树的代价e[1,n]，利用之前保存的较少结点最优二叉树的结果。   
20         for(l = 1;l<=n;l++)   
21         {   
22                 for(i = 1;i<=n-l+1;i++)   
23                 {   
24                         j = i+l-1;   
25                         e[i][j] = MAX;   
26                         w[i][j] = w[i][j-1] + p[j]+q[j];   
27                         for(int r = i;r<=j;r++)   
28                         {   
29                                 double t = 0;   
30                                 t = e[i][r-1]+e[r+1][j] + w[i][j];   
31                                 if(t<e[i][j])   
32                                 {   
33                                         e[i][j]= t;   
34                                         root[i][j] = r;   
35                                 }   
36                         }   
37    
38                 }   
39         }   
40    
41 }   
42 int main()   
43 {   
44         double e[MAXNUM][MAXNUM];   
45         int root[MAXNUM][MAXNUM];   
46         double w[MAXNUM][MAXNUM];   
47    
48         optimal_bst(e,root,w,5);   
49    
50         for(int i =1;i<=6;i++)   
51         {   
52                 for(int j = 0;j<=5;j++)   
53                 {   
54                         cout << e[i][j] << "  ";   
55                 }   
56                 cout << endl;   
57         }   
58 }  

核心依然是从底部向上构造。。