Question

我指的是THIS问题和解决方案。

首先，我没有理解为什么在递归方程中加入频率之和。 enter image description here 有人可以通过一个例子来帮助理解。

在作者的话中。

我们添加从i到j的频率之和（参见上面的第一项）公式），这是因为每次搜索都将通过root和每次搜索都会进行一次比较。

在代码中，频率之和（我不明白的目的）......对应于fsum。

int optCost(int freq[], int i, int j)
{
   // Base cases
   if (j < i)      // If there are no elements in this subarray
     return 0;
   if (j == i)     // If there is one element in this subarray
     return freq[i];

   // Get sum of freq[i], freq[i+1], ... freq[j]
   int fsum = sum(freq, i, j);

   // Initialize minimum value
   int min = INT_MAX;

   // One by one consider all elements as root and recursively find cost
   // of the BST, compare the cost with min and update min if needed
   for (int r = i; r <= j; ++r)
   {
       int cost = optCost(freq, i, r-1) + optCost(freq, r+1, j);
       if (cost < min)
          min = cost;
   }

   // Return minimum value
   return min + fsum;
}

其次，此解决方案将返回最优成本。关于如何获得实际bst的任何建议？

Answer 1

为什么我们需要频率总和

频率总和背后的想法是正确计算特定树的成本。它的行为类似于累加器值来存储树的重量。

想象一下，在第一级递归时，我们从位于树的第一层的所有键开始（我们还没有选择任何根元素）。记住权重函数 - 它对所有节点权重乘以节点级别求和。现在我们树的重量等于所有键的权重之和，因为我们的任何键都可以位于任何级别（从第一个开始），无论如何，我们的结果中每个键至少有一个权重。

1）假设我们找到了最佳根密钥，比如密钥r。接下来，我们将除r之外的所有键移动一级，因为剩下的每个元素最多可以位于第二级（第一级已被占用）。因此，我们将每个键的重量加到我们的总和中，因为无论如何，对于所有这些键，我们将至少具有双倍的重量。键离开我们根据我们之前选择的r元素（从r向左，向右）分成两个子数组。

2）下一步是选择第二级的最佳键，一个来自第一步剩下的两个子阵列中的每一个。在这样做之后，我们再次将所有键向下移动一级，并将它们的权重添加到总和中，因为它们将至少位于第三级，因此我们将为每个键至少具有三倍权重。

3）等等。

我希望这个解释能让你理解为什么我们需要这个频率之和。

寻找最佳bst

正如作者在文章末尾提到的那样

2）在上述解决方案中，我们仅计算了最优成本。该可以很容易地修改解决方案以存储BST的结构。我们可以创建另一个大小为n的辅助数组来存储结构树。我们需要做的就是将选定的'r'存储在最里面循环。

我们可以做到这一点。您将在下面找到我的实现。

关于它的一些注意事项：

1）我被迫用实用程序类int[n][n]替换Matrix因为我使用了Visual C ++，它不支持非编译时常量表达式作为数组大小。

2）我使用了你提供的文章（带记忆）的算法的第二次实现，因为添加功能来存储最佳bst要容易得多。

3）作者在他的代码中有错误：第二个循环for (int i=0; i<=n-L+1; i++)的上限不应为n-L而不是n-L+1。

4）我们存储最佳bst的方式如下：对于每对i, j，我们存储最佳密钥索引。这与最优成本相同，但不是存储最优成本，而是存储最佳密钥索引。例如，对于0, n-1，我们将得到结果树的根键r的索引。接下来，我们根据根元素索引r将数组拆分为两个，并获得它们的最佳键索引。我们可以通过访问矩阵元素0, r-1和r+1, n-1来指出这一点。等等。效用函数'PrintResultTree'使用此方法并按顺序打印结果树（左子树，节点，右子树）。所以你基本上得到有序列表，因为它是二叉搜索树。

5）请不要因为我的代码而激怒我 - 我不是一个真正的c ++程序员。：）

