动态规划之最优二叉搜索树

最新推荐文章于 2024-02-01 17:03:03 发布

雪狐晨光

最新推荐文章于 2024-02-01 17:03:03 发布

阅读量1.3w

点赞数 10

分类专栏：算法数据结构算法和能力文章标签：动态规划最优二叉树搜索 OP-BST 算法导论

本文链接：https://blog.csdn.net/zhangyifei521/article/details/50833792

版权

算法数据结构同时被 2 个专栏收录

32 篇文章 1 订阅

订阅专栏

算法和能力

8 篇文章 0 订阅

订阅专栏

Age wrinkles the body. Quitting wrinkles the soul. 岁月使皮肤起皱，放弃使灵魂起皱。——Douglas MacArthur（道格拉斯.麦克阿瑟）

《算法导论》学习笔记

1. 概述

　　利用最优二叉搜索树来实现树的搜索代价最小。树上的每一个节点都有一个被搜索到的概率值 $p_i$ ，搜索一个节点的花费为 $p_i *（depth(ki)+1）$ ，如何构造一个二叉查找树使搜索树上的所有节点的花费最小即为实现最优二叉查找树的问题。该问题可以用动态规划的思路实现。
　　形式化定义：给定n个不同关键字已经排序的序列 $K=(k_1,k_2,...,k_n) 因此(k_1 < k_2 < k_3 < ... < k_n)$ ,我们希望用这些关键字构造一个二叉搜索树。对每个关键字 $k_i$ ,都有概率 $p_i$ 表示起搜索概率。有些要搜索的值可能不再K中，因此我们还需要n+1个伪关键字 $(d_0,d_1,d_2, ... d_n)$ ，对于每一个伪关键字都有一个概率 $q_i$ 表示对应的搜索概率。

2. 问题案例

　　n=5的关键字集合以及如下的搜索概率，构造二叉搜索树。
　　关键字和搜索概率
　　
　　期望搜索代价的计算公式：
　　
　　
　　
　　我们已知：
　　
　　概率和公式

3. 动态规划思路解析

Step1 :最优二叉搜索树的结构：为了刻画最有二叉搜索树的结构我们从观察子树特征开始。Op-BST的T的子树T’肯定也是Op-BST，我们可以使用剪切-粘贴法来证明。
Step2:递归算法的构建：我们给出最优解的递归定义，我们选取子问题为求包含关键字 $(k_i,k_{i+1},... ,k_j)的最优二叉搜索树，其中i>=1,j<=n且j>=i-1(当j=i-1时，子树不包含实际关键字，只包含伪关键字d_{i-1}). 定义e[i,j]为包含关键字(k_i,k_{i+1},... ,k_j)的二叉搜索树进行一次搜索的期望代价，最后我们希望求解得到e[1,n]。$

j=i-1的情况最简单，由于子树只含有伪关键字 $d_{i-1}$ 因此， $e[i,j]=q_{i-1}$
当j>=i时，我们需要从 $(k_i,k_{i+1},... ,k_j)$ 中选择一个跟结点 $k_r$ ,然后分别构造其左子树和右子树。下面需要计算以 $kr$ E为根的树的期望搜索代价。然后选择导致最小期望搜索代价的kr做根。
现在需要考虑的是，当一棵树成为一个节点的子树时，期望搜索代价怎么变化？子树中每个节点深度都增加1.期望搜索代价增加量为子树中所有概率的总和。
对一棵关键字ki,…,kj的子树，定义其概率总和为：

w [i, j] = \sum l = i j p l + \sum l = i - 1 j q l

$w[i,j]=\sum _{l=i} ^{j} p_{l} + \sum _{l=i-1} ^{j} q_{l}$
因此，如果

kr $k_r$ 是根节点，我们有如下公式：

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

$e[i,j]=p_r+((e[i,r-1]+w[i,r-1])+(e[r+1,j]+w[r+1,j]))$
注意：

w [i, j] = w [i, r - 1] + p r + w [r + 1, j]

$w[i,j]= w[i,r-1]+p_r+w[r+1,j]$
因此e[i,j]可以重写为

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

