最优二叉搜索树----jvav递归解决

背景

最优二叉搜索树问题的问题提出是，设S={x1, x2, ..., xn}是一个由n个关键字组成的线性有序集，(a0, b1, a1, ..., bn, an) 为集合S的存取概率分布，表示有序集S的二叉搜索树利用二叉树的节点存储有序集中的元素。在二叉搜索树中搜索一个元素x。在二叉搜索树的内部结点中找到x的概率为bj；在二叉搜索树的叶结点中确定x的概率为ai。最优二叉搜索树问题要求找出搜索成本最低的二叉搜索树。设n=4，b(1:4)=(3, 3, 1, 1)，a(1:5)=(2, 3, 1, 1, 1)。

递归计算最优值

设m(i,j)是相对于序列S(i,j)和存取概率分布P(i,j)的最优二叉搜索树的评价比较次数

m(i,j) = min{m(i,k -1) + m(k + 1,j) + w(i,j)     (1<=i <= k <= j <= n)

初始m(i,i - 1) = 0 对应取边界点为根的情况 

w(i,j) = w(i ,j  - 1) + b(j) + a(j)   w(i,i -1) = a(i - 1) 

---

所以我们来写一下递归表达式

 public static double m(double[] p, double[] q, int i, int j) {
        if (j < i) {
            return 0;
        }

        double w = 0;
        for (int k = i - 1; k <= j; k++) {
            w += p[k];
        }
        for (int k = i; k <= j; k++) {
            w += q[k];
        }

        double minCost = Double.MAX_VALUE;
        for (int k = i; k <= j; k++) {
            double cost = m(p, q, i, k - 1) + m(p, q, k + 1, j) + w;
            if (cost < minCost) {
                minCost = cost;
            }
        }
        return minCost;
    }

其实dp的思想跟分治很像，你看我们要求的是m(1,4)但是要把他分成一个个，如果这题不用递归来写，用循环来写，你可以跟写矩阵连乘一样，斜着遍历，所以我觉得矩阵连乘跟最优二叉树没啥太大区别，只是最优二叉树很难理解他那最优的搜索的意思，不像矩阵连乘，只用求最小的相乘次数，这么浅显易懂的答案，但是他们的dp思想都是一样的

总代码

import java.util.Random;
import java.util.Scanner;

//TIP 要<b>运行</b>代码，请按 <shortcut actionId="Run"/> 或
// 点击装订区域中的 <icon src="AllIcons.Actions.Execute"/> 图标。
public class Main {
    public static double m(double[] p, double[] q, int i, int j) {
        if (j < i) {
            return 0;
        }

        double w = 0;
        for (int k = i - 1; k <= j; k++) {
            w += p[k];
        }
        for (int k = i; k <= j; k++) {
            w += q[k];
        }

        double minCost = Double.MAX_VALUE;
        for (int k = i; k <= j; k++) {
            double cost = m(p, q, i, k - 1) + m(p, q, k + 1, j) + w;
            if (cost < minCost) {
                minCost = cost;
            }
        }
        return minCost;
    }

    public static void main(String[] args) {
        double[] p = {2, 3, 1, 1, 1}; // 内部节点概率
        double[] q = {0,3, 3, 1, 1};       // 叶节点概率
        int n = 4; // 关键字个数
        double result = m(p, q, 1, n);
        System.out.println("最小搜索代价为: " + result);
    }
}