算法与数据结构学习笔记-最优二叉搜索树(optimal binary search tree)的动态规划实现详解

一串字符中可能进行多次查找，每个字符被查找到的频率都不同，如何根据字符被查找到的频率，建立一个二叉搜索树，使得花费时间最少呢？

题目：给定一列按升序排列的键值$K=[k_1,k_2,...,k_n]$和它们被搜索到的频率$P=[p_1,p_2,...,p_n]$，建立一个二叉搜索树，使得搜索的平均费用最低。要求输入键值和频率数组，返回搜索树及其费用。

二叉树的费用如何计算呢？我们知道节点越低，搜索经过的路程越长。因此定义搜索的花费$cost(k_i)=depth(k_i)+1$。因为对根节点进行查找也需要一次操作，而根节点的深度为0,所以定义每个节点的搜索花费为$depth(k_i)+1$。每一个节点$k_i$被搜索到的频率为$p_i$，因此整棵树T的费用定义为：

$$E(T)=\sum _{i=1}^{n}cost(k_i)\cdot p_i=\sum _{i=1}^n(depth(k_i)+1)\cdot p_i=\sum _{i=1}^{n}depth(k_i)\cdot p_i+\sum _{i=1}^n{p}_i$$
而${\sum }_{i=1}^n{p}_i$的值为1（每个键值的概率相加），因此
$$E(T)=\sum _{i=1}^{n}depth(k_i)\cdot p_i+1$$

在搜索过程中会出现对给出的键值之外的值的搜索，为了方便，我们给搜索树的每个叶子节点加上两个“假的”节点，并给出搜索到假节点的概率用$q_0,q_1,...,q_n$表示。

用该公式尝试计算一棵二叉搜索树的费用：

i	1	2	3	4	5
$k_i$	0.25	0.20	0.05	0.20	0.30

左树$$E(T)=\sum _{i=1}^{n}depth(k_i)\cdot p_i+1=0.20\times 0+0.25\times 1+0.20\times 1+0.05\times 2+0.30\times 2+1=2.15$$
右树$$E(T)=\sum _{i=1}^{n}depth(k_i)\cdot p_i+1=0.20\times 0+0.25\times 1+0.30\times 1+0.20\times 2+0.05\times 3+1=2.10$$

显然右树更理想。

有时会对给出键值之外的值进行搜索，这部分搜索的概率不为0，导致${\sum }_{i=0}^n{p}_i<1$，这时要把搜索不到的部分也加到搜索树上，也就是加上一些“假节点”，当搜索到假节点时，表示搜索失败。这部分概率用$q_0,q_1,q_2,...,q_n$表示。

i	0	1	2	3	4	5
$p_i$		0.15	0.10	0.05	0.10	0.20
$q_i$	0.05	0.10	0.05	0.05	0.05	0.10

左树$$\begin{gathered} E(T)=\sum _{i=1}^{n}depth(k_i)\cdot p_i+\sum _{i=0}^{n}depth(k_i)\cdot q_i+1 \\ =0.10\times 0+0.15\times 1+0.10\times 1+0.05\times 2+0.20\times 2+0.05\times 2+0.10\times 2+0.05\times 3+0.05\times 3+0.05\times 3+0.10\times 3+1 \\ =2.80 \end{gathered}$$

右树$$\begin{gathered} E(T)=\sum _{i=1}^{n}depth(k_i)\cdot p_i+\sum _{i=0}^{n}depth(k_i)\cdot q_i+1 \\ =0.10\times 0+0.15\times 1+0.20\times 1+0.10\times 2+0.05\times 3+0.05\times 2+0.10\times 2+0.05\times 3+0.05\times 3+0.05\times 3+0.10\times 3+1 \\ =2.75 \end{gathered}$$

右树更优。

这道题是否满足动态规划解题的条件呢？

可以把每一个节点看成一棵二叉树的根节点，如果整棵二叉树是最优的（搜索费用最低），那么每一棵子树里面节点的排列也是最优的。否则可以通过重新排列子树的节点使整棵树的费用降低。因此该问题满足”最优子结构“。

寻找递归公式使用如下方式：对所有$i\ge 1,j\le n,j\ge i-1$，对于从$k_i到k_j$的一系列节点，每一个节点都有可能是使$k_i到k_j$成为最优搜索树的根节点，因此让$k_i到k_j$的每一个节点都当一次根节点$k_r$，并让$k_i到k_{r-1}$成为最优二叉搜索树，且让$k_{i+1}到k_j$成为最优二叉搜索树，并计算相应的$E(k_r)$。在所有的$E(k_r)$里找到最小值并记录$E(k_r)$和$r$值。

定义$k_i...k_j$组成的最优二叉搜索树的费用为$e[i,j]$（与上文的$E(T)$类似），那么当$k_r(i\le r\le j)$作为根节点时，左树最低费用为$e[i,r-1]$，右树最低费用为$e[r+1,i]$，根节点费用为$p_r$。然而，整棵树的费用不能简单地将左树费用，根节点费用，右树费用相加，因为$e[i,r-1]$和$e[r+1,i]$分别为左右树单独成树的费用。当它们成为$k_r$的左子树和右子树，所有节点的深度加1，根据公式$E(T)={\sum }_{i=1}^{n}depth(k_i)\cdot p_i+{\sum }_{i=0}^{n}depth(k_i)\cdot q_i+1$，成为子树后$E(T)={\sum }_{i=1}^n(depth(k_i)+1)\cdot p_i+{\sum }_{i=0}^n(depth(k_i)+1)\cdot q_i+1$，即$E^{\prime }(T)=E(T)+{\sum }_{i=1}^n{p}_i+{\sum }_{i=0}^n{q}_i$。