$e[i,j]=e[i,r-1]+w[i,j])+(e[r+1,j]$
如果选取期望搜索代价最低者最为根节点，可以得出最终的递推公式：

e [i, j] = {q i - 1 M i n () e [i, r - 1] + w [i, j]) + (e [r + 1, j] j=i-1 j>=i,i<=r<=j

$e[i,j]=\begin{cases} q_{i-1} & \text{j=i-1}\\ Min() e[i,r-1]+w[i,j])+(e[r+1,j]& \text{j>=i,i<=r<=j} \end{cases}$

Step3:计算二叉搜索树的期望搜索代价：
伪代码算法：

OPTIMAL-BST(p[],q[],n){
let e[1,...n+1,0,...n] and root[1,...n,1,...n] and  w[1,...n+1,0,...n]
//e[1,0]表示只有伪关键字d0的代价,e[n+1,n]表示只有伪关键字dn的代价  
//在w[1,...n+1,0,...n]的下标含义一致

//初始化e[i, i - 1]和 w[i, i - 1]
for i ← 1 to n + 1
   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] ← ∞
       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
}

算法分析，在每一次的计算 $t ← e[i, r - 1] + e[r + 1, j] + w[i, j]$ 中,随着层数的增加，w[i,j]是重复计数的而且和深度有关。

Step4:构建最优解输出：
算法设计：

CONSTRUCTOR-OPTIMAL-BST(root[][],i,j,r){
    int rootChild = root[i][j];//子树根节点  
    if (rootChild == root[1][n])  
    {  
        //输出整棵树的根  
        print("K"+rootChild+"是根");      
        CONSTRUCTOR-OPTIMAL-BST(root,i,rootChild - 1,rootChild);  
        CONSTRUCTOR-OPTIMAL-BST(root,rootChild + 1,j,rootChild);  
        return;  
    }  
    if (j < i - 1)  
    {  
        return;  
    }  
    else if (j == i - 1)//遇到虚拟键  
    {  
        if (j < r)  
        {  
           print( "d" +  j + "是" + "k" + r + "的左孩子" );  
        }  
        else {
            print( "d" +  j + "是" + "k" + r + "的右孩子" );  
        } 
        return;  
    }  
    else//遇到内部结点  
    {  
        if (rootChild < r)  
        {  
            print ("k" + rootChild + "是" + "k" + r + "的左孩子" );  
        }  
        else{
            print ("k" + rootChild + "是" + "k" + r + "的右孩子" );  
        }  

    }  

    CONSTRUCTOR-OPTIMAL-BST(root[],i,rootChild - 1,rootChild);  
    CONSTRUCTOR-OPTIMAL-BST(root[],rootChild + 1,j,rootChild);  
}

4. 最优二叉搜索树Java实现模拟

算法Java实现源码：

package lbz.ch15.dp.ins4;
/** 
 * @author LbZhang
 * @version 创建时间：2016年3月10日 下午10:04:32 
 * @description 测试最优二叉搜索树
 */
public class TestMain {

    public static void main(String[] args) {
        double[] p={0,0.15,0.1,0.05,0.1,0.2};  //n=5关键字有5个
        double[] q={0.05,0.1,0.05,0.05,0.05,0.1};  //叶子结点有n+1 = 6个
        ///这里的关键字长度为5
        int n = p.length;

        System.out.println("输出根节点辅助表");
        int[][] root = Optimal_BST(p,q,n-1);
        int temp = root.length-1;
        for(int i=1;i<temp;i++){
            for(int j=1;j<temp;j++){
                System.out.print(root[i][j]+"-");
            }
            System.out.println();
        }

        printOptimalBST(root,1,5,root[1][5]);  
    }

    /**
     * DP在计算最优二叉树的辅助表的算法实现
     * @param p
     * @param q
     * @param n
     * @return
     */
    private static int[][] Optimal_BST(double[] p, double[] q, int n) {
        double[][] e = new double[n+2][n+2];//
        double[][] w = new double[n+2][n+2];
        int[][] root = new int[n+2][n+2];

        //初始化叶子结点的值
        for(int i=1;i<=n+1;i++){
            e[i][i-1]=q[i-1];
            w[i][i-1]=q[i-1];
        }
        for(int l=1 ; l<=n ; l++){///最外层循环是逐渐的将关键字个数从一个扩展到n个
            for(int i=1;i<=n-l+1;i++){
                int j=i+l-1;
                e[i][j]=Double.MAX_VALUE;
                w[i][j]=w[i][j-1]+p[j]+q[j];
                for(int r=i;r<=j;r++){
                    double 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;///存储根节点的位置
                    }
                }
            }



        }

        System.out.println("输出当前的最小代价："+e[1][n]);
        return root;

    }

    /**
     * 构建最优二叉搜索树
     * @param root
     * @param i
     * @param j
     * @param k
     */
    private static void printOptimalBST(int[][] root, int i, int j, int r) {
        int rootChild = root[i][j];
        if(rootChild==r){
            System.out.println("K"+rootChild+"是根");
            printOptimalBST(root,i,rootChild - 1,rootChild);  
            printOptimalBST(root,rootChild + 1,j,rootChild);  
            return;  
        }
        if (j < i - 1)  
        {  
            return;  
        }  
        else if (j == i - 1)//遇到虚拟键  
        {  
            if (j < r)  
            {  
                System.out.println( "d" +  j + "是" + "k" + r + "的左孩子" );  
            }  
            else {//j>=r
                System.out.println( "d" +  j + "是" + "k" + r + "的右孩子" );  
            } 
            return;  
        }  
        else//遇到内部结点  
        {  
            if (rootChild < r)  
            {  
                System.out.println ("k" + rootChild + "是" + "k" + r + "的左孩子" );  
            }  
            else{
                System.out.println ("k" + rootChild + "是" + "k" + r + "的右孩子" );  
            }  

        }  

        printOptimalBST(root,i,rootChild - 1,rootChild);  
        printOptimalBST(root,rootChild + 1,j,rootChild);  

    }




}