2023-09-23：用go语言，假设每一次获得随机数的时候，这个数字大于100的概率是P。
尝试N次，其中大于100的次数在A次~B次之间的概率是多少?
0 < P < 1, P是double类型，
1 <= A <= B <= N <= 100。
来自左程云。
答案2023-09-23：
首先，我们可以使用动态规划来解决这个问题。我们可以定义一个二维数组dp，其中dp[i][j]表示在i次尝试中，获得j次大于100的随机数的概率。
然后，我们可以使用递归的方式计算dp[i][j]。具体地说，我们可以将每一次尝试分为两种情况：获得大于100的随机数和获得小于等于100的随机数。如果我们获得大于100的随机数，则剩余的i-1次尝试中，我们需要获得j-1次大于100的随机数；如果我们获得小于等于100的随机数，则剩余的i-1次尝试中，我们还需要获得j次大于100的随机数。我们可以使用更大的P表示获得大于100的随机数的概率，用1-P表示获得小于等于100的随机数的概率。
递归的边界条件是如果i为0且j为0，则表示已经没有剩余的尝试次数，并且已经获得了所需的j次大于100的随机数，所以概率为1；如果i为0且j不为0，则表示已经没有剩余的尝试次数，但是还没有满足所需的j次大于100的随机数，所以概率为0。
为了避免重复计算，我们可以使用一个二维数组dp来保存计算过的结果。在每次计算前，先检查dp[i][j]是否已经计算过，如果是，则直接返回结果。
最后，在主函数中，我们可以调用probability函数来计算概率，并打印结果。
总的时间复杂度和额外空间复杂度分别为O(N^2)，因为需要计算dp数组的所有元素。
go完整代码如下：
go
package main
import "fmt"
func probability(P float64, N int, A int, B int) float64 {
dp := make([][]float64, N+1)
for i := 0; i <= N; i++ {
dp[i] = make([]float64, N+1)
for j := 0; j <= N; j++ {
dp[i][j] = -1
}
}
ans := 0.0
for j := A; j <= B; j++ {
ans += process(P, 1-P, N, j, dp)
}
return ans
}
func process(more, less float64, i, j int, dp [][]float64) float64 {
if i < 0 || j < 0 || i < j {
return 0
}
if i == 0 && j == 0 {
return 1
}
if dp[i][j] != -1 {
return dp[i][j]
}
ans := more*process(more, less, i-1, j-1, dp) + less*process(more, less, i-1, j, dp)
dp[i][j] = ans
return ans
}
func main() {
P := 0.6
N := 100
A := 30
B := 50
fmt.Println(probability(P, N, A, B))
}
rust完整代码如下：
rust
fn probability(p: f64, n: i32, a: i32, b: i32) -> f64 {
let mut dp: Vec<Vec<f64>> = vec![vec![-1.0; (n + 1) as usize]; (n + 1) as usize];
let mut ans = 0.0;
for j in a..=b {
ans += process(p, 1.0 - p, n, j, &mut dp);
}
ans
}
fn process(more: f64, less: f64, i: i32, j: i32, dp: &mut Vec<Vec<f64>>) -> f64 {
if i < 0 || j < 0 || i < j {
return 0.0;
}
if i == 0 && j == 0 {
return 1.0;
}
if dp[i as usize][j as usize] != -1.0 {
return dp[i as usize][j as usize];
}
let ans = more * process(more, less, i - 1, j - 1, dp) + less * process(more, less, i - 1, j, dp);
dp[i as usize][j as usize] = ans;
ans
}
fn main() {
let p = 0.6;
let n = 100;
let a = 30;
let b = 50;
println!("{}", probability(p, n, a, b));
}
c++完整代码如下：
cpp
#include <iostream>
#include <vector>
double process(double more, double less, int i, int j, std::vector<std::vector<double>>& dp);
double probability(double P, int N, int A, int B) {
std::vector<std::vector<double>> dp(N + 1, std::vector<double>(N + 1, -1));
double ans = 0;
for (int j = A; j <= B; j++) {
ans += process(P, 1 - P, N, j, dp);
}
return ans;
}
double process(double more, double less, int i, int j, std::vector<std::vector<double>>& dp) {
if (i < 0 || j < 0 || i < j) {
return 0;
}
if (i == 0 && j == 0) {
return 1;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
double ans = more * process(more, less, i - 1, j - 1, dp) + less * process(more, less, i - 1, j, dp);
dp[i][j] = ans;
return ans;
}
int main() {
double P = 0.6;
int N = 100;
int A = 30;
int B = 50;
std::cout << probability(P, N, A, B) << std::endl;
return 0;
}
c完整代码如下：
c
#include <stdio.h>
#include <stdlib.h>
double probability(double P, int N, int A, int B);
double process(double more, double less, int i, int j, double** dp);
double probability(double P, int N, int A, int B) {
double** dp = (double**)malloc((N + 1) * sizeof(double*));
for (int i = 0; i <= N; i++) {
dp[i] = (double*)malloc((N + 1) * sizeof(double));
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= N; j++) {
dp[i][j] = -1;
}
}
double ans = 0;
for (int j = A; j <= B; j++) {
ans += process(P, 1 - P, N, j, dp);
}
for (int i = 0; i <= N; i++) {
free(dp[i]);
}
free(dp);
return ans;
}
double process(double more, double less, int i, int j, double** dp) {
if (i < 0 || j < 0 || i < j) {
return 0;
}
if (i == 0 && j == 0) {
return 1;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
double ans = more * process(more, less, i - 1, j - 1, dp) + less * process(more, less, i - 1, j, dp);
dp[i][j] = ans;
return ans;
}
int main() {
double P = 0.6;
int N = 100;
int A = 30;
int B = 50;
printf("%f\n", probability(P, N, A, B));
return 0;
}