第1章 游戏之乐——NIM（3）两堆石头的游戏

NIM（3）两堆石头的游戏

1. 问题描述

      假设有两堆石头，有两个玩家会根据如下的规则轮流取石头：每人每次可以从两堆石头中各取出数量相等的石头，或者仅从一堆石头中取出任意数量的石头；最后把剩下的石头一次拿光的人获胜。请问在哪些局面（依据两堆石头中的石头个数）下，先取石头的玩家有必胜的策略。

2. 解法

      类似构造质数的筛选方法，这里我们利用找到的必输局面（后取的玩家有必胜策略）来筛去掉能通过一次操作达该必输局面的其它必胜局面（先取的玩家有必胜策略）。最后选出的局面都是必输局面。

　　构造必胜策略：

      如果一开始的局面就是必输局面，那么可能先取的玩家没有必胜策略（当然如果后取的玩家不太聪明，先取的玩家依然有可能能赢）。如果一开始的局面不是必输局面，那么先取的玩家一定有必胜策略，且必胜策略就是保证每次都将当前非必输局面转变为必输局面（后取的玩家必输）。

　　先取者有必胜策略的局面为“安全局面”，而先取者无必胜策略的局面为“不安全局面”。通过筛选可得如下不安全局面表：

不安全局面表

N	1	2	3	4	5	6	7	8	9	10	...
an	1	3	4	6	8	9	11	12	14	16	...
bn	2	5	7	10	13	15	18	20	23	26	...

　　有了通项公式，我们就能更加简明地实现函数bool nim(n,m)，这个函数的时间复杂度为O(min(m,n))。代码如下：

 

package chapter1youxizhileNIM3;
/**
 * 两堆石头的游戏
 * @author DELL
 *
 */
public class NIM3 {
    /**
     * 计算玩家是否能赢得游戏
     * @param n 其中一堆石头的数量
     * @param m 另一堆石头的数量
     * @return 输赢状态
     */
    public static boolean nim(int n, int m){
        double a,b;
        int temp;
        a = (1+Math.sqrt(5.0))/2;
        b = (3+Math.sqrt(5.0))/2;
        if(m == n)
            return true;
        if(m < n){  //保证m>n
            temp = m;
            m = n;
            n = temp;
        }
        int i = n;
        while(i>=1){ //由于序号i值一定小于等于min(m,n)所以遍历查找
            if((int)Math.floor(a*i)==n&&(int)Math.floor(b*i)==m)
                return false;
            i--;
        }
            return true;
    }
    public static void main(String[] args) {
        if(nim(5,3))
            System.out.println("(5,3)有必胜策略！");
        else
            System.out.println("(5,3)没有必胜策略！");
        
        if(nim(3,6))
            System.out.println("(3,6)有必胜策略！");
        else
            System.out.println("(3,6)没有必胜策略！");
    }

}

程序运行结果如下：

(5,3)没有必胜策略！
(3,6)有必胜策略！

 3. 扩展问题

　　1. 现在我们已经给出了一个判断先取者是否能够最终赢得游戏的判断函数，但是，游戏的乐趣在于过程，大家能不能根据本题的思路给出一个赢得游戏的必胜策略呢？即根据当前石头的个数，给出当前玩家下一步要怎么取石头才能必胜。

程序如下：

package chapter1youxizhileNIM3;
/**
 * 两堆石头的游戏
 * @author DELL
 *
 */
public class NIM3 {
    /**
     * 计算玩家是否能赢得游戏
     * @param n 其中一堆石头的数量
     * @param m 另一堆石头的数量
     * @return 输赢状态
     */
    public static boolean nim(int n, int m){
        double a,b;
        int temp;
        a = (1+Math.sqrt(5.0))/2;
        b = (3+Math.sqrt(5.0))/2;
        if(m == n)
            return true;
        if(m < n){  //保证m>n
            temp = m;
            m = n;
            n = temp;
        }
        int i = n;
        while(i>=1){ //由于序号i值一定小于等于min(m,n)所以遍历查找
            if((int)Math.floor(a*i)==n&&(int)Math.floor(b*i)==m)
                return false;
            i--;
        }
            return true;
    }
    