int optimalSearchTree(int keys[], int freq[], int n, Matrix& optimalKeyIndexes)
{
    /* Create an auxiliary 2D matrix to store results of subproblems */
    Matrix cost(n,n);
    optimalKeyIndexes = Matrix(n, n);
    /* cost[i][j] = Optimal cost of binary search tree that can be
    formed from keys[i] to keys[j].
    cost[0][n-1] will store the resultant cost */

    // For a single key, cost is equal to frequency of the key
    for (int i = 0; i < n; i++)
        cost.SetCell(i, i, freq[i]);

    // Now we need to consider chains of length 2, 3, ... .
    // L is chain length.
    for (int L = 2; L <= n; L++)
    {
        // i is row number in cost[][]
        for (int i = 0; i <= n - L; i++)
        {
            // Get column number j from row number i and chain length L
            int j = i + L - 1;
            cost.SetCell(i, j, INT_MAX);

            // Try making all keys in interval keys[i..j] as root
            for (int r = i; r <= j; r++)
            {
                // c = cost when keys[r] becomes root of this subtree
                int c = ((r > i) ? cost.GetCell(i, r - 1) : 0) +
                    ((r < j) ? cost.GetCell(r + 1, j) : 0) +
                    sum(freq, i, j);
                if (c < cost.GetCell(i, j))
                {
                    cost.SetCell(i, j, c);
                    optimalKeyIndexes.SetCell(i, j, r);
                }
            }
        }
    }
    return cost.GetCell(0, n - 1);
}

以下是实用工具类Matrix：

class Matrix
{
private:
    int rowCount;
    int columnCount;
    std::vector<int> cells;
public:
    Matrix()
    {

    }
    Matrix(int rows, int columns)
    {
        rowCount = rows;
        columnCount = columns;
        cells = std::vector<int>(rows * columns);
    }

    int GetCell(int rowNum, int columnNum)
    {
        return cells[columnNum + rowNum * columnCount];
    }

    void SetCell(int rowNum, int columnNum, int value)
    {
        cells[columnNum + rowNum * columnCount] = value;
    }
};

带有效用函数的主要方法按顺序打印结果树：

//Print result tree in in-order
void PrintResultTree(
    Matrix& optimalKeyIndexes,
    int startIndex,
    int endIndex,
    int* keys)
{
    if (startIndex == endIndex)
    {
        printf("%d\n", keys[startIndex]);
        return;
    }
    else if (startIndex > endIndex)
    {
        return;
    }

    int currentOptimalKeyIndex = optimalKeyIndexes.GetCell(startIndex, endIndex);
    PrintResultTree(optimalKeyIndexes, startIndex, currentOptimalKeyIndex - 1, keys);
    printf("%d\n", keys[currentOptimalKeyIndex]);
    PrintResultTree(optimalKeyIndexes, currentOptimalKeyIndex + 1, endIndex, keys);

}
int main(int argc, char* argv[])
{
    int keys[] = { 10, 12, 20 };
    int freq[] = { 34, 8, 50 };

    int n = sizeof(keys) / sizeof(keys[0]);
    Matrix optimalKeyIndexes;
    printf("Cost of Optimal BST is %d \n", optimalSearchTree(keys, freq, n, optimalKeyIndexes));
    PrintResultTree(optimalKeyIndexes, 0, n - 1, keys);

    return 0;
}

修改

下面你可以找到创建简单树状结构的代码。

这是实用程序TreeNode类

struct TreeNode { public: int Key; TreeNode* Left; TreeNode* Right; };

使用main函数
更新了BuildResultTree函数
void BuildResultTree(Matrix& optimalKeyIndexes, int startIndex, int endIndex, int* keys, TreeNode*& tree) { if (startIndex > endIndex) { return; } tree = new TreeNode(); tree->Left = NULL; tree->Right = NULL; if (startIndex == endIndex) { tree->Key = keys[startIndex]; return; } int currentOptimalKeyIndex = optimalKeyIndexes.GetCell(startIndex, endIndex); tree->Key = keys[currentOptimalKeyIndex]; BuildResultTree(optimalKeyIndexes, startIndex, currentOptimalKeyIndex - 1, keys, tree->Left); BuildResultTree(optimalKeyIndexes, currentOptimalKeyIndex + 1, endIndex, keys, tree->Right); } int main(int argc, char* argv[]) { int keys[] = { 10, 12, 20 }; int freq[] = { 34, 8, 50 }; int n = sizeof(keys) / sizeof(keys[0]); Matrix optimalKeyIndexes; printf("Cost of Optimal BST is %d \n", optimalSearchTree(keys, freq, n, optimalKeyIndexes)); PrintResultTree(optimalKeyIndexes, 0, n - 1, keys); TreeNode* tree = new TreeNode(); BuildResultTree(optimalKeyIndexes, 0, n - 1, keys, tree); return 0; }

在求解最优二叉搜索树的同时添加频率之和

1 个答案: