动态规划-最优二叉搜索树-公式推导

本文详细介绍了如何使用动态规划方法构建最优二叉搜索树,以最小化搜索操作的平均成本。通过具体实例,展示了算法步骤,包括计算子树概率总和、期望代价以及确定根节点的过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

 

 

 


#include <iostream>
#include<bits/stdc++.h>
using namespace std;

const int MaxVal = 9999;

const int n = 5;

//搜索到根节点和虚拟键的概率
double p[n + 1] = {0, 0.15, 0.1 , 0.05 , 0.1,0.2};
double q[n + 1] = {0.05, 0.1 ,0.05,0.05,0.05, 0.1};

int    root[n + 1][n + 1];//记录根节点
double w[n + 2][n + 2];//子树概率总和
double e[n + 2][n + 2];//子树期望代价

void optimalBST(double *p,double *q,int n)
{
    //初始化只包括虚拟键的子树
    for (int i = 1;i <= n + 1;++i)
    {
        w[i][i - 1] = q[i - 1];
        e[i][i - 1] = q[i - 1];
    }

    //由下到上,由左到右逐步计算
    for (int len = 1 ; len <= n; len++ )
    {
        for (int j = n - len + 1 ; j <= n ; j++)
        {
            int i = n - len + 1;// i 从5到1

            e[i][j] = MaxVal;
            w[i][j] = w[i][j - 1] + p[j] + q[j];//公式推导、

            /*
            cout<<"w "<<i<<" "<<j - 1<<" "<<w[i][j - 1]<<endl;
            cout<<"p "<<j<<" "<<p[j]<<endl;

            cout<<"q "<<j<<" "<<q[j]<<endl;
            cout<<"w "<<i<<" "<<j<<" "<<w[i][j]<<endl;
            //cout<<"w"<<i<<j<<w[i][j]<<endl;
            //cout<<w[i][j]<<endl;
            getchar();
            */

            //求取最小代价的子树的根
            for (int k = i;k <= j;++k)
            {
                double temp = e[i][k - 1] + e[k + 1][j] + w[i][j];
                if (temp < e[i][j])
                {
                    /*
                    cout<<k<<endl;
                    cout<<i<<" "<<k-1<<"e "<<e[i][k - 1]<<endl;
                    cout<<k+1<<" "<<j<<"e "<<e[k + 1][j]<<endl;
                    cout<<i<<" "<<j<<"w "<<w[i][j]<<endl;
                    cout<<temp<<endl;

                    getchar();*/
                    e[i][j] = temp;
                    root[i][j] = k;
                }
            }
        }
    }
}

//输出最优二叉查找树所有子树的根


//打印最优二叉查找树的结构
//打印出[i,j]子树,它是根r的左子树和右子树

void printOptimalBST(int i,int j,int r)
{
    int rootChild = root[i][j];//子树根节点

    if (rootChild == root[1][n])
    {
        //输出整棵树的根
        cout << "k" << rootChild << "是根" << endl;
        printOptimalBST(i,rootChild - 1,rootChild);
        printOptimalBST(rootChild + 1,j,rootChild);
        return;
    }

    if (j < i - 1)
    {
        return;
    }
    else if (j == i - 1)//遇到虚拟键
    {
        if (j < r)
        {
            cout << "d" << j << "是" << "k" << r << "的左孩子" << endl;
        }
        else
            cout << "d" << j << "是" << "k" << r << "的右孩子" << endl;
        return;
    }
    else//遇到内部结点
    {
        if (rootChild < r)
        {
            cout << "k" << rootChild << "是" << "k" << r << "的左孩子" << endl;
        }
        else
            cout << "k" << rootChild << "是" << "k" << r << "的右孩子" << endl;
    }

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

int main()
{
    optimalBST(p,q,n);
    cout << "最优二叉树结构:" << endl;
    printOptimalBST(1,n,1);
}

 

最优二叉搜索树(Optimal Binary Search Tree,简称OBST)问题是指给定一个值序列,其中每个值作为二叉搜索树中的一个键,要求构造一棵具有最小期望搜索成本的二叉搜索树动态规划是解决这个问题的一种有效方法。动态规划的递推公式如下: 设cost[i][j]表示以值序列中的第i个值到第j个值作为二叉搜索树的根节点时的最小期望搜索成本。则有: 1. 当i > j时,cost[i][j] = 0,因为没有节点,不需要搜索成本。 2. 当i ≤ j时,cost[i][j]的值由以下两部分决定: - 选择某个值作为根节点,计算其左右子树的最小成本之和。 - 计算以当前根节点进行搜索时的期望成本,即每个节点被搜索的概率乘以其深度。 具体的递推公式如下: cost[i][j] = min{cost[i][j], cost[i][k-1] + cost[k+1][j] + sum(p[i...k-1] * depth(k, i, j)) + p[k] * depth(k, i, j)} 其中,k从i到j进行遍历,p[i...k-1]表示从i到k-1的节点被搜索的概率之和,p[k]表示节点k被搜索的概率,depth(k, i, j)表示节点k在以i到j为节点构成的树中的深度。 这里的关键是如何计算深度。对于一个节点k,其深度取决于其是左子树的根还是右子树的根。如果k是左子树的根,则其深度是1加上左子树的根节点的深度;如果k是右子树的根,则其深度是1加上右子树的根节点的深度。 通过这个递推公式,我们可以利用动态规划的方法,从最小的子问题开始,逐步构建出整个问题的解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值