[jzoj5233]概率博弈（树形DP）

Description

小A和小B在玩游戏。这个游戏是这样的：

有一棵?个点的以1为根的有根树，叶子有权值。假设有?个叶子，那么树 上每个叶子的权值序列就是一个1 → ?的排列。

一开始在1号点有一颗棋子。两人轮流将这颗棋子移向其当前位置的一个 儿子。假如棋子到达叶子，游戏结束，最终获得的权值为所在叶子对应权值。

小A希望最后的权值尽量大，小B希望尽量小。小A是先手。

在玩了很多局游戏后，小B对其中绝大多数局游戏的结果不满意，他觉得 是小A对叶子权值做了手脚。于是他一怒之下，决定将叶子的权值随机排列。现 在小B想知道，假如叶子的权值是随机排列的（即叶子权值的每种排列都以等概 率出现），那么游戏期望的结果是多少？

请输出答案乘上?!对\(10^9+7\)取模的结果，显然这是一个整数。

Solution

真是一道有趣的题，经过和各位信息界的学长讨论后写了一篇题解，

首先这是一道树形DP，结合了概率与期望（其实没有用到），

我们考虑最后取到值>=k的方案数为\(F(k)\)，那么取到等于k的方案数就为\(F(k)-F(k+1)\)，

我们把>=k的叶节点权值设为1，否则为0，

那么我们设\(f[u][i][0/1]\)表示以u为根节点下有i个叶节点为1且想走到1(小A)或0(小B)的方案数

在树上做动规，具体转移方程见代码，不好说，有点复杂

题目要求最后把期望乘上m!就相当于m的所有全排列取到值之和，

因为要把0/1具体化，最后答案就为\(\sum{f[1][k][1]*k!*(m-k)!}, 1\leq k\leq m\)

Code

#include <cstdio>
#include <algorithm>
#include <cstring>
#define N 5010
using namespace std;

const int yh = 1e9 + 7;
struct info {
    int to, nex;
} e[N * 2];
int n, m, tot, head[N * 2];
int fac[N], Ans;
long long f[N][N][2], g[N][2];

inline int read() {
    int x = 0, f = 1; char ch = getchar();
    while (ch < '0' || ch > '9') {if (ch == '-')f = -1; ch = getchar();}
    while (ch >= '0' && ch <= '9') {x = x * 10 + ch - '0'; ch = getchar();}
    return x * f;
}

void add_edge(int u, int v) {
    e[++tot].to = v;
    e[tot].nex = head[u];
    head[u] = tot;
}

int DP(int u, int fa, int x) {
    int su = 0, sv;
    for (int i = head[u]; i; i = e[i].nex) {
        int v = e[i].to;
        if (v == fa) continue;
        sv = DP(v, u, x ^ 1);
        if (!su) {
            memcpy(f[u], f[v], sizeof(f[v]));
            su = sv;
            continue;
        }

        memset(g, 0, sizeof(g));
        for (int i = 0; i <= su; ++i)
            for (int j = 0; j <= sv; ++j) {
                int k = i + j;
                long long t = (f[u][i][x ^ 1] * 1ll * f[v][j][x ^ 1]) % yh;
                long long p = f[u][i][x] + f[u][i][x ^ 1];
                long long q = f[v][j][x] + f[v][j][x ^ 1];
                g[k][x ^ 1] = (g[k][x ^ 1] + t) % yh;
                g[k][x] = (g[k][x] + p * 1ll * q % yh - t) % yh;
            }
        memcpy(f[u], g, sizeof(g));
        su += sv;
    }

    if (!su) f[u][++su][1] = f[u][0][0] = 1;
    return su;
}

int main() {
    n = read();
    for (int i = 1; i < n; ++i) {
        int u = read(), v = read();
        add_edge(u, v);
        add_edge(v, u);
    }
    m = DP(1, 0, 1);
    fac[0] = 1;
    for (int i = 1; i <= m; ++i) fac[i] = (1ll * fac[i - 1] * i) % yh;
    for (int i = 1; i <= m; ++i)
        Ans = (Ans + (1ll * f[1][i][1] * fac[i] % yh * fac[m - i]) % yh) % yh;
    printf("%d\n", Ans);
    return 0;
}

转载于:https://www.cnblogs.com/void-f/p/7721884.html