    public static void result(int n,int m){
        int min,max; //存储m,n中的最小值和最大值
        int i;
        if(m<=n){
            min = m;
            max = n;
        }else{
            min = n;
            max = m;
        }
        if(m==n)
            System.out.println("("+n+", "+m+")取后的状态为(0, 0)");
        if(nim(n,m)){
            for(i=1;i<=min;i++){
                if(!nim(n-i,m-i)){
                    System.out.println("("+n+", "+m+")取后的状态为("+(n-i)+", "+(m-i)+")");
                    return;
                }
                if(!nim(n-i,m)){
                    System.out.println("("+n+", "+m+")取后的状态为("+(n-i)+", "+m+")");
                    return;
                }
                if(!nim(n,m-i)){
                    System.out.println("("+n+", "+m+")取后的状态为("+n+", "+(m-i)+")");
                    return;
                }
            }
            for(i=min+1;i<=max;i++){
                if(n>=m){
                    if(!nim(n-i,m)){
                        System.out.println("("+n+", "+m+")取后的状态为("+(n-i)+", "+m+")");
                        return;
                    }
                }else{
                    if(!nim(n,m-i)){
                        System.out.println("("+n+", "+m+")取后的状态为("+n+", "+(m-i)+")");
                        return;
                    }
                }
            }
        }else{
            System.out.println("无论怎么取都没有必胜的策略！");
        }
    }
    public static void main(String[] args) {
        result(3,6);
        result(6,6);
    }

}

程序运行结果如下：

(3, 6)取后的状态为(3, 5)
(6, 6)取后的状态为(0, 0)

 　　2. 取石头的游戏已经不少了，但是我们还有一种游戏要请大家思考，我们姑且叫它NIM(4):

　　两个玩家，只有一堆石头，两人依次拿石头，最后拿光者为赢家。取石头的规则是：

　　　　（a）第一个玩家不能拿光所有的石头。

　　　　（b) 第一次拿石头之后，每人每次最多只能拿掉对方前一次所拿石头的两倍。

　　那么，这个游戏有没有必胜的算法？（提示：好像和Fibonacci数列有关。）

　　经分析可知，当这一堆石头的数量为Fibonacci值的时候，先拿者没有必胜策略。

判断的算法如下：

 

package chapter1youxizhileNIM3;
/**
 * 扩展问题
 * 　两个玩家，只有一堆石头，两人依次拿石头，最后拿光者为赢家。取石头的规则是：

　　　　（a）第一个玩家不能拿光所有的石头。

　　　　（b) 第一次拿石头之后，每人每次最多只能拿掉对方前一次所拿石头的两倍。

　　那么，这个游戏有没有必胜的算法？（提示：好像和Fibonacci数列有关。）
 * @author DELL
 *
 */
public class NIM4 {
    /**
     * 计算玩家是否能赢得游戏
     * @param n 给定的一堆石头的数量
     * @return 输赢状态
     */
    public static boolean nim(int n){
        int f1 = 1, f2 = 1;  //Fibonacci数列的前两个值
        int f3;
        if(n==1)
            return false;
        do{
            f3 = f1+f2;
            f1 = f2;
            f2 = f3;
        }while(f3<n);
        if(f3==n)
            return false;
        else
            return true;        
    }
    
    public static void main(String[] args){
        if(nim(3))
            System.out.println("(3)有必胜策略！");
        else
            System.out.println("(3)没有必胜策略！");
        if(nim(4))
            System.out.println("(4)有必胜策略！");
        else
            System.out.println("(4)没有必胜策略！");
    }
}

程序运行结果如下：

(3)没有必胜策略！
(4)有必胜策略！