数学专题训练1

1. RollingDiceDivOne

有 $n$ 个骰子，第 $i$ 个骰子拥有 $d i ce [i]$ 面，每面包含 $1, 2, ..., d i ce [i]$ 的点数。同时掷这 $n$ 个骰子，问掷出来的各个骰子的总点数是多少的概率最高，如果有多个答案，返回最小的那个。

数据规模：n为 $[1, 50]$ ，每个骰子的面数取值范围为 $1,10^9]$

列一个表格找规律便可以发现

列表一定是对称的

如果列表的长度大于等于骰子的面数，列表中间值一定是极值点。
如果以上不成立，那么第一个新极值点数在最终列表中的位置肯定是“当前列表长度-1”。

public class RollingDiceDivOne {
    public long mostLikely(int[] dice) {
        long sum = 0;
        int max = 0;
        for (int die : dice) {
            sum += die - 1;
            max = Math.max(max, die - 1);
        }
        return dice.length + Math.min(sum / 2, sum - max);
    }
}

2. CoinReversing

记住 $E (X + Y) = E (X) + E (Y)$ 不需要满足 $X$ 和 $Y$ 相互独立.

假设第 $i$ 次选择的事件记为 $X_i$ ，则选择第 $j$ 个硬币正面朝上记作 $X_{i,j}$ . 则 $X_i = X_{i,1} + X_{i,2} + ... + X_{i,n}$ . 那么 $E(X_i) = \sum\limits_{j=1}^{n}E(X_{i,j})$ . 我们还知道第 $i$ 次选择，第 $j$ 个硬币被选到的概率是 $\frac{a_i}{n}$ . 不妨定义 $a_0 = 0,E(X_0) = n$ .

那么， $E(X_{i,j}) = E(X_{i-1,j}) * (1-p) + E(\overline{X_{i-1,j}}) * p$ .

所以， $E(X_{i}) = E(X_{i-1}) * (1-p) + E(\overline{X_{i-1}}) * p$

3. Aeroplane chess

问路径的期望长度，从起点开始搜。

#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
double f[N];
int n, m;
unordered_map<int, int> mp;

double dp(int x)
{
    if(f[x] >= 0) return f[x];
    if(x >= n) return 0;
    f[x] = 0;
    if(mp.count(x)) f[x] += dp(mp[x]);
    else for(int i = 1; i <= 6; i++)
    {
        f[x] += 1.0 / 6 * (dp(x + i) + 1);
    }
    return f[x];
}

int main()
{
    while(cin >> n >> m, n || m)
    {
        mp.clear();
        fill(f, f + N, -1);
        //memset(f, -1, sizeof f);
        for(int i = 1; i <= m; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            mp[x] = y;
        }
        printf("%.4f\n", dp(0));
    }
    return 0;
}

4. Card Collector

$f [S]$ 在等式两边同时出现，因此把 $f [S]$ 移项到同一侧即可.

#include<bits/stdc++.h>
using namespace std;
const int N = (1 << 20);
double f[N], p[25];
int n;
double dp(int x)
{
    if(f[x] >= 0) return f[x];
    f[x] = 0;
    double P = 0;
    bool flag = false;
    for(int i = 0; i < n; i++)
    {
        if(!(x >> i & 1)) P += p[i], flag = true;
    }
    if(!flag) return f[x] = 0;
    f[x] = 1 - P;
    for(int i = 0; i < n; i++)
    {
        if(!(x >> i & 1)) f[x] += (dp(x | (1 << i)) + 1) * p[i];
    }
    f[x] /= P;
    return f[x];
}
int main()
{
    while(cin >> n)
    {
        for(int i = 0; i < n; i++) scanf("%lf", &p[i]);
        memset(f, -1, sizeof f);
        printf("%.10f\n", dp(0));
    }
    return 0;
}

5. Bag of mice

求公主获胜概率

