使用C++完成以下任务： 随机化查找数字及其查找成功概率并求出最优二叉搜索树。

首先，我们需要定义一个二叉搜索树节点的结构体：

struct Node {
    int key;
    double probability;
    Node* left;
    Node* right;
};

其中，`key`代表节点存储的数字，`probability`代表查找成功的概率，`left`和`right`分别指向左右子树。

然后，我们需要生成随机数和对应的查找成功概率。假设我们需要随机生成`n`个数字，可以使用如下代码：

#include <cstdlib>
#include <ctime>

// 生成一个在[min, max]范围内的随机整数
int random(int min, int max) {
    return rand() % (max - min + 1) + min;
}

// 随机生成n个数字和对应的查找成功概率
void generateRandomNumbers(int n, int* numbers, double* probabilities) {
    srand(time(nullptr));
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        // 随机生成数字和概率
        numbers[i] = random(1, 100);
        probabilities[i] = (double)random(1, 100) / 100.0;
        sum += probabilities[i];
    }
    // 归一化
    for (int i = 0; i < n; i++) {
        probabilities[i] /= sum;
    }
}

接下来，我们需要实现一个函数来构造最优二叉搜索树。这里使用动态规划算法。我们定义`dp[i][j]`表示从第`i`个数字到第`j`个数字构成的子数组所对应的最优二叉搜索树的期望代价。我们可以通过以下递推式来计算`dp[i][j]`：

dp[i][j] = min{dp[i][k-1] + dp[k+1][j] + sum(probabilities[i..j])} (i <= k <= j)

其中，`sum(probabilities[i..j])`表示从第`i`个数字到第`j`个数字对应的查找成功概率之和。

我们可以使用以下代码实现最优二叉搜索树的构造：

Node* constructOptimalBST(int n, int* numbers, double* probabilities) {
    // 构造dp数组
    double dp[n][n];
    for (int i = 0; i < n; i++) {
        dp[i][i] = probabilities[i];
    }
    for (int len = 2; len <= n; len++) {
        for (int i = 0; i <= n - len; i++) {
            int j = i + len - 1;
            dp[i][j] = DBL_MAX;
            double sum = 0.0;
            for (int k = i; k <= j; k++) {
                sum += probabilities[k];
            }
            for (int k = i; k <= j; k++) {
                double cost = (k == i ? 0.0 : dp[i][k-1]) + (k == j ? 0.0 : dp[k+1][j]) + sum;
                if (cost < dp[i][j]) {
                    dp[i][j] = cost;
                    // 记录最小代价的根节点
                    numbers[k] = numbers[k];
                }
            }
        }
    }
    // 构造最优二叉搜索树
    Node* root = new Node();
    root->key = numbers[0];
    root->probability = probabilities[0];
    root->left = root->right = nullptr;
    for (int i = 1; i < n; i++) {
        Node* node = new Node();
        node->key = numbers[i];
        node->probability = probabilities[i];
        node->left = node->right = nullptr;
        // 插入节点
        Node* p = root;
        while (true) {
            if (node->key < p->key) {
                if (p->left == nullptr) {
                    p->left = node;
                    break;
                } else {
                    p = p->left;
                }
            } else {
                if (p->right == nullptr) {
                    p->right = node;
                    break;
                } else {
                    p = p->right;
                }
            }
        }
    }
    return root;
}

最后，我们可以使用以下代码进行测试：

int main() {
    const int n = 10;
    int numbers[n];
    double probabilities[n];
    generateRandomNumbers(n, numbers, probabilities);
    Node* root = constructOptimalBST(n, numbers, probabilities);
    return 0;
}