抛硬币的赌博游戏——庞果英雄会

         这是一道来自庞果网的在线编程挑战题目，属于中等偏上难度的题目。正式这道题目，让我对庞果网的程序挑战产生了兴趣。下面就讲一下我的解题思路。

         题目：抛硬币的赌博游戏

         原文链接（有可能失效）：http://hero.pongo.cn/OnlineCompiler/Index?ID=59&ExamID=57

         题目详情：小a和小b起初分别有A块钱和B块钱，它们决定玩一个赌博游戏，游戏规则是扔一个硬币，如果结果是正面的话，小a要给小b C块钱。

否则是反面的话，小b给小a D块钱。

         它们不断地扔硬币，直到某一次应该给钱的人拿不出那么多钱，就认为他破产输掉了。

硬币不是均匀的，它以p1的概率产生正面，1 - p1的概率产生反面。

         请问小a最后胜利(也就是说小b破产输掉)的概率有多大？

         输入：A，B，C，D是整数，0<=A,B<50，0<=C,D<=100，p1是浮点数 0<=p1<=1；

         输出：为保证输出的是整数，请输出小a获胜的概率乘以100后再下取整（直接截断后面的位数）的结果。

         例如，结果是0.125则输出12。

 

         一看这道题目，是计算概率，但利用数学公式去计算，却无比的麻烦。于是拿出一个例子来分析，应该能找到这道题目的解决方法。那么，假设经过若干次抛硬币，小a持有x元钱，小b持有y元钱，那么将这个时刻看作一种状态，那么下一次如果还可以继续投硬币（即：x不小于0，y不小于0），则投掷一次硬币，可能变成小a持有x-2元，小b持有y+2元，这又是一种状态，与之对应，小a持有x+1元，小b持有y-1元，这是另外一种状态。由此，我们可以将整个抛硬币的过程看作状态之间的转换。那么，状态是否有无限种？状态之间的转换有什么关系呢？下面，就一组给定的数据，画出状态的转换图。假定开始小a有5元，小b有3元，硬币朝上，小a给小b的钱数为2元，硬币朝下，小b给小a的钱数为1元。



在这里，椭圆中第一个数字为小a持有的钱数，第二个数字为小b持有的钱数。将小a或者小b持有钱数为负值的情况作为终点状态，因为此时有一个人已经输掉所有钱，不会再有下一种状态了。而如图，两种相邻的状态，他们的子状态，有一个是重合的，如状态（3/5）可以转换成（4/4），与它相邻的状态（6/2）也可以转换成（4/4），可以把它们合并。这是状态转换的一个特点。

         随着状态转换的次数增加，可以看出，最后出现的状态总是与前边的状态重复，这说明，所有的状态应该是有限的。图中，再往后的状态转换没有画出，因为，状态已经重复了，不可能再出现新的状态了。
         下面考虑一下概率的问题，最终我们要得到的概率。假设硬币朝上概率为0.7。起始状态（5/3）的概率肯定是1，那么硬币第一次投硬币之后，（3/5）的概率为0.7，而（6/2）的概率为。我们可以认为，子节点的概率，来源于父节点的概率。节点的两个字节点的概率，分别等于该节点的概率乘以0.7和0.3。于是概率计算的问题也解决了。
         随着状态的变化，概率发生了转移。再次观察状态转换图，如果我们要计算状态（3/5）的概率需要找到状态（5/3）和状态（2/6）这样，P(3/5) = P(5/3) * 0.7 + P(2/6) * 0.3；计算一个节点的公式我们得出了，那么将公式堆叠在一起，我们可以得到一个矩阵。如下图：



图中，如果矩阵的右边乘以当前每个状态点概率的列向量，则获取下一次抛一次硬币时各个状态的概率。在这里，我将状态（-2/10）、（-1/9）、（9/-1）三个点自身提供给自身的概率设置为1，这样可以下一次矩阵相乘时，它们的概率不会丢失（应该算做转移到自身）。如此连续相乘，求取矩阵的极限，能够获取最终的概率。而程序不可能求取无数次，而且也不必要求无数次矩阵相乘。就可以使得概率的收敛达到理想效果。下面是我的代码：

#include <cstdio>
#include <string>
#include <cmath>

using namespace std;

struct Node{
int A; // 小a剩余钱数
int B; // 小b剩余钱数
int finish; // 是否终结,-1小a输掉,1,小b输掉,0未达到输赢
struct Node* next;

};