分类讨论就可以了，假设当前有 $a$ 只白鼠 $b$ 只黑鼠，那么分为：公主抓到白鼠；公主抓到黑鼠、龙抓到白鼠；公主抓到黑鼠、龙抓到白鼠、跑了白鼠；公主抓到黑鼠、龙抓到白鼠、跑了黑鼠。共四种情况。注意讨论一下边界.

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
double f[N][N];
int n, m;
double dp(int a, int b)
{
    if(a > 0 && b <= 0) return 1;
    if(a <= 0) return 0;
    if(f[a][b] >= 0) return f[a][b];

    f[a][b] = 0;
    f[a][b] += 1.0 * a / double(a + b);

    double t1 = 0, t2 = 0;
    if(b >= 2) t1 = 1.0 * b / double(a + b) * (b - 1) / double(a + b - 1);
    if(b >= 3) t2 = (b - 2) / double(a + b - 2) * dp(a, b - 3);
    if(b >= 2 && a >= 1) t2 += 1.0 * a / double(a + b - 2) * dp(a - 1, b - 2);
    f[a][b] += t1 * t2;
    return f[a][b];
}
int main()
{
    scanf("%d%d", &n, &m);
    memset(f, -1, sizeof f);
    printf("%.15f", dp(n, m));
    return 0;
}

6. Where is the canteen

题意补充：若从 $(x, y)$ 能往 $k$ 个方向走，那么往每个方向走的概率是 $\frac{1}{k}$ .

状态之间有环，要用高斯消元

有方程 $\frac{1}{4}\sum\limits_{i=1}^4(f(x + dx_i, y + dy_i) + 1)$ 由这个可以列出线性方程组，然后高斯消元求解即可

记住方程组记录的一定是可以走到的点，只标注能走到的点，不能走到的点不标注，不然会导致矩阵的秩不满从而导致多解. 不仅#走不到，不连通的点也走不到！

无解意味着从起点不能到达终点，否则一定有唯一解。不过怎么证明矩阵的秩等于 $n * m$ 呢？

#include<bits/stdc++.h>
#define x first
#define y second
using namespace std;
const int N = 230;
const double eps = 1e-9;
double f[N][N];
char s[20][20];
int n, m, ID[20][20], cnt[20][20], idx;
int sx, sy;
typedef pair<int, int> P;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};

bool bfs()
{
    //只标注能走到的点，不能走到的点不标注，不然会导致矩阵的秩不满从而导致多解.
    //不仅#走不到，不连通的点也走不到!
    idx = 0;
    memset(ID, 0, sizeof ID);
    memset(cnt, 0, sizeof cnt);

    memset(f, 0, sizeof f);
    bool flag = false;
    queue<P> que;
    que.push({sx, sy});
    ID[sx][sy] = ++idx;

    while(que.size())
    {
        auto p = que.front(); que.pop();
        int x = p.x, y = p.y;
        
        if(s[x][y] == '$')
        {
            flag = true;
            continue;
        }

        for(int i = 0; i < 4; i++)
        {
            int nx = x + dx[i], ny = y + dy[i];
            if(nx < 1 || nx > n || ny < 1 || ny > m) continue;
            if(s[nx][ny] == '#') continue;

            cnt[x][y]++;
            if(!ID[nx][ny])
            {
                ID[nx][ny] = ++idx;
                que.push({nx, ny});
            }
        }
    }
    return flag;
}

double gauss(int n)
{
    for(int r = 1, c = 1; c <= n; c++)
    {
        int t = r;
        for(int i = r; i <= n; i++)
        {
            if(fabs(f[i][c]) > fabs(f[t][c])) t = i;
        }
        if(fabs(f[t][c]) < eps) continue;

        for(int j = c; j <= n + 1; j++)
        {
            swap(f[r][j], f[t][j]);
        }

        for(int j = n + 1; j >= c; j--) f[r][j] /= f[r][c];

        for(int i = 1; i <= n; i++)
        {
            if(i == r) continue;
            if(fabs(f[i][c]) > eps)
                //循环方向别反了
                for(int j = n + 1; j >= c; j--) f[i][j] -= f[r][j] * f[i][c];
        }
        r++;
    }

    return f[ID[sx][sy]][n + 1];
}

