[UOJ299][CTSC2017] 游戏

最新推荐文章于 2022-04-26 21:30:20 发布

原创最新推荐文章于 2022-04-26 21:30:20 发布 · 1.9k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#概率论 #动态规划 #算法

普通/值域/势能/李超/可持久化线段树同时被 2 个专栏收录

59 篇文章

订阅专栏

概率与期望

17 篇文章

订阅专栏

【CTSC2017】游戏

problem

UOJ299

solution

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

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

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

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

那么答案为 $\sum_{i=1}^nP(X_i=1\Big|A_{k_1}A_{k_2}...A_{ks})$

$P(X_i=1\Big|A_{k_1}A_{k_2}...A_{ks})=\frac{P(X_i=1·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\Big|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$ 输。

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

$f_{i}=\begin{bmatrix}1-q_i\quad\quad q_i\\1-p_i\quad\quad p_i\end{bmatrix}$

可以继续这么归纳下去，计算 $Q(r\Big|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}=\begin{bmatrix}0\quad\quad q_i\\0\quad\quad p_i\end{bmatrix}$ ，在乘到 $i$ 位置时变成乘 $g_i$ 。

同样用线段树维护， $g_{now}=f_{lson}*g_{rson}+g_{lson}*f_{rson};f_{now}=f_{lson}*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;
}