[UOJ299][CTSC2017] 游戏

【CTSC2017】游戏

problem

UOJ299

solution

定义 $X_i:$ 当前已知条件第 $i$ 局的状态 $1/0$（胜/败）。

将 $X_i=C_i$ 记为事件 $A_i$。

假设现在已知条件共有 $s$ 个，即：第 $k_{1\sim s}$ 局的胜负状态。

期望不妨拆成求和每一局获胜的概率。

那么答案为 ${\sum }_{i=1}^{n}P(X_i=1|A_{k_1}{A}_{k_2}...A_{ks})$

$P(X_i=1|A_{k_1}{A}_{k_2}...A_{ks})=\frac{P(X_i=1\cdot A_{k_1}...A_{k_s})}{P(A_{k_1}...A_{k_s})}$

$P(A_{k_1}...A_{k_s})=P(A_{k_1})P(A_{k_2}|A_{k_1})P(A_{k_3}|A_{k_1}{A}_{k_2})...P(A_{k_s}|A_{k_1}...A_{k_{s-1}})$

因为每一局的胜负概率只和上一局有关，所以 $P(A_{k_3}|A_{k_1}{A}_{k_2})=P(A_{k_3}|A_{k_2})$

即，$P(A_{k_1}...A_{k_s})=P(A_{k_1})P(A_{k_2}|A_{k_1})P(A_{k_3}|A_{k_2})...P(A_{k_s}|A_{k_{s-1}})$

假设 $k_1<k_2<...<k_j<i<k_{j+1}<...<k_s$

类似地，$P(X_i=1A_{k_1}...A_{k_s})=P(A_{k_1})...P(A_{k_j}|X_i=1)P(X_i=1|A_{k_{j+1}})...P(A_{k_s}|A_{k_{s-1}})$

所以 $P(X_i=1|A_{k_1}{A}_{k_2}...A_{ks})=\frac{P(A_{k_j}|X_i=1)P(X_i=1|A_{k_{j+1}})}{P(A_{k_{j+1}}|A_{k_j})}$

答案为 ${\sum }_{i=1}^n\frac{P(A_{k_j}|X_i=1)P(X_i=1|A_{k_{j+1}})}{P(A_{k_{j+1}}|A_{k_j})}$

也就是说，已知结果将 $n$ 局游戏划分成了若干段区间，每段的贡献计算的先决条件都是一样的。

也就是说每个区间的答案为 ${\sum }_{i=k_j+1}^{i=k_{j+1}-1}\frac{P(A_{k_j}|X_i=1)P(X_i=1|A_{k_{j+1}})}{P(A_{k_{j+1}}|A_{k_j})}$

设 $Q(r|l):$ 第 $l$ 局 $R$ 赢的情况下，第 $r$ 局 $R$ 赢的概率，$\sim l$ 则表示第 $l$ 局 $R$ 输。

显然有，$Q(l+1|l)=p[l+1]$，再考虑计算 $Q(l+2|l)$。
$$\begin{gathered} Q(l+2|l)=Q(l+2|l+1)\cdot Q(l+1|l)+Q(l+2|\sim (l+1))\cdot Q(\sim (l+1)|l) \\ =p[l+2]\cdot p[l+1]+q[l+2]\cdot (1-p[l+1]) \end{gathered}$$
同理可计算出，$Q(l+2|\sim l),Q(\sim (l+2)|l),Q(\sim (l+2)|\sim l)$

发现，这其实是两个矩阵相乘的结果，即 $f_{l+1}\cdot f_{l+2}$

$f_i=\left[\begin{array}{c}1-q_i{q}_i\\ 1-p_i{p}_i\end{array}\right]$

可以继续这么归纳下去，计算 $Q(r|l)$ 等相关信息，无非就是一个连续区间的矩阵相乘后某个位置的结果。

${\sum }_{i=k_j+1}^{i=k_{j+1}-1}\frac{P(A_{k_j}|X_i=1)P(X_i=1|A_{k_{j+1}})}{P(A_{k_{j+1}}|A_{k_j})}$，用线段树维护矩阵 $f$。

分母就是 $f$ 矩阵从 $k_j$ 一直乘到 $k_{j+1}$。

分子就是 $f$ 矩阵乘到 $i$ 位置时，只乘第二列（表示胜利），可以新定义一个矩阵 $g_i$。

$g_i=\left[\begin{array}{c}0q_i\\ 0p_i\end{array}\right]$，在乘到 $i$ 位置时变成乘 $g_i$。