void build_matrix()
{
    for(int x = 1; x <= n; x++)
    {
        for(int y = 1; y <= m; y++)
        {
            if(!ID[x][y]) continue;
            int id = ID[x][y];
            f[id][id] = 1;
            for(int i = 0; i < 4; i++)
            {
                int nx = x + dx[i], ny = y + dy[i];
                if(!ID[nx][ny]) continue;
                //如果 (x,y) 是终点，那么 ID[nx, ny] 可能不为 0 但是 cnt[x][y] 一定是0.
                if(cnt[x][y]) f[id][ID[nx][ny]] = -1.0 / cnt[x][y];
            }
            if(cnt[x][y]) f[id][idx + 1] = 1;
        }
    }
}

int main()
{
    while(cin >> n >> m)
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%s", s[i] + 1);
        }

        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                if(s[i][j] == '@') sx = i, sy = j;
            }
        }

        if(!bfs())
        {
            printf("-1\n");
            continue;
        }

        build_matrix();
        printf("%.6f\n", gauss(idx));
    }
    return 0;
}
/*
1 2
@$
2 2
@.
.$
1 3
@#$
2 2
#$
#@
1 4
.#$@
1 4
..$@
*/

7. 3744 – Scout YYF I

题意：在一条不满地雷的路上，你现在的起点在 $1$ 处。在 $n$ 个点处布有地雷， $1\le n\le10$ 。地雷点的坐标范围： $1,10^8]$ .

每次有 $p$ 的概率前进一步， $1 - p$ 的概率前进 $2$ 步。问顺利通过这条路的概率。就是不要走到有地雷的地方。

这样每一段只有一个地雷。我们只要求得通过每一段的概率。乘法原理相乘就是答案。对于每一段，通过该段的概率等于 1-踩到该段终点的地雷的概率。

就比如第一段 $1\sim x[1]$ . 通过该段其实就相当于是到达 $x [1] + 1$ 点。那么 $p [x [1] + 1] = 1 - p [x [1]]$ . 但是这个前提是p[1]=1,即起点的概率等于1.对于后面的段我们也是一样的假设，这样就乘起来就是答案了。

对于每一段的概率的求法可以通过矩阵乘法快速求出来。
$\begin{pmatrix}f_{i-1} & f_{i}\end{pmatrix}\begin{pmatrix}0 & 1-p \\ 1 & p \end{pmatrix}=\begin{pmatrix}f_{i} & f_{i + 1}\end{pmatrix}$

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 15;
double m[2][2];
int a[N];
double p;
void mul(double a[], double b[], double c[][2])
{
    static double tmp[2];
    memset(tmp, 0, sizeof tmp);
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            tmp[i] += b[j] * c[j][i];
        }
    }
    //printf("### %f %f\n", tmp[0], tmp[1]);
    memcpy(a, tmp, sizeof tmp);
}

void mul(double a[][2], double b[][2], double c[][2])
{
    static double tmp[2][2];
    memset(tmp, 0, sizeof tmp);
    for(int i = 0; i < 2; i++)
    {
        for(int j = 0; j < 2; j++)
        {
            for(int k = 0; k < 2; k++)
            {
                tmp[i][j] += b[i][k] * c[k][j];
            }
        }
    }
    memcpy(a, tmp, sizeof tmp);
}

double calc(int n)
{
    //转移矩阵千万别推导错了.
    m[0][0] = 0, m[0][1] = 1 - p;
    m[1][0] = 1, m[1][1] = p;
    double f[2] = {0, 1};
    n--;
    while(n)
    {
        if(n & 1) mul(f, f, m);
        //printf("***  %f %f\n", f[0], f[1]);
        mul(m, m, m);
        n >>= 1;
    }
    return f[1];
}

