蓝桥杯-博弈问题的思路

例1【取球博弈】 

今盒里有n个小球，A、B两人轮流从盒中取球。
每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个。
两人都很聪明，不会做出错误的判断。

每个人从盒子中取出的球的数目必须是：1，3，7或者8个。
轮到某一方取球时不能弃权！
A先取球，然后双方交替取球，直到取完。

被迫拿到最后一个球的一方为负方（输方）
    
编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？

解析：此类问题属于最简单的博弈，即无偏博弈（没有平局情况），一般解决方法为：

f(局面 x){
  for(所有可能走法){
     试走 x --> y
     if(f(y))== 输 then return 赢
     回溯
  }
  return 输
}

public class Main {
    static boolean f(int x) {
        if(x==0) return true;//必赢
        
        if(x>=1 && f(x-1)==false) return true;
        if(x>=3 && f(x-3)==false) return true;
        if(x>=7 && f(x-7)==false) return true;
        if(x>=8 && f(x-8)==false) return true;
        return false;

    }
    public static void main(String[] args) {
        for(int i=1;i<50;i++)
            System.out.println(i + ":" + f(i));
    }
}

例2【填字母游戏】

K大师在纸上画了一行n个格子，要小明和他交替往其中填入字母。
1. 轮到某人填的时候，只能在某个空格中填入L或O
2. 谁先让字母组成了“LOL”的字样，谁获胜。
3. 如果所有格子都填满了，仍无法组成LOL，则平局。

小明试验了几次都输了，他很惭愧，希望你能用计算机帮他解开这个谜。

本题的输入格式为：
第一行，数字n（n<10），表示下面有n个初始局面。
接下来，n行，每行一个串，表示开始的局面。
  比如：“******”, 表示有6个空格。“L****”,   表示左边是一个字母L，它的右边是4个空格。

要求输出n个数字，表示对每个局面，如果小明先填，当K大师总是用最强着法的时候，小明的最好结果。
1 表示能赢
-1 表示必输
0 表示可以逼平

例如，
输入：
4
***
L**L
L**L***L
L*****L

则程序应该输出：
0
-1
1
1

解析：该问题为有平局博弈问题，一般解决方法：

f(局面 x)
{
  t = 输
  for(所有可能走法){
     试走 x --> y    
     if f(y)= ? {
        输 ==> return 赢
        平 ==> t = 平
     }          
     回溯
  } 
  return t
}

public class Main {
    static int f(char [] c) {
        String s=new String(c);
        if(s.contains("LOL"))
            return -1;
        if(s.contains("*")==false)
            return 0;//出口勿漏

        boolean ping=false;//假设无法逼平
        for(int i=0;i<c.length;i++) {
            if(c[i]=='*') {
                try {
                    c[i]='L';//进行试探
                    if(f(c)==-1)
                        return 1;
                    else if(f(c)==0)
                        ping=true; //不能直接返回0，否则不能进行进一步试探
                    c[i]='O';
                    if(f(c)==-1)
                        return 1;
                    else if(f(c)==0)
                        ping=true;
                }
                finally {
                    c[i]='*';//回溯
                }
            }
        }
        if(ping) return 0;
        return -1;
    }
    public static void main(String[] args) {
        System.out.println(f("***".toCharArray()));
        System.out.println(f("L**L".toCharArray()));
        System.out.println(f("L**L***L".toCharArray()));
        System.out.println(f("L*****L".toCharArray()));

    }
}

例3【高僧斗法】

古时丧葬活动中经常请高僧做法事。
仪式结束后，有时会有“高僧斗法”的趣味节目，以舒缓压抑的气氛。    

节目大略步骤为：先用粮食（一般是稻米）在地上“画”出若干级台阶（表示N级浮屠）。
又有若干小和尚随机地“站”在某个台阶上。
最高一级台阶必须站人，其它任意。(如图所示)

两位参加斗法的法师分别指挥某个小和尚向上走任意多级的台阶，但会被站在高级台阶上的小和尚阻挡，不能越过。
两个小和尚也不能站在同一台阶，也不能向低级台阶移动。

两法师轮流发出指令，最后所有小和尚必然会都挤在高段台阶，再也不能向上移动。
轮到哪个法师指挥时无法继续移动，则游戏结束，该法师认输。

对于已知的台阶数和小和尚的分布位置，请你计算先发指令的法师该如何决策才能保证胜出。

输入数据为一行用空格分开的N个整数，表示小和尚的位置。台阶序号从1算起，所以最后一个小和尚的位置即是台阶的总数。（N<100, 台阶总数<1000）
    
输出为一行用空格分开的两个整数: A B, 表示把A位置的小和尚移动到B位置。
若有多个解，输出A值较小的解，若无解则输出-1。

例如：
用户输入：
1 5 9
则程序输出：
1 4

再如：
用户输入：
1 5 8 10
则程序输出：
1 3

解析：斯普莱格–格隆第定理---任何无偏游戏都可以等价到尼姆堆

public class Main {
    //组合博弈论。。。转化为尼姆堆
    static boolean f(int []x){
        int sum = 0;
        for(int i=0;i<x.length-1;i+=2){
            sum ^= x[i+1] - x[i] - 1;//相邻两人差几个空台阶
        }
        return sum==0;
    }