定义一个新变量$w(i,j)={\sum }_{l=i}^j{p}_l+{\sum }_{l=i}^j{q}_l$，那么
$$e[i,j]=p_r+(e[i,r-1]+w(i,r-1))+(e[r+1,j]+w(r+1,j))$$
可得
$$e[i,j]=e[i,r-1]+e[r+1,j]+w(i,j)$$
这是递归公式的基础。当$j=i-1$时是什么情况呢？，当把$k_r$作为根节点时，$k_r$的左子树应该是有$k_r...k_{r-1}$这些节点。当$r=i$时，$k_i$的左子树有$k_i...k_{i-1}$这些节点。但因为树的所有节点是从$k_i$开始的，$k_{i-1}$并不存在这棵树中。根节点$k_i$也被排除在外。由之前对假节点的定义我们知道，这是一个假节点，表明搜索失败，且这是一棵只有假节点的单节点树，其费用为$q_{i-1}$。由此可得：
$$e[i,j]=\{\begin{array}{llc}{q}_{i-1}& & j=i-1\\ {\min }_{i\le r\le j}(e[i,r-1]+e[r+1,j]+w(i,j))& & S_L\le 0<S_M\end{array}$$

如果直接用递归实现，会对很多$e[i,j]$重复计算，比如寻找$k_1...k_5$的最优树，当$r=2$时，需要计算$k_3...k_5$的最优解。寻找$k_3...k_7$的最优树，当$r=6$时，需要再次计算$k_3...k_5$的最优解。因此有很多重叠的子问题，满足动态规划解题的第二条件。

void optimal_bst(vector<double> p, vector<double> q, vector<vector<double>> &e, vector<vector<int>> &root) {

 int i,j,k,l;
 double temp;
 vector<vector<double>> w(q.size()+1, vector<double>(q.size()));

 for(i=1;i<=q.size();i++) {
   e[i][i-1]=q[i-1];
   w[i][i-1]=q[i-1];
 }
 for(l=1;l<q.size();l++)
   for(i=1;i<q.size()-l+1;i++) {
     j=i+l-1;
     for(k=i;k<=j;k++) {
       w[i][j]=w[i][k-1]+p[k]+w[k+1][j];
       temp=e[i][k-1]+e[k+1][j]+w[i][j];
       if(temp<e[i][j]) {
         e[i][j]=temp;
         root[i][j]=k;
       }
     }
   }
}

输出结果根据root表递归：

void print_bst_aux (vector<vector<int>> root,int i,int j) {

 int r=root[i][j];
 if(r==0)return;
 if(r>i) {
   cout<<"k"<<root[i][r-1]<<" is the left child of k"<<r<<endl;
   //cout<<"i:"<
   print_bst_aux(root, i, r-1);
 }
 else {
   cout<<"d"<<i-1<<" is the left dummy child of k"<<i<<endl;
 }
 if(r<j) {
   cout<<"k"<<root[r+1][j]<<" is the right child of k"<<r<<endl;
   print_bst_aux(root,r+1,j);
  }
 else {
   cout<<"d"<<i<<" is the right dummy child of k"<<r<<endl;
 }
}
void print_bst (vector<vector<int>> root) {
int r=root[1][root.size()-1];
cout<<"k"<<r<<" is the root"<<endl;
print_bst_aux(root,1,root.size()-1);
}

测试使用表格：

i	0	1	2	3	4	5
$p_i$		0.15	0.10	0.05	0.10	0.20
$q_i$	0.05	0.10	0.05	0.05	0.05	0.10

用$k_i$代表正常节点，用$d_i$代表假节点。

全部代码：

#include
#include
using namespace std;
#define INF 2147483647

template <class value_type>
void print(vector<vector<value_type>> v) {
 for(int i=0;i<v.size();i++){
   for(int j=0;j<v[i].size();j++)
     if(v[i][j]==INF)cout<<"X ";
     else cout<<v[i][j]<<", ";
     cout<<endl;
 }
}

void optimal_bst(vector<double> p, vector<double> q, vector<vector<double>> &e, vector<vector<int>> &root) {

int i,j,k,l;
double temp;
vector<vector<double>> w(q.size()+1, vector<double>(q.size()));

for(i=1;i<=q.size();i++) {
  e[i][i-1]=q[i-1];
  w[i][i-1]=q[i-1];
}
for(l=1;l<q.size();l++)
  for(i=1;i<q.size()-l+1;i++) {
    j=i+l-1;
    for(k=i;k<=j;k++) {
      w[i][j]=w[i][k-1]+p[k]+w[k+1][j];
      temp=e[i][k-1]+e[k+1][j]+w[i][j];
      if(temp<e[i][j]) {
        e[i][j]=temp;
        root[i][j]=k;
      }
    }
  }
print(e);
print(w);
print(root);
}

void print_bst_aux (vector<vector<int>> root,int i,int j) {

 int r=root[i][j];
 if(r==0)return;
 if(r>i) {
   cout<<"k"<<root[i][r-1]<<" is the left child of k"<<r<<endl;
   //cout<<"i:"<
   print_bst_aux(root, i, r-1);
 }
 else {
   cout<<"d"<<i-1<<" is the left dummy child of k"<<i<<endl;
 }
 if(r<j) {
   cout<<"k"<<root[r+1][j]<<" is the right child of k"<<r<<endl;
   print_bst_aux(root,r+1,j);
  }
 else {
   cout<<"d"<<i<<" is the right dummy child of k"<<r<<endl;
 }
}

void print_bst (vector<vector<int>> root) {
int r=root[1][root.size()-1];
cout<<"k"<<r<<" is the root"<<endl;
print_bst_aux(root,1,root.size()-1);
}

int main() {

vector<double> p={0.00,0.15,0.10,0.05,0.10,0.20};
vector<double> q={0.05,0.10,0.05,0.05,0.05,0.10};

vector<vector<double>> e(q.size()+1, vector<double>(q.size(),INF));
vector<vector<int>> root(q.size(), vector<int>(q.size(),0));
optimal_bst(p,q,e,root);
print_bst(root);
}