int win(int A,int B,int C,int D,double p1) {

double pA = 0.0;
double p2 = 1 - p1;

if(A == B && C == D && p1 == 0.5){
pA = 0.5; // 双方条件一致,概率一样
}else if(A < C && B < D){
pA = 1 - p1; // 一局定胜负
}else{
int start = - C; // 小a拥有的最小的财富,可能是负值
int end = A + B + D; // 小a拥有的最大财富,小b可能是负值
int count = end - start + 1;
bool* exists = new bool[count];
int i = 0 , j = 0;

for(i = 0 ; i < count ; ++i){ // 初始化变量,全部置为false
exists[i] = false;
}
// 确定根节点
Node *root = new Node();
root -> A = A;
root -> B = B;
root -> finish = 0;

int current = 0; // 当前第几个节点
int total = 1; // 节点总个数

Node * front = root;
Node * tail = root;
Node * pNew = NULL;

exists[root -> A + C] = true;

int finish = 0;
int nextA = 0;
int nextB = 0;

while(current < total){

if(front -> finish == 0){
// 处理正面的情况
nextA = front -> A - C;
nextB = front -> B + C;

if(nextA < 0){
finish = -1;
}else {
finish = 0;
}
pNew = new Node();
pNew -> A = nextA;
pNew -> B = nextB;
pNew -> finish = finish;

if(!exists[nextA + C]){ // 节点未加入队列
tail -> next = pNew;
tail = tail -> next;
exists[nextA + C] = true;
total ++;

}

// 处理反面
nextA = front -> A + D;
nextB = front -> B - D;

if(nextB < 0){
finish = 1;
}else {
finish = 0;
}
pNew = new Node();
pNew -> A = nextA;
pNew -> B = nextB;
pNew -> finish = finish;

if(!exists[nextA + C]){ // 节点未加入队列
tail -> next = pNew;
tail = tail -> next;
exists[nextA + C] = true;
total ++;

}

} // if判断finish==0

front = front -> next; // 移动到下一个节点
current ++;

}// while循环

//迭代生成概率向量
int * tag = new int[count];

int k = 0;
for(i = 0 ; i < count ; ++i){

if(exists[i]){
tag[i] = k;
k ++;
}else{
tag[i] = -1; // 标示该节点不存在
}

}

double * pFir = new double[total];
double * pSec = new double[total];
double * pMid = NULL;

int * numbers = new int[total]; // 小a可能拥有的钱数

int r = 0 , n = 0 ; // r循环变量,n迭代次数

front = root;
while(front != NULL){ // 初始化小a可能出现的钱数(按照从小到大排列)
numbers[tag[front -> A + C]] = front -> A;
front = front -> next;
}

// 初始化概率
for(r = 0 ; r < total ; ++ r){
pFir[r] = 0.0;
pSec[r] = 0.0;

}

pFir[tag[A + C]] = 1.0; // 起始概率为1

int T = A + B;

n = 0;

double pSum = 0.0;

int v = 0;

while(n++ < 1000){ // 完成n次迭代(最多一万次)

for(r = 0 ; r < total ; ++ r){ // 完成一次迭代

if(numbers[r] < 0){ // 小a输掉的节点
pSec[r] = pFir[r] + pFir[tag[numbers[r] + C + C]] * p1;

}else if(numbers[r] <= T){

pSec[r] = 0;
if(numbers[r] - D >= 0){
pSec[r] += pFir[tag[numbers[r] - D + C]] * p2;

}
if(numbers[r] + C <= T){
pSec[r] += pFir[tag[numbers[r] + C + C]] * p1;

}

}else{
pSec[r] = pFir[r] + pFir[tag[numbers[r] - D + C]] * p2;

}

} // 完成一次迭代

//交换概率
pMid = pFir;
pFir = pSec;
pSec = pMid;

pA = 0.0;
pSum = 0.0;
for(v = 0 ; v < total ; v ++){ // 计算新概率

if(numbers[v] >= 0 && numbers[v] <= T){
pSum += pFir[v];
}else if(numbers[v] > T){
pA += pFir[v];
}
}

if(pSum < 0.00001){
break;
}

} // 完成n次迭代

}

return pA * 100;

}

//start 提示：自动阅卷起始唯一标识，请勿删除或增加。
int main()
{
printf("%d" , win(5, 3, 2 , 1 , 0.7));

//
return 0;
}
//end //提示：自动阅卷结束唯一标识，请勿删除或增加。