HDU 4649 Professor Tian（概率DP）题解

Posted 2022-04-05 kirinsb

题意：一个表达式，n + 1个数，n个操作，每个操作Oi和数Ai+1对应，给出每个操作Oi和数Ai+1消失的概率，给出最后表达式值得期望。只有| ， ^，&三个位操作

思路：显然位操作只对当前位相关，那么我们可以一位一位求解，算出每一位的概率，然后算出这一位所给出的贡献的期望。

代码：

#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include <iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn = 200 + 10;
const int M = maxn * 30;
const ull seed = 131;
const int INF = 0x3f3f3f3f;
const int MOD = 1e4 + 7;
double dp[maxn][2], poss[maxn];
int a[maxn];
char op[maxn][2];
int main()
    int n, ca = 1;
    while(~scanf("%d", &n))
        for(int i = 0; i <= n; i++)
            scanf("%d", &a[i]);
        
        for(int i = 1; i <= n; i++)
            scanf("%s", op[i]);
        
        for(int i = 1; i <= n; i++)
            scanf("%lf", &poss[i]);
        
        for(int i = 0; i < 20; i++)
            if(a[0] & (1 << i))
                dp[i][1] = 1;
                dp[i][0] = 0;
            
            else
                dp[i][1] = 0;
                dp[i][0] = 1;
            
        
        double ans = 0;
        for(int k = 0; k < 20; k++)
            for(int i = 1; i <= n; i++)
                int bit = (1 << k) & a[i];
                double pre0 = dp[k][0], pre1 = dp[k][1];
                if(op[i][0] == ‘&‘)
                    if(bit)
                        dp[k][1] = pre1;
                        dp[k][0] = pre0;
                    
                    else
                        dp[k][1] = pre1 * poss[i];
                        dp[k][0] = pre0 * (1 - poss[i]) + pre0 * poss[i] + pre1 * (1 - poss[i]);
                    
                
                else if(op[i][0] == ‘|‘)
                    if(bit)
                        dp[k][1] = pre0 * (1 - poss[i]) + pre1;
                        dp[k][0] = pre0 * poss[i];
                    
                    else
                        dp[k][1] = pre1;
                        dp[k][0] = pre0;
                    
                
                else   // ^
                    if(bit)
                        dp[k][1] = pre1 * poss[i] + pre0 * (1 - poss[i]);
                        dp[k][0] = pre0 * poss[i] + pre1 * (1 - poss[i]);
                    
                    else
                        dp[k][1] = pre1;
                        dp[k][0] = pre0;
                    
                
            
//            printf("* %f %f\n", dp[k][0], dp[k][1]);
            ans += dp[k][1] * double(1 << k);
        
        printf("Case %d:\n%.6f\n", ca++, ans);
    
    return 0;