(depth(ki)+1)*pi //对每个i=1~n，搜索成功情况
+(depth(di)+1)*qi //对每个i=0~n，搜索失败情况
一个最优二叉树的子树必定包含连续范围的关键字ki~kj，1<=i<=j<=n，同时也必须含有连续的虚叶子节点di-1~dj。
如果一棵最优二叉查找树T有一棵含有关键字ki~kj的子树T'，那么，T'也是一棵最优查找树，这通过剪贴思想可以证明。
定义e[i,j]为一棵包含关键字ki~kj的最优二叉树的期望代价。当j=i-1时没有真实的关键在，只有虚叶子节点d(i-1)。
于是当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];
min(e[i,r-1] + e[r+1,j]+w[i,j]),如果i<=j，其中i<=r<=j
- 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] = t;
- 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 }
http://blog.csdn.net/clearriver/article/details/4212830
http://blog.csdn.net/taesimple/article/details/6588080
问题描述（详见算法导论P212-P213)
对于给定关键字序列，构造一颗最优的二叉查找树T，使得在T内的一次搜索的期望代价最小
前提概念
- 一颗最优二叉树不一定是一颗整体高度最小的树；也不一定总把具有最大概率的关键字作为根节点
- 二叉查找树的子树必定包含连续范围内的关键字
- 当一颗树成为一个节点的子树时，它的期望代价增加值为该树中所有概率的总和
- 给定一个由n个互异关键字(k1, ..., kn)组成的序列K，且关键字有序（k1＜...＜kn）。对每个关键字ki，一次搜索为ki的概率是pi。某些搜索值可能不在K内，因此还有n+1个”虚拟键“d0, d1, ..., dn代表不在K内的值，且ki≤di≤ki+1，di概率为qi
- e[i, j]：最优二叉查找树(ki, ..., kj)的期望代价
- w[i, j]：最优二叉查找树(ki, ..., kj)的概率总和，即∑p+∑q（p:i~j q:i-1~j）
- root[i, j]：记录最优二叉查找树(ki, ..., kj)的根节点的序号，用于构造问题最优解
- 当j=i-1时，表示只有虚拟键di-1，此时e[i, i-1] = w[i, i-1] = qi
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
- 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] = t;
- 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 }
动态规划方法生成最优二叉查找树
1、概念引入
6、具体实现代码（其中所有数据都存放在2.txt中，其内容为：
其中5表示有5个节点，其他数据表示各个节点出现的概率；
1 #include<stdio.h> 2 #include<stdlib.h> 3 #define max 9999 4 void OptimalBST(int,float*,float**,int**); 5 void OptimalBSTPrint(int,int,int**); 6 void main() 7 { 8 int i,num; 9 FILE *point; 10 //所有数据均从2.txt中获取，2.txt中第一个数据表示节点个数；从第二个数据开始表示各个节点的概率 11 point=fopen("2.txt","r"); 12 if(point==NULL) 13 { 14 printf("cannot open 2.txt.\n"); 15 exit(-1); 16 } 17 fscanf(point,"%d",&num); 18 printf("%d\n",num); 19 float *p=(float*)malloc(sizeof(float)*(num+1)); 20 for(i=1;i<num+1;i++) 21 fscanf(point,"%f",&p[i]); 22 //创建主表； 23 float **c=(float**)malloc(sizeof(float*)*(num+2)); 24 for(i=0;i<num+2;i++) 25 c[i]=(float*)malloc(sizeof(float)*(num+1)); 26 //创建根表； 27 int **r=(int**)malloc(sizeof(int*)*(num+2)); 28 for(i=0;i<num+2;i++) 29 r[i]=(int*)malloc(sizeof(int)*(num+1)); 30 //动态规划实现最优二叉查找树的期望代价求解。。 31 OptimalBST(num,p,c,r); 32 printf("该最优二叉查找树的期望代价为：%f \n",c[1][num]); 33 //给出最优二叉查找树的中序遍历结果； 34 printf("构造成的最优二叉查找树的中序遍历结果为："); 35 OptimalBSTPrint(1,4,r); 36 37 } 38 void OptimalBST(int num,float*p,float**c,int**r) 39 { 40 int d,i,j,k,s,kmin; 41 float temp,sum; 42 for(i=1;i<num+1;i++)//主表和根表元素的初始化 43 { 44 45 c[i][i-1]=0; 46 c[i][i]=p[i]; 47 r[i][i]=i; 48 } 49 c[num+1][num]=0; 50 for(d=1;d<=num-1;d++)//加入节点序列 51 { 52 for(i=1;i<=num-d;i++) 53 { 54 j=i+d; 55 temp=max; 56 for(k=i;k<=j;k++)//找最优根 57 { 58 if(c[i][k-1]+c[k+1][j]<temp) 59 { 60 temp=c[i][k-1]+c[k+1][j]; 61 kmin=k; 62 } 63 } 64 r[i][j]=kmin;//记录最优根 65 sum=p[i]; 66 for(s=i+1;s<=j;s++) 67 sum+=p[s]; 68 c[i][j]=temp+sum; 69 } 70 } 71 } 72 //采用递归方式实现最优根的输出，最优根都是保存在r[i][j]中的。。。 73 void OptimalBSTPrint(int first,int last,int**r) 74 { 75 76 int k; 77 if(first<=last) 78 { 79 k=r[first][last]; 80 printf("%d ",k); 81 OptimalBSTPrint(first,k-1,r); 82 OptimalBSTPrint(k+1,last,r); 83 } 84 }
7、最终运行结果：
8、参考文献：
（1）算法导论
（2）数据结构 严蔚敏
（3）网上下载的一个ppt（算法设计与分析，第八章）
645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
