【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
&= \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
。

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
.toString() + "/" + FM
.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());
}
}