【HDOJ】4043 FXTZ II

1. 题目描述
有n个球，第i个球的伤害值为$2^i-1, i \in [1,n]$。有甲乙两个人，每次由甲选择n个球中的一个，用它以相同概率攻击自己或者乙，同时彻底消耗这个球。这样的攻击最多进行n次。
一旦甲的伤害值高于乙，则甲输，否则甲胜。问甲胜的概率是多少。

2. 基本思路
还是一步步推导。令dp[k]表示共有k个球时甲胜的概率。
\begin{align}
    dp[1] &= \frac{1}{2}    \notag \\
    dp[2] &= \frac{1}{2} \times \frac{1}{2} \times (1 + dp[1]) \notag \\
    dp[3] &= \frac{1}{3} \times \frac{1}{2} \times (1 + dp[1] + dp[2]) \notag \\
    dp[4] &= \frac{1}{4} \times \frac{1}{2} \times (1 + dp[1] + dp[2] + dp[3]) \notag \\
        &\cdots \notag \\
    dp[n] &= \frac{1}{n} \times \frac{1}{2} \times (1 + \Sigma_{i=1}^{n-1}dp[i])
\end{align}
为什么上式成立，以$dp[3] = \frac{1}{3} \times \frac{1}{2} \times (1 + dp[1] + dp[2])$为例解释。
$\frac{1}{3} \times \frac{1}{2}$表示在第k次取到第3个球的概率（该球一定攻击乙），$k \in [1,3]$。
此时，这个球一定属于乙（否则甲必输）并且从此时开始，无论后续的球如何安排，最终都是甲胜。
然而，前k次一定满足甲胜，否则在$[1,k-1]$的某一次中，即停止游戏。
当k=3时，概率为dp[2];
当k=2时，概率为dp[1];
当k=1时，概率为1。
以此类推，dp[n]。

3. 代码

import java.lang.*;
import java.io.*;
import java.util.*;
import java.math.BigInteger;


public class Main {
    
    public static void main(String[] arg) throws java.lang.Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(in, out);
        out.close();
    }
}


    
class TaskA {
    public final static int maxn = 505;
    BigInteger[] FZ = new BigInteger[maxn];
    BigInteger[] FM = new BigInteger[maxn];
    
    public TaskA() {
        init();
    }
    
    public void solve(InputReader in, PrintWriter out) {
        int t = in.nextInt();
        int n;
        
        while (t-- > 0) {
            n = in.nextInt();
            out.println(FZ[n].toString() + "/" + FM[n].toString());
        }
    }
    
    private void init() {
        BigInteger sfm = BigInteger.ONE, sfz = BigInteger.ONE;
        BigInteger fm, fz;
        BigInteger g, lcm;
        
        for (int i=1; i<=500; ++i) {
            fm = sfm.multiply(BigInteger.valueOf(i*2));
            fz = sfz;
            g = fz.gcd(fm);
            FZ[i] = fz.divide(g);
            FM[i] = fm.divide(g);
            // System.out.println(fz + "/" + fm);
            
            g = sfm.gcd(FM[i]);
            sfz = sfz.multiply(FM[i].divide(g))
                     .add( FZ[i].multiply(sfm.divide(g)) );
            sfm = FM[i].divide(g).multiply(sfm);
        }
    }
    
    private BigInteger A(int n, int m) {
        BigInteger ret = BigInteger.ONE;
        
        for (int i=n; i>n-m; --i)
            ret = ret.multiply(BigInteger.valueOf(i));
        
        return ret;
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    
    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }
    
    public String next() {
        while (tokenizer==null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    
    public int nextInt() {
        return Integer.parseInt(next());
    }
    
    public long nextLong() {
        return Long.parseLong(next());
    }
}