[java,2019-01-28] 枪手博弈，谁才是最后赢家

什么是枪手博弈：

　　枪手博弈指彼此痛恨的甲乙丙三个枪手准备决斗。甲枪法最好，十发八中。乙枪法次之，十发六中。丙枪法最差，十发四中。假设他们了解彼此实力，也能做出理性判断。

　　问题一：如果三人同时开枪，并且每人每次只发一枪。若干轮枪战后，谁活下来的机会大？

　　问题二：如果三人轮流开枪，并且由枪法最差的丙先开枪，他该怎么做？

问题一：

分析：

　　3个人同时开枪，则枪手开枪的同时也可能被射死，4种情况，场上分别剩余（3,2,1,0）人

1）场上剩余3人，此时a（甲）一定向b（乙）射击，b一定向a射击，c（丙）可能向a射击或向空射击

2）场上剩余2人，互射，无其他可能

3）场上剩余1人，最后的胜利者

4）场上剩余0人，全部死亡

抽象出枪手模型

public class Hackbuteer {
    private int state=1; //存活状态，1存活，0死亡
    private double shot_rate; //命中率
    public Hackbuteer(double shot_rate){
        this.shot_rate=shot_rate;
    }
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
    }
    public double getShot_rate() {
        return shot_rate;
    }
    public void setShot_rate(double shot_rate) {
        this.shot_rate = shot_rate;
    }
    public boolean shot(Hackbuteer target) {
        double rand = Math.random();
        if(rand<shot_rate){ //随机数小于命中率，表示命中
            target.state=0; //目标死亡
            return true;
        }
        return false;
    }   
}

 模拟多次（100w）射击，用频率估算概率，代码如下：

public class HackbuteerTest {
    public static void main(String[] args) {
        int a_count=0;  //a存活次数
        int b_count=0;  //b存活次数
        int c_count=0;  //c存活次数
        for(int i=0;i<1000000;i++){
            Hackbuteer a=new Hackbuteer(0.8);
            Hackbuteer b=new Hackbuteer(0.6);
            Hackbuteer c=new Hackbuteer(0.4);
            while(true){
                int all_state=a.getState()+b.getState()+c.getState(); //场上存活状态
                if(all_state==3){ //3人都存活
                    a.shot(b);
                    b.shot(a);
                    //c.shot(a); //c向a射击；若模拟向空射击，则注释此行
                }else if(all_state==2){ //1人死亡，2人存活
                    if(a.getState()==0){
                        b.shot(c);
                        c.shot(b);
                    }
                    if(b.getState()==0){
                        a.shot(c);
                        c.shot(a);
                    }
                    if(c.getState()==0){
                        b.shot(a);
                        a.shot(b);
                    }
                }else if(all_state==1   //仅有一人存活
                        || all_state==0   //无人存活
                        ){   
                    if(a.getState()==1){
                        a_count++;
                    }
                    if(b.getState()==1){
                        b_count++;
                    }
                    if(c.getState()==1){
                        c_count++;
                    }
                    break;
                }
                
            }
        }
        System.out.println("a存活--"+a_count);
        System.out.println("b存活--"+b_count);
        System.out.println("c存活--"+c_count);
        System.out.println("无人存活--"+(1000000-a_count-b_count-c_count));
        
    }
}

结果：

c向a射击，c向空射击，

所以对于c来说，在同时开枪的情况下，c应该向a开枪，而不是向空开枪。

PS:以上结果仅代表实验100w次的频率，不完全代表概率。

问题二：

分析：

3人轮流开枪，c先开枪，依然是2种方案（向a射击，向空射击），代码如下：

public class HackbuteerTest2 {
    public static void main(String[] args) {
        int a_count=0;  //a存活次数
        int b_count=0;  //b存活次数
        int c_count=0;  //c存活次数
        for(int i=0;i<1000000;i++){
            Hackbuteer a=new Hackbuteer(0.8);
            Hackbuteer b=new Hackbuteer(0.6);
            Hackbuteer c=new Hackbuteer(0.4);
            while(true){
                //c存活，开枪策略1，优先射击a
                if(c.getState()==1){
                    if(a.getState()==1){
                        c.shot(a);
                    }else if(b.getState()==1){
                        c.shot(b);
                    }
                }
                //c存活，开枪策略2，当a，b都存活时，不射击任何人
//                if(c.getState()==1){
//                    if(a.getState()==0 && b.getState()==1){
//                        c.shot(b);
//                    }else if(a.getState()==1 && b.getState()==0){
//                        c.shot(a);
//                    }
//                }
                
                //a存活，开枪策略，优先射击b
                if(a.getState()==1){
                    if(b.getState()==1){
                        a.shot(b);
                    }else if(c.getState()==1){
                        a.shot(c);
                    }
                }
                //b存活，开枪策略，优先射击a
                if(b.getState()==1){
                    if(a.getState()==1){
                        b.shot(a);
                    }else if(c.getState()==1){
                        b.shot(c);
                    }
                }
                
                if(a.getState()+b.getState()+c.getState()==1){ //仅有一人存活
                    if(a.getState()==1){
                        a_count++;
                    }
                    if(b.getState()==1){
                        b_count++;
                    }
                    if(c.getState()==1){
                        c_count++;
                    }
                    break;
                }
                
            }
        }
        System.out.println("a存活--"+a_count);
        System.out.println("b存活--"+b_count);
        System.out.println("c存活--"+c_count);
    }
}

结果：

c向a射击，c向空射击

显然，此时c应该向空射击，而不是向a射击

PS：当射击顺序为（c-b-a时，结论依然如此）

结论：

火并也要按照基本法，同时开枪有1/4-1/3的概率全部玩完（你是不是以为我要说什么实力很重要，选择很重要，背叛与忠诚？）