动态规划计算连续成功概率期望值

1. 问题背景与理解

我们先来理解一下这个简化版osu游戏的规则。游戏由n次操作组成，每次操作有成功（记为1）和失败（记为0）两种结果。每个操作的成功概率是给定的，我们需要计算所有可能的01串对应的分数期望值。

关键计分规则是：对于极长的连续1串（即不被其他1包含的最长连续1串），长度为X的串贡献X³分。例如：

• "0110"中有两个长度为1的1串，总分为1³ + 1³ = 2
• "0111"中有一个长度为3的1串，总分为3³ = 27
• "1011"中有一个长度为1和一个长度为2的1串，总分为1³ + 2³ = 9

2. 动态规划解法分析

2.1 基本思路

直接计算所有可能的01串并求期望显然不可行，因为时间复杂度是O(2ⁿ)。我们需要找到一种更高效的方法来计算期望值。

动态规划是解决这类期望计算问题的有效方法。我们可以定义几个辅助数组来记录不同阶的期望值：

• b[i]：表示以第i次操作结尾的连续1的期望长度
• c[i]：表示以第i次操作结尾的连续1的平方期望长度
• d[i]：表示前i次操作的总期望分数

2.2 递推公式推导

对于第i次操作，有两种可能：

1. 操作成功（概率a[i]）
   • 连续1的长度增加1
   • 连续1长度的平方增加2*当前长度+1
   • 连续1长度的立方增加3当前平方长度+3当前长度+1
2. 操作失败（概率1-a[i]）
   • 连续1的长度、平方长度和立方贡献都重置为0

因此，递推公式为：

code复制b[i] = (b[i-1] + 1) * a[i]
c[i] = (c[i-1] + 2*b[i-1] + 1) * a[i]
d[i] = d[i-1] + (3*c[i-1] + 3*b[i-1] + 1) * a[i]

2.3 时间复杂度分析

这个算法只需要遍历一次所有操作，每个操作执行固定数量的计算，因此时间复杂度是O(n)，空间复杂度也是O(n)（可以优化到O(1)）。

3. 代码实现详解

3.1 变量定义

c复制#include<stdio.h>
#define R register
#define N 100001

int m;  // 操作次数
double a[N], b[N], c[N], d[N];  // 概率和三个辅助数组

3.2 主函数逻辑

c复制int main(void)
{
    scanf("%d",&m);  // 读取操作次数
    
    // 遍历每个操作
    for(R int i=1; i<=m; i++)
    {
        scanf("%lf",&a[i]);  // 读取当前操作的成功概率
        
        // 计算以i结尾的连续1的期望长度
        b[i]=(b[i-1]+1)*a[i];
        
        // 计算以i结尾的连续1的平方期望长度
        c[i]=(c[i-1]+b[i-1]*2+1)*a[i];
        
        // 计算前i次操作的总期望分数
        d[i]=d[i-1]+(c[i-1]*3+b[i-1]*3+1)*a[i];
    }
    
    // 输出结果，保留1位小数
    printf("%.1lf",d[m]);
    return 0;
}

3.3 代码优化空间

虽然这个实现已经足够高效，但我们还可以进行一些优化：

1. 空间优化：由于每个状态只依赖于前一个状态，我们可以只保存前一个状态的值，将空间复杂度从O(n)降到O(1)
2. 输入优化：使用更快的输入方法（如fread）处理大量输入数据
3. 循环展开：对于特别大的n，可以考虑循环展开来提升性能

4. 示例解析

让我们用题目中的样例来验证这个算法：

输入：

code复制3
0.5
0.5
0.5

计算过程：

1. i=1:
   • b[1] = (0+1)*0.5 = 0.5
   • c[1] = (0+0+1)*0.5 = 0.5
   • d[1] = 0 + (0+0+1)*0.5 = 0.5
2. i=2:
   • b[2] = (0.5+1)*0.5 = 0.75
   • c[2] = (0.5+1+1)*0.5 = 1.25
   • d[2] = 0.5 + (1.5+1.5+1)*0.5 = 2.5
