hdu 4649 Professor Tian

题目：Professor Tian

题意：给你n+1个数字和n个操作（&，^，|），对于每个操作和操作后面的数字，可能出现消失的概率，求最后的期望。

思路：虽然标程说是反状态dp，可是好像之前貌似没有听说过这个东西，不过因为各种操作是不存在进位的现象的，所以我们可以单独考虑对于每一位消失或不消失进行讨论（尼玛，这就是反状态？dp？）

所以dp方程就是 dp[i][j] 表示前 i 位出现结果为 j 的概率，那么最后的答案就是 dp[n][1] * (1<<i) 累积的和

具体的看代码吧。

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <vector>
#include <map>
using namespace std;
const int maxn = 210;
double p[maxn];
char op[maxn];
int a[maxn];
double dp[21][2];
int main()
{
    int t=0;
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<=n;i++)
            scanf("%d",&a[i]);
        getchar();
        for(int i=1;i<=n;i++)
            scanf("%c%*c",&op[i]);
        for(int i=1;i<=n;i++)
            scanf("%lf",&p[i]);

        double ans=0;
        for(int i=0;i<20;i++)
        { // 逐位考虑
            dp[0][1]=(a[0]>>i)&1;
            dp[0][0]=!(int)dp[0][1];

            for(int j=1;j<=n;j++)
            {
                // 第j位消失
                dp[j][0]=dp[j-1][0]*p[j];
                dp[j][1]=dp[j-1][1]*p[j];

                // 第j位不消失
                if(op[j]=='^')
                {
                    if((a[j]>>i)&1)
                    {
                        dp[j][0]+=dp[j-1][1]*(1-p[j]);
                        dp[j][1]+=dp[j-1][0]*(1-p[j]);
                    }
                    else
                    {
                        dp[j][0]+=dp[j-1][0]*(1-p[j]);
                        dp[j][1]+=dp[j-1][1]*(1-p[j]);
                    }
                }
                else if(op[j]=='&')
                {
                    if((a[j]>>i)&1)
                    {
                        dp[j][0]+=dp[j-1][0]*(1-p[j]);
                        dp[j][1]+=dp[j-1][1]*(1-p[j]);
                    }
                    else
                    {
                        dp[j][0]+=(dp[j-1][0]+dp[j-1][1])*(1-p[j]);
                    }
                }
                else if(op[j]=='|')
                {
                    if((a[j]>>i)&1)
                    {
                        dp[j][1]+=(dp[j-1][1]+dp[j-1][0])*(1-p[j]);
                    }
                    else
                    {
                        dp[j][1]+=dp[j-1][1]*(1-p[j]);
                        dp[j][0]+=dp[j-1][0]*(1-p[j]);
                    }
                }
            }
            ans+=dp[n][1]*(1<<i);
        }
        printf("Case %d:\n%lf\n",++t,ans);
    }
    return 0;
}