Gambler's Ruin（赌徒破产问题 概率论）

P(N|h) = a*P(N|h+1) + (1-a)*P(N|h-1)

x^2 - 1/a * x + (1-a)/a = 0

P(N|h) = A*(1^h) + B*(r^h)

1 = A + B*(r^N)

0 = A + B

A = -1/(r^N - 1)、B = 1/(r^N - 1)

P(N|h) = A+B*h

A = 0、B=1/N

Problem Statement

There are N cats sitting around a circle. The cats are numbered 0 throughN-1 in clockwise order. Note that as they sit around a circle, catN-1 is adjacent to cat 0. The cats are playing a game and the winner will get a prize!

The game looks as follows:

• There is a single ball. Initially, cat 0 holds the ball.
• In each round of the game, the cat who currently holds a ball flips a biased coin. The coin will come up heads with probabilityp/1,000,000,000 and tails with probability 1-(p/1,000,000,000).
• If the coin came up heads, the current cat will hand the ball to the next cat clockwise, otherwise the current cat will hand the ball to the next cat counterclockwise. Formally, if the current cat is cat j, heads means that the ball goes to cat (j+1) modN and tails means that it goes to cat (j-1) mod N.
• The game is played until each cat held the ball at least once. The cat who holds the ball at the end of the game is the winner.

In other words, the winner is the last cat to touch the ball. Note that cat 0 holds the ball at the beginning, and this does count as holding the ball. Hence, if there is more than one cat, cat 0 can never win the game.

Cat K wonders what is the probability that she will win the prize. You are given the intsN,K, and p. Return the probability that catK wins.

Definition

 Class: CatsOnTheCircle Method: getProb Parameters: int, int, int Returns: double Method signature: double getProb(int N, int K, int p) (be sure your method is public)

Limits

 Time limit (s): 2 Memory limit (MB): 256 Stack limit (MB): 256

Notes

- Your return value must have an absolute or relative error smaller than or equal to 1e-6

Constraints

- N will be between 3 and 1,000,000,000, inclusive.
- K will be between 1 and N-1, inclusive.
- p will be between 1 and 999,999,999, inclusive.

Examples

0)

 3 1 300000000
Returns: 0.6999999999999985
 This game has N=3 cats, labeled 0, 1, 2. We havep=30,000,000, hence the coin will come up heads with probability 30,000,000/1,000,000,000 = 0.3 and tails with probability 0.7. The game can look as follows: Cat 0 is given the ball. Cat 0 flips the coin. The coin comes up tails. Cat 0 hands the ball to cat (0-1) mod 3 = cat 2. Cat 2 flips the coin. The comes up tails again. Cat 2 hands the ball to cat (2-1) mod 3 = cat 1. At this moment, each cat has held the ball. The game ends and cat 1 gets the prize. This particular sequence of events has probability 0.7*0.7 of occuring. It can be shown that the probability that cat 1 wins the game is 0.7.
1)

 6 2 500000000
Returns: 0.2
 The coin that is flipped will come up heads with probability 1/2, and tails with probability 1/2.
2)

 6 5 500000000
Returns: 0.2
3)

 10 2 666666666
Returns: 0.00391389439551009
4)

 999999999 999999996 777777777
Returns: 0.05830903870125612
5)

 1000000000 4 300000000
Returns: 0.044981259448371
6)

 534428790 459947197 500000000
Returns: 1.871156682766205E-9

N只猫围成一圈玩游戏，顺时针编号0~N-1，N-1与0相邻。游戏规则如下：

、一开始编号0的猫拿着一个球

、每个回合中手里拿球的猫抛硬币，该硬币有P/1000000000的概率正面朝上，(1-P/1000000000)的概率反面朝上

、如果硬币正面朝上，则该猫 j 把球传给编号为(1+j)%N的猫，否则传给编号为(j-1+N)%N的猫

、该游戏持续进行直到每只猫至少拿到一次球。且最终拿球的猫赢得游戏

1. 如果最终猫K拿到球并结束游戏，那么之前一回合必然是猫K-1或K+1拿球，且除K外的猫都至少拿过一次球。则最终的结果为P(K+1,K-1) + P(K-1,K+1)，既猫K+1先拿到球的前提下K-1拿到球的概率加上猫K-1先拿到球的前提下K+1拿到球的概率。这样就可以了，因为当全局只剩下K没有拿过球，K必然是最后一个拿到球的。

2. 这种情况和赌徒破产问题有什么类似之处呢？再来回顾下赌徒破产问题，该问题求的是当前有h枚金币的情况下，赢得N枚金币的概率。不如我们换一种表述方式，即该赌徒一开始最多能连续输掉h枚金币。放到这题的环境中，我们假设顺时针走等于金币加一，逆时针走等于金币减一。

3. 以求解P(K-1,K+1)为例，需要将其拆分为两种概率的乘积：P(a)=从0出发向左走最多到达K+2，且向右走必然到达K-1；P(b)=从K-1出发向右最多到达K-1，且向左走必然到达K+1；这样一来就可以套赌徒破产问题了。

4. 大于1.0的浮点数求幂可能会爆，需要控制一下

#include <cstdio>
#include <iostream>
#include <string>
#include<assert.h>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <set>
typedef long long int ll;
#define rp(i,b) for(int i=(0),__tzg_##i=(b);i<__tzg_##i;++i)
#define rep(i,a,b) for(int i=(a),__tzg_##i=(b);i<__tzg_##i;++i)
#define repd(i,a,b) for(int i=(a),__tzg_##i=(b);i<=__tzg_##i;++i)
#define mst(a,b) memset(a,b,sizeof(a))
using namespace std;
const double Denominator = 1e9;
const double eps = 1/Denominator;
struct CatsOnTheCircle {
double gamblers_ruin(int n, int h, double p) {
double q = 1.0-p;
if (fabs(p-q) < eps)
return 1.0*h/n;
if (q > p)
return 1-gamblers_ruin(n, n-h, q);
double r = q/p;
return (pow(r,h)-1)/(pow(r,n)-1);
}
double getProb(int N, int K, int _p){
double p = _p/Denominator;
double q = 1.0-p;
double o = gamblers_ruin(N-2, N-K-1, p);
double u = gamblers_ruin(N-2, K-1, q);
return o*gamblers_ruin(N-1, 1, q) + u*gamblers_ruin(N-1, 1, p);
}
};