3. i=3:
   • b[3] = (0.75+1)*0.5 = 0.875
   • c[3] = (1.25+1.5+1)*0.5 = 1.875
   • d[3] = 2.5 + (5.625+2.625+1)*0.5 = 6.0

最终输出6.0，与题目给出的样例结果一致。

5. 数学原理深入

5.1 期望的线性性质

这个解法利用了期望的线性性质：E[X³]可以通过分解为E[X]、E[X²]等低阶期望来计算。具体来说：

对于连续1的长度X，当新增一个1时：

• X → X+1
• X² → X² + 2X + 1
• X³ → X³ + 3X² + 3X + 1

因此，我们可以分别维护X、X²和X³的期望值。

5.2 递推关系证明

让我们更严格地证明递推关系的正确性：

定义：

• l[i]：以i结尾的连续1的长度
• s[i]：以i结尾的连续1的长度的平方
• f[i]：前i次操作的总分数

对于第i次操作：

1. 如果成功（概率a[i]）：
   • l[i] = l[i-1] + 1
   • s[i] = (l[i-1]+1)² = l[i-1]² + 2l[i-1] + 1
   • f[i] = f[i-1] + (l[i]³ - l[i-1]³) = f[i-1] + 3l[i-1]² + 3l[i-1] + 1
2. 如果失败（概率1-a[i]）：
   • l[i] = 0
   • s[i] = 0
   • f[i] = f[i-1]

因此，期望值为：
E[l[i]] = (E[l[i-1]] + 1) * a[i]
E[s[i]] = (E[s[i-1]] + 2E[l[i-1]] + 1) * a[i]
E[f[i]] = E[f[i-1]] + (3E[s[i-1]] + 3E[l[i-1]] + 1) * a[i]

这与我们的递推公式完全一致。

6. 常见问题与调试技巧

6.1 精度问题

由于题目要求保留1位小数，而概率是实数，需要注意：

1. 使用double类型而不是float，保证足够的精度
2. 输出时使用"%.1lf"格式，确保四舍五入正确
3. 避免在中间计算过程中累积过多舍入误差

6.2 边界情况

需要特别注意的边界情况包括：

1. n=0时，分数应为0
2. 所有概率为1时，分数应为n³
3. 所有概率为0时，分数应为0
4. 某些概率为1，某些为0时的混合情况

6.3 调试建议

如果实现结果不正确，可以：

1. 打印中间变量b、c、d的值，检查递推过程
2. 对小规模样例手动计算，与程序输出对比
3. 检查数组是否越界（特别是i=1时的边界处理）
4. 验证输入是否正确读取（特别是大量数据时）

7. 算法扩展与变种

这个问题的解法可以推广到更一般的情况：

7.1 不同幂次的分数计算

如果分数计算规则改为连续X个1贡献Xᵏ分，我们可以类似地维护k个辅助数组，分别表示X、X²,...,Xᵏ⁻¹的期望值。

7.2 更复杂的计分规则

对于更复杂的计分规则（如分段函数），可能需要调整动态规划的状态定义和转移方程。

7.3 空间优化实现

如前所述，我们可以只保存前一个状态的值，将空间复杂度优化到O(1)：

c复制double a, b = 0, c = 0, d = 0;
for(int i=1; i<=m; i++) {
    scanf("%lf",&a);
    double new_b = (b + 1) * a;
    double new_c = (c + 2*b + 1) * a;
    d = d + (3*c + 3*b + 1) * a;
    b = new_b;
    c = new_c;
}
printf("%.1lf",d);

8. 实际应用与类似问题

这种动态规划方法在概率和期望计算中非常常见，类似的题目包括：

1. 连续命中奖励的游戏计分系统
2. 质量控制中的连续合格品统计
3. 信号处理中的连续脉冲检测
4. 生物信息学中的连续模式识别

理解这个问题的解法有助于解决一大类期望计算和动态规划问题。关键在于如何定义合适的状态变量，并建立它们之间的递推关系。