int main()
{
    int n;
    while(cin >> n >> p)
    {
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        double ans = 1;

        //一定要排序，不然快速幂部分就传入负数然后就超时了。
        sort(a + 1, a + n + 1);
        for(int i = 1; i <= n; i++)
        {
            ans *= 1 - calc(a[i] - a[i - 1]);
        }
        printf("%.7f\n", ans);
    }
    return 0;
}

8. Maze

有n个房间，由n-1条通道连通起来，实际上就形成了一棵树，从结点1出发，开始走，在每个结点i都有3种可能：
1.被杀死，回到结点1处（概率为ki）
2.找到出口，走出迷宫（概率为ei）
3.和该点相连有m条边，随机走一条
求：走出迷宫所要走的步数的期望值。

好难的一道题

题解

设点 $u$ 父结点为 $F_u$ ，子结点是 $Ch_u$ ，则每个结点都可以写为 $E_u = K_u * E_1 + B_u * E_{F_u} + C_u$ .

调不出来了，扔到这里

#include<bits/stdc++.h>
using namespace std;
const int N = 10010, M = 2 * N;
int h[N], e[M], ne[M], idx;
int n, dout[N];
double A[N], B[N], C[N], Q[N], E[N], K[N];
const double eps = 1e-8;

inline void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool dfs(int u, int fa)
{   int cnt = 0;
    double sumA = 0, sumB = 0, sumC = 0;
    for(int i = h[u]; i != -1; i = ne[i])
    {
        int v = e[i];
        if(v == fa) continue;
        if(!dfs(v, u)) return false;
        sumA += A[v], sumB += B[v], sumC += C[v];
        cnt++;
    }
    if(!cnt) A[u] = K[u], B[u] = 1 - K[u] - E[u], C[u] = 1 - K[u] - E[u];
    else
    {
        Q[u] = (1 - K[u] - E[u]) / dout[u];
        double tmp = 1 - Q[u] * sumB;

        if(fabs(tmp) < eps) return false;
        A[u] = (K[u] + Q[u] * sumA) / tmp;
        B[u] = Q[u] / tmp;
        C[u] = Q[u] * (dout[u] + sumC) / tmp;
        //printf("*** %d %d %.15f %f %f %f\n", u, fabs(tmp) < eps, tmp, sumB, Q[u], A[u]);
    }
    return true;
}
int kase;
int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        memset(h, -1, sizeof h);
        idx = 0;
        memset(dout, 0, sizeof dout);

        scanf("%d", &n);
        for(int i = 1; i < n; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            add(x, y), add(y, x);
            dout[x]++, dout[y]++;
        }
        for(int i = 1; i <= n; i++)
        {
            scanf("%lf%lf", &K[i], &E[i]);
            K[i] /= 100, E[i] /= 100;
        }
        printf("Case %d: ", ++kase);
        if(dfs(1, -1) && fabs(A[1] - 1) > eps) printf("%.10f\n", C[1] / (1 - A[1]));
        else printf("impossible\n");

        //printf("### %f %f %f %f\n", A[1], B[1], C[1], Q[1]);
    }
    return 0;
}
/*
1
3
1 2
2 3
0 0
100 0
0 100
*/

9. LOOPS

题意：迷宫是一个R*C的布局，每个格子中给出停留在原地，往右走一个，往下走一格的概率，起点在(1,1)，终点在(R,C)，每走一格消耗两点能量，求出最后所需要的能量期望

入门级概率dp. 题面有两个问题，一个是没说多组数据（不过话说杭电的题目一般都是多组测试数据）；一个是如果到了一个方格，这个方格只能到达自己，那么这点的期望是0.

