最优二叉搜索树

     OBST问题：用二叉树来存数据，不同数据访问频率不一样，怎么样构建这颗二叉树，才可以使得访问代价最小。

     直观的想法是把访问频率最高的放到树的根节点，树越矮越好，但是，很容易举出例子证明这种想法是错的，正确的做法是用动态规划。

     先讲讲用到的变量：

　　　　p[ n ]是n个节点的频率数组，

　　　　e[ i ][ j ] 表示第 i 个节点到第 j 个节点构成的子树的最小搜索代价值，

　　　　w[ i ][ j ]表示第 i 个节点到第 j 个节点的频率和。

     一个事实：如果r是e[ i ][ j ]的根节点（i<=r<=j）那么：

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

　　同时定义边界：e[ i ][ j ]=0   ( j=i-1 )

　　动态转移方程：

　　　　e[ i ][ j ]=min{ e[ i ][ r-1 ] + e[ r+1 ][ j ] +w[ i ][ j ] }

　　用到了3层循环，第一层循环变量是子树的节点个数，第二层循环的变量是子树的起点位置，第三层循环的变量是子树的根节点位置，如此，我们可以得到任意区间OBST的搜索期望是多少。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define INF 9999;

void Optimal_BST(double p[],int n){
    int i,j,l,r;
    int root[n+1][n+1];
    double e[n+2][n+2];
    double w[n+2][n+2];
    for(i=1;i<=n+1;i++){
        e[i][i-1]=0;
        w[i][i-1]=0;
    }
    
    for(l=1;l<=n;l++){
        for(i=1;   i<=n-l+1;  i++){  // i,j between 1 and n+1，i是左边界，j是右边界 
            j=i+l-1;
            e[i][j]=INF;
            w[i][j]=w[i][j-1]+p[j];     
            for(r=i;r<=j;r++){
                double temp=e[i][r-1]+e[r+1][j]+w[i][j];
                if(temp<e[i][j]){
                    e[i][j]=temp;
                    root[i][j]=r;
                }
            }
        }
    }
    printf("

e table
");    
    for(i=1;i<=n;i++){
        for(j=1;j<=n;j++){
            if(i>j)printf("          ");
            else printf("%f  ",e[i][j]);
        }
        printf("
");
    }
    
    printf("

w table
");
    for(i=1;i<=n;i++){
        for(j=1;j<=n;j++){
            if(i>j)printf("          ");
            else printf("%f  ",w[i][j]);
        }
        printf("
");
    }

    printf("

root table
");
    for(i=1;i<=n;i++){
        for(j=1;j<=n;j++){
            if(i>j)printf("  ");
            else printf("%d ",root[i][j]);
        }
        printf("
");
    }
}

int main(){
    int n=5;
    double p[6]={-1,0.25,0.2,0.05,0.2,0.3};
    Optimal_BST(p,n);
    return 0;
}