    static void solve(int[] x) {
        for(int i=0;i<x.length-1;i++){//最后一个和尚不能走
            for(int k=x[i]+1;k<x[i+1];k++){
                int old = x[i];
                try{
                    x[i] = k; //试探
                    if(f(x)) {
                        System.out.println(old + "  " + k);
                        return;
                    }
                }
                finally{
                    x[i] = old; //回溯
                }
            }
        }


    }
    public static void main(String[] args) {
        solve(new int[]{1,5,9});//3（9不能动，可以看成废棋）
        solve(new int[]{1,5,8,10});//3,1
        solve(new int[]{1,4,8,12,16,19,28,33,35,40,45,52,66,67,68,85,99,102,134,155,211,214,216,355,400,412});
    }
}

例4【古代赌局】

俗话说：十赌九输。因为大多数赌局的背后都藏有阴谋。
不过也不尽然，有些赌局背后藏有的是：“阳谋”。

有一种赌局是这样的：桌子上放六个匣子，编号是1至6。
多位参与者（以下称玩家）可以把任意数量的钱押在某个编号的匣子上。
所有玩家都下注后，庄家同时掷出3个骰子（骰子上的数字都是1至6）。
输赢规则如下：

1.若只有1个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目赔付（即1比1的赔率）。
2.若2个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的2倍赔付（即1比2的赔率）。
3.若3个骰子上的数字都与玩家押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的10倍赔付（即1比10的赔率）。

乍一看起来，好像规则对玩家有利，庄家吃亏。但经过大量实战，会发现局面很难说，于是怀疑是否庄家做了手脚，庄家则十分爽快地说：可以由玩家提供骰子，甚至也可以由玩家来投掷骰子。

你的任务是：通过编程模拟该过程。模拟50万次，假定只有1个玩家，他每次的押注都是1元钱，其押注的匣子号是随机的。再假定庄家有足够的资金用于赔付。最后计算出庄家的盈率（庄家盈利金额/押注总金额）。

解析：此类问题属于伪博弈问题

public class Main {
    static double f(){
        int a = (int)(Math.random() * 6) + 1;
        int b = (int)(Math.random() * 6) + 1;
        int c = (int)(Math.random() * 6) + 1;

        int w = (int)(Math.random() * 6) + 1;
        int sum = 0;
        if(a==w) sum++;
        if(b==w) sum++;
        if(c==w) sum++;
        if(sum==1) return -1;
        if(sum==2) return -2;
        if(sum==3) return -10;
        return 1;
    }

    public static void main(String[] args) {
        int N = 500 * 1000;
        double sum = 0;
        for(int i=0;i<N;i++){
            sum += f();
        }
        System.out.println(sum/N);//约为5%
    }
}

例5【火柴游戏】

这是一个纵横火柴棒游戏。
如图1，在3x4的格子中，游戏的双方轮流放置火柴棒。

其规则是：
1. 不能放置在已经放置了火柴棒的地方（即只能在空格中放置）。
2. 火柴棒的方向只能是竖直或水平放置。
3. 火柴棒不能与其它格子中的火柴“连通”。
所谓连通是指两根火柴棒可以连成一条直线，且中间没有其它不同方向的火柴“阻拦”。
例如：
图1所示的局面下，可以在C2位置竖直放置（为了方便描述格子位置，图中左、下都添加了标记），但不能水平放置，因为会与A2连通。
同样道理，B2，B3，D2此时两种方向都不可以放置。
但如果C2竖直放置后，D2就可以水平放置了，因为不再会与A2连通（受到了C2的阻挡）。
4. 游戏双方轮流放置火柴，不可以弃权，也不可以放多根。

如某一方无法继续放置，则该方为负（输的一方）。

游戏开始时可能已经放置了多根火柴。
你的任务是：编写程序，读入初始状态，计算出对自己最有利的放置方法并输出放置后的局面。
图1的局面表示为：
00-1
-000
0100
即用“0”表示空闲位置，用“1”表示竖直放置，用“-”表示水平放置。

解法不唯一，找到任意解法即可。

例如，局面：
0111
-000
-000
的解：
-111
-000
-000

再例如，局面：
1111
----
0010
的解：
1111
----
0110

public class Main {
    static void show(char[][]data){
        System.out.println();
        for(int i=0;i<data.length;i++){
            System.out.println(data[i]);
        }
    }
    //对给定的局面来判定是否能赢
    static boolean f(char[][]data){
        for(int i=0;i<data.length;i++){
            String s = new String(data[i]);
            s = s.replaceAll("0","");
            if(s.contains("--")) return true;
        }
        for(int i=0;i<data[0].length;i++){
            String s = "" + data[0][i]+data[1][i]+data[2][i];
            s = s.replaceAll("0","");
            if(s.contains("11")) return true;
        }
        for(int i=0;i<data.length;i++){
            for(int j=0;j<data[i].length;j++){
                if(data[i][j]=='0'){
                    try{
                        data[i][j]='1';
                        if(f(data)==false)
                            return true;
                        data[i][j]='-';
                        if(f(data)==false)
                            return true;
                    }
                    finally {
                        data[i][j]='0';
                    }
                }
            }
        }
        return false;
    }

    static void solve(char[][]data){
       for(int i=0;i<data.length;i++){
           for(int j=0;j<data[i].length;j++) {
               if (data[i][j] == '0') {
                   try{
                       data[i][j] = '1';
                       if(f(data)==false)
                           show(data);
                           //return;
                       data[i][j] = '-';
                       if(f(data)==false)
                           show(data);
                           //return;
                   }
                   finally {
                       data[i][j] = '0';
                   }

               }
           }
       }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char[][]data = new char[3][];
        data[0] = sc.nextLine().trim().toCharArray();
        data[1] = sc.nextLine().trim().toCharArray();
        data[2] = sc.nextLine().trim().toCharArray();
        solve(data);
    }
}