#include<bits/stdc++.h>
using namespace std;
const int N = 1010;
const double eps = 1e-8;
double f[N][N], k1[N][N], k2[N][N], k3[N][N];
int n, m;
double dp(int x, int y)
{
    if(f[x][y] >= 0) return f[x][y];
    f[x][y] = 0;
    if(fabs(1 - k1[x][y]) > eps)
    {
        f[x][y] += 2 * k1[x][y] / (1 - k1[x][y]);
        if(y < m) f[x][y] += double(k2[x][y]) / (1.0 - k1[x][y]) * (dp(x, y + 1) + 2);
        if(x < n) f[x][y] += double(k3[x][y]) / (1.0 - k1[x][y]) * (dp(x + 1, y) + 2);
    }
    return f[x][y];
}
int main()
{
    while(cin >> n >> m)
    {
        memset(f, -1, sizeof f);
        f[n][m] = 0;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                scanf("%lf%lf%lf", &k1[i][j], &k2[i][j], &k3[i][j]);
            }
        }
        printf("%.3f\n", dp(1, 1));
    }
    return 0;
}

10. Check the difficulty of problems

题意：有 $t$ 支队伍， $m$ 道题，问保证每队最少做一题，冠军最少做 $n$ 题的概率

和期望没什么关系

11. Football

$2^n$ 个队进行足球赛淘汰赛（两支相邻的队伍比赛淘汰一只，即第 $x$ 只与第 $\oplus 1$ 队伍比赛），每个队打败另外一个队都有一个概率。问最后胜利的概率最大的是哪只球队。

设 $f (x, i)$ 为第 $x$ 只队伍在第 $i$ 轮胜利的概率。那么在第 $i$ 轮和他比赛的队伍为 $/2^i) \oplus 1) * 2^i +(0 \sim 2^i - 1)$ .

那么就是 $\sum f(id, i - 1) * g(x,id)$ .

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = (1 << 8);
int n;
double g[N][N], f[N][8];
int main()
{
    while(cin >> n && n != -1)
    {
        memset(f, 0, sizeof f);
        for(int i = 0; i < (1 << n); i++)
        {
            for(int j = 0; j < (1 << n); j++)
            {
                scanf("%lf", &g[i][j]);
            }
        }
		//注意枚举顺序不要错.
        for(int i = 0; i < n; i++)
        {
            for(int x = 0; x < (1 << n); x++)
            {
                if(i == 0)
                {
                    f[x][i] = g[x][x ^ 1];
                }
                else
                {
                    int id = ((x >> i) ^ 1) << i;
                    for(int d = 0; d < (1 << i); d++)
                    {
                        f[x][i] += f[id + d][i - 1] * g[x][id + d];
                    }
                    f[x][i] *= f[x][i - 1];
                }
            }
        }
        int ans = 0;
        double res = f[0][n - 1];
        for(int i = 0; i < (1 << n); i++)
        {
            if(res < f[i][n - 1]) res = f[i][n - 1], ans = i;
        }
        printf("%d\n", ans + 1);
    }
    return 0;
}

12. Kids and Prizes

题意: $N$ 个礼品箱, 每个礼品箱内的礼品只有第一个抽到的人能拿到. $M$ 个小孩每个人依次随机抽取一个, 求送出礼品数量的期望值. $1 ≤ N, M ≤ 10^5$

m个人是独立的。
对于每个礼物不被人选中的概率为((n-1)/n)^m
那么不被选中的礼物数的期望就是 n*((n-1)/n)^m   （考虑二项分布）
所以答案就是  n-n*((n-1)/n)^m;

13. Time travel

题意：一个 $0\sim n-1$ 的坐标轴，给出起点 $X$ 、终点 $Y$ ，和初始方向 $D$ （ $0$ 表示从左向右、 $1$ 表示从右向左， $- 1$ 表示 $0$ 号点或 $n - 1$ 号点），在走的过程中如果到达 $0$ 号点或 $n - 1$ 号点，那么下一步往反方向走。每次可以走 $1\sim m$ 步，每步概率为 $p [i]$ ，问走到终点的期望步数。（ $n,m,X,Y\le 100$ ）