同样用线段树维护，$g_{now}=f_{lson}\ast g_{rson}+g_{lson}\ast f_{rson};f_{now}=f_{lson}\ast g_{rson}$

最后就是具体实现问题了。

考虑插入两个哨兵 $0,n+1$，初始局面答案就是一整个区间。

有涉及到询问当前已知条件中的前驱 $l$ 后继 $r$ 问题，就需要用 STL 实现。

加点就用答案减去区间 $(l,r)$ 的贡献，再加上区间 $(l,i)$ 和区间 $(i,r)$ 的贡献。

删点就用答案减去区间 $(l,i)$ 和区间 $(i,r)$ 的贡献，再加上区间 $(l,r)$ 的贡献。

code

#include <map>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct matrix {
    double c[2][2];
    // double * operator [] ( int x ) { return c[x]; }
    matrix() { memset( c, 0, sizeof( c ) ); }
    friend matrix operator + ( matrix u, matrix v ) {
        matrix ans;
        for( int i = 0;i < 2;i ++ )
            for( int j = 0;j < 2;j ++ )
                ans.c[i][j] = v.c[i][j] + u.c[i][j];
        return ans;
    }
    friend matrix operator * ( matrix u, matrix v ) {
        matrix ans;
        for( int i = 0;i < 2;i ++ )
            for( int j = 0;j < 2;j ++ )
                for( int k = 0;k < 2;k ++ )
                    ans.c[i][j] += u.c[i][k] * v.c[k][j];
        return ans;
    }
    void print() {
        for( int i = 0; i < 2; i ++ ) {
            for( int j = 0; j < 2; j ++ )
                printf( "%.3f ", c[i][j] );
            printf( "\n" );
        }
    }
};
#define maxn 200005
struct node { matrix f, g; }t[maxn << 2];
int n, m;
char type;
double ans;
double p[maxn], q[maxn];
map < int, bool > x;

#define lson now << 1
#define rson now << 1 | 1
#define mid ( ( l + r ) >> 1 )

node operator + ( node x, node y ) {
    node ans;
    ans.f = x.f * y.f;
    ans.g = x.g * y.f + x.f * y.g;
    return ans;
}

void build( int now, int l, int r ) {
    if( l == r ) {
        t[now].f.c[0][0] = 1 - q[l];
        t[now].f.c[0][1] = t[now].g.c[0][1] = q[l];
        t[now].f.c[1][0] = 1 - p[l];
        t[now].f.c[1][1] = t[now].g.c[1][1] = p[l];
        // printf( "(%d):\n", l );
        // t[now].f.print();t[now].g.print();
        return;
    }
    build( lson, l, mid );
    build( rson, mid + 1, r );
    t[now] = t[lson] + t[rson];
    // printf( "{ %d } [%d, %d] ::\n", now, l, r );
    // t[now].f.print(); t[now].g.print();
}

node query( int now, int l, int r, int L, int R ) {
    if( L <= l and r <= R ) return t[now];
    if( R <= mid ) return query( lson, l, mid, L, R );
    else if( mid < L ) return query( rson, mid + 1, r, L, R );
    else return query( lson, l, mid, L, R ) + query( rson, mid + 1, r, L, R );
}

double Ask( int l, int r ) {
    node now = query( 1, 0, n + 1, l + 1, r );
    // now.f.print(); now.g.print();
    return now.g.c[x[l]][x[r]] / now.f.c[x[l]][x[r]];
}

int main() {
    scanf( "%d %d %c %lf", &n, &m, &type, &p[1] );
    for( int i = 2;i <= n;i ++ ) scanf( "%lf %lf", &p[i], &q[i] );
    p[0] = q[0] = x[0] = 1, x[n + 1] = 0;
    build( 1, 0, n + 1 );
    ans = Ask( 0, n + 1 );
    // printf( "%f\n", ans );
    while( m -- ) {
        char opt[10]; int i, c;
        scanf( "%s", opt );
        if( opt[0] == 'a' ) {
            scanf( "%d %d", &i, &c );
            auto r = x.lower_bound( i );
            auto l = r;
            l --;
            x[i] = c;
            ans -= Ask( l -> first, r -> first );
            ans += Ask( l -> first, i );
            ans += Ask( i, r -> first );
        }
        else {
            scanf( "%d", &i );
            auto r = x.upper_bound( i );
            auto l = r;
            l --, l --;
            ans -= Ask( l -> first, i );
            ans -= Ask( i, r -> first );
            ans += Ask( l -> first, r -> first );
            x.erase( ++ l );
        }
        printf( "%f\n", ans );
    }
    return 0;
}