五.博弈問題的思路


1. 日期與星期

大數學家高斯有個好習慣:無論如何都要記日記。
他的日記有個與眾不同的地方,他從不注明年月日,而是用一個整數代替,比如:4210
后來人們知道,那個整數就是日期,它表示那一天是高斯出生后的第幾天。這或許也是個好習慣,它時時刻刻提醒着主人:日子又過去一天,還有多少時光可以用於浪費呢?
高斯出生於:1777年4月30日。
在高斯發現的一個重要定理的日記上標注着:5343,因此可算出那天是:1791年12月15日。
高斯獲得博士學位的那天日記上標着:8113
請你算出高斯獲得博士學位的年月日。
1949年的國慶節(10月1日)是星期六。
今年(2012)的國慶節是星期一。
那么,從建國到現在,有幾次國慶節正好是星期日呢?
只要答案,不限手段!
可以用windows日歷,windows計算器,Excel公式,。。。。。
當然,也可以編程!
【源代碼】

【JAVA:於航】

很多關於日期的求解問題可以歸結為:求兩個日期之間的差值(但不建議使用Date類計算日期/日歷)

// 日期差問題
// 2015-3-2 距離 1979-12-15 多少天?

// 日期表示法?? 距離基點的天數

基點為1年1月1日     A-B=(A-基准)】-(B-基准)

public class A
{
    static int day_dif(int year1,int month1,int day1, int year2,int month2,int day2){
        return get_days(year2,month2,day2) - get_days(year1,month1,day1);
    }
   
    static boolean is_leap_year(int year){//閏年
        boolean tag = false;
        if(year%4==0) tag = true;
        if(year%100==0) tag = false;
        if(year%400==0) tag = true;
        return tag;
    }
   
    static int get_days(int year, int month, int day){
        int[] M = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        if(is_leap_year(year)) M[2]++;
       
        int sum = 0;
        for(int i=1; i<year; i++){
            sum += 365;
            if(is_leap_year(i)) sum++;
        }
       
        for(int i=1; i<month; i++){
            sum += M[i];
        }
       
        sum += day;
        return sum;
    }
   
    public static void main(String[] args){
        System.out.println(day_dif(1979,12,15,2015,3,2));
    }

}

2. excel地址

Excel單元格的地址表示很有趣,它使用字母來表示列號,比如:
A表示第1列,
B表示第2列,
Z表示第26列,
AA表示第27列,
AB表示第28列,
BA表示第53列,
….
當然Excel的最大列號是有限度的,所以轉換起來不難。
如果我們想把這種表示法一般化,可以把很大的數字轉換為很長的字母序列呢?
本題目既是要求對輸入的數字, 輸出其對應的Excel地址表示方式。
例如,
輸入:
26
則程序應該輸出:
Z
再例如,
輸入:
2054
則程序應該輸出:
BZZ
我們約定,輸入的整數范圍[1,2147483647]
【源代碼】

【JAVA:於航】

public class A         //不超過三個字母的解法
{
    // n 轉換為excel列地址
    static String f(int n){
        for(int i=0; i<=26; i++)
        for(int j=(i==0)?0:1; j<=26; j++)//若i=0,則j=0  否則:i=1,j=1

        for(int k=(j==0)?0:1; k<=26; k++){ //若j=0,則k=0  否則:j=1,k=1

                int x = i*26*26 + j*26 + k; 

                if(x==n){ String s =""; 

                if(i>0) s += (char)(i-1+'A');

                if(j>0) s += (char)(j-1+'A');
                if(k>0) s += (char)(k-1+'A');              
                return s;
            }
        }
        return "";
    }
   
    public static void main(String[] args){
        for(int i=700; i<750; i++){
            System.out.println(i + ": " + f(i));
        }
    }
}

另一種方法:

import java.util.Scanner;  
public class Main{  
    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);  
        int[] iA = new int[5000];  
        int n = in.nextInt();  
        int i = 1;  
        while (n != 0) {  
            if (n % 26 == 0) {  
                // +64轉大寫字母,+96轉小寫字母  
                iA[i] = 26 + 64;  
                n -= 1;  
            } else {  
                iA[i] = n % 26 + 64;  
            }  
            n /= 26;  
            i++;  
        }  
        for (int j = i - 1; j > 0; j--) {  
            System.out.print((char)iA[j]);  
        }  
    }  
}  

public class B
{
    // excel列地址轉換為n
    static int f(String s){
        int n = 0;
        for(int i=0; i<s.length(); i++){
            n = n * 26 + (s.charAt(i)-'A' + 1);
        }
        return n;
    }
   
    public static void main(String[] args){
        System.out.println(f("AA"));
        System.out.println(f("BA"));
        System.out.println(f("ZZ"));
        System.out.println(f("AAA"));
    }

}

3. 取球博弈

今盒里有n個小球,A、B兩人輪流從盒中取球。
每個人都可以看到另一個人取了多少個,也可以看到盒中還剩下多少個。
兩人都很聰明,不會做出錯誤的判斷。
每個人從盒子中取出的球的數目必須是:1,3,7或者8個。
輪到某一方取球時不能棄權!
A先取球,然后雙方交替取球,直到取完。
被迫拿到最后一個球的一方為負方(輸方)

編程確定出在雙方都不判斷失誤的情況下,對於特定的初始球數,A是否能贏?

思路:

       f(局面x){
            for(可能的所有走法){
            試走x->y;
            if(f(y)==輸)
        then return 贏;
            回溯;
            }
            return 輸;

        }

//當調用的雙方共用了某個數據結構,則需要回溯,否則,當另一方下次調用時,會發生錯誤

【源代碼】

【JAVA:於航】

public class A        //數據量比較大時,程序會癱瘓(跑不動了)
{
    static boolean f(int n){//n:球數
        if(n==0) return true;//必贏
       
        if(n>=1 && f(n-1)==false) return true;
        if(n>=3 && f(n-3)==false) return true;
        if(n>=7 && f(n-7)==false) return true;
        if(n>=8 && f(n-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));
        }
    }

}

4. 填字母游戲

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
【源代碼】

【JAVA:於航】

import java.util.*;
public class A
{
    // -1: 必輸,0: 平局, 1: 必贏
    static int f(char[] x)
    {
        String s = new String(x);      
        if(s.contains("LOL")) return -1;
        if(s.contains("*")==false) return 0;
       
        boolean ping = false;  // 假設無法平局
       
        for(int i=0; i<x.length; i++){
            if(x[i]=='*'){
                try{
                    x[i]='L';  //試着填L
                    switch(f(x)){
                        case -1: return 1;
                        case 0: ping = true;
                    }
                    x[i]='O';  //試着填O
                    switch(f(x)){
                        case -1: return 1;
                        case 0: ping = true;
                    }
                }
                finally{           
                    x[i]='*';//回溯
                }
            }
        }
       
        if(ping) return 0;
        return -1;
    }
   
    static int game(String s)
    {
        return f(s.toCharArray());
    }
   
    public static void main(String[] args)
    {  
        System.out.println(game("***"));
        System.out.println(game("L**L"));
        System.out.println(game("L**L***L"));
        System.out.println(game("L*****L"));
    }
}


import java.util.*;
public class LOL
{
    static Map<String, Integer> map = new HashMap<String, Integer>();
   
    // -1: 必輸,0: 平局, 1: 必贏
    static int f(char[] x)
    {
        String s = new String(x);
        if(map.get(s) != null) return map.get(s);
       
        if(s.contains("LOL")) {
            map.put(s,-1);
            return -1;
        }
        if(s.contains("*")==false) {
            map.put(s,0);
            return 0;
        }
       
        boolean ping = false;
       
        for(int i=0; i<x.length; i++){
            if(x[i]=='*'){
                try{
                    x[i]='L';
                    {
                        int t = f(x);
                        if(t<0) {
                            map.put(s,1);
                            return 1;
                        }
                        if(t==0) ping = true;
                    }
                    x[i]='O';
                    {
                        int t = f(x);
                        if(t<0) {
                            map.put(s,1);
                            return 1;
                        }
                        if(t==0) ping = true;
                    }      
                }
                finally{           
                    x[i]='*';
                }
            }
        }
       
        if(ping){
            map.put(s,0);
            return 0;
        }
       
        map.put(s,-1);
        return -1;
    }
   
    static int game(String s)
    {
        map.clear();
        return f(s.toCharArray());
    }
   
    public static void main(String[] args)
    {  
        Scanner scan = new Scanner(System.in);
       
        int n = Integer.parseInt(scan.nextLine().trim());
        for(int i=0; i<n; i++){
            System.out.println(game(scan.nextLine().trim()));
        }
    }

}

尼姆定理:

斯普萊格-格隆第定理:任何一個無偏游戲都可以等價到尼姆堆

5. 高僧斗法

古時喪葬活動中經常請高僧做法事。
儀式結束后,有時會有“高僧斗法”的趣味節目,以舒緩壓抑的氣氛。
節目大略步驟為:先用糧食(一般是稻米)在地上“畫”出若干級台階(表示N級浮屠)。
又有若干小和尚隨機地“站”在某個台階上。
最高一級台階必須站人,其它任意。(如圖所示)


兩位參加斗法的法師分別指揮某個小和尚向上走任意多級的台階,但會被站在高級台階上的小和尚阻擋,不能越過。
兩個小和尚也不能站在同一台階,也不能向低級台階移動。
兩法師輪流發出指令,最后所有小和尚必然會都擠在高段台階,再也不能向上移動。
輪到哪個法師指揮時無法繼續移動,則游戲結束,該法師認輸。
對於已知的台階數和小和尚的分布位置,請你計算先發指令的法師該如何決策才能保證勝出。
輸入數據為一行用空格分開的N個整數,表示小和尚的位置。台階序號從1算起,所以最后一個小和尚的位置即是台階的總數。(N<100, 台階總數<1000)
輸出為一行用空格分開的兩個整數: A B, 表示把A位置的小和尚移動到B位置。
若有多個解,輸出A值較小的解,若無解則輸出-1。
例如:
用戶輸入:
1 5 9
則程序輸出:
1 4
再如:
用戶輸入:
1 5 8 10
則程序輸出:
1 3
【源代碼】

【JAVA:於航】

// 組合博弈論....轉化為尼姆堆:兩個人之間的空台階數,組成一個尼姆堆
import java.util.*;
public class A
{
    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++){   

                     // x [i] +1:當前這一階的下級   k<x[i+1]:不能撞上/越過下一個小和尚的位置

                int old = x[i];  //試着走
                try{
                    x[i] = k;
                    if(f(x)==false) {
                        System.out.println(old + " " + k);
                        return;
                    }
                }
                finally{
                    x[i] = old; //回溯
                }
            }
        }
    }
   
    public static void main(String[] args)
    {  
        solve(new int[]{1,5,9});
        solve(new int[]{1,5,8,10});
        solve(new int[]{1,4,8,12,16,19,28,33,35,36,40,45,52,66,67,68,69,77
          ,85,99,102,134,155,211,214,216,355,376,400,412});
    }

}

6. 古代賭局

俗話說:十賭九輸。因為大多數賭局的背后都藏有陰謀。
不過也不盡然,有些賭局背后藏有的是:“陽謀”。
有一種賭局是這樣的:桌子上放六個匣子,編號是1至6。
多位參與者(以下稱玩家)可以把任意數量的錢押在某個編號的匣子上。
所有玩家都下注后,庄家同時擲出3個骰子(骰子上的數字都是1至6)。
輸贏規則如下:
1.若只有1個骰子上的數字與玩家所押注的匣子號相同,則玩家拿回自己的押注,庄家按他押注的數目賠付(即1比1的賠率)。
2.若2個骰子上的數字與玩家所押注的匣子號相同,則玩家拿回自己的押注,庄家按他押注的數目的2倍賠付(即1比2的賠率)。
3.若3個骰子上的數字都與玩家押注的匣子號相同,則玩家拿回自己的押注,庄家按他押注的數目的10倍賠付(即1比10的賠率)。
乍一看起來,好像規則對玩家有利,庄家吃虧。但經過大量實戰,會發現局面很難說,於是懷疑是否庄家做了手腳,庄家則十分爽快地說:可以由玩家提供骰子,甚至也可以由玩家來投擲骰子。

你的任務是:通過編程模擬該過程。模擬50萬次,假定只有1個玩家,他每次的押注都是1元錢,其押注的匣子號是隨機的。再假定庄家有足夠的資金用於賠付。最后計算出庄家的盈率(庄家盈利金額/押注總金額)。

【源代碼】

【JAVA:於航】

public class DuJu
{
    public 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 n = 0;
        if(a==w) n++;
        if(b==w) n++;
        if(c==w) n++;
       
        if(n==3) return -10;
        if(n==2) return -2;
        if(n==1) return -1;
       
        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);//即贏率  由於押注總是1元
    }

}

7. 火柴游戲(沒有半局)

這是一個縱橫火柴棒游戲。
如圖1,在3×4的格子中,游戲的雙方輪流放置火柴棒。
其規則是:
1. 不能放置在已經放置了火柴棒的地方(即只能在空格中放置)。
2. 火柴棒的方向只能是豎直或水平放置。
3. 火柴棒不能與其它格子中的火柴“連通”。
所謂連通是指兩根火柴棒可以連成一條直線,且中間沒有其它不同方向的火柴“阻攔”。
例如:
火柴游戲.jpg

圖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

【源代碼】

【JAVA:於航】

import java.util.*;
public class A
{
    static void show(char[][] data){
        System.out.println();
        for(int i=0; i<data.length; i++){
            System.out.println(new String(data[i]));
        }
    }
   
    static boolean f(char[][] data){      //遞歸:判斷是否贏 
        for(int i=0; i<data.length; i++){//檢查是否橫着連通
            String s = new String(data[i]).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]).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;    //所有的試走都為true
    }
   
    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 scan = new Scanner(System.in);
       
        char[][] data = new char[3][];
        data[0] = scan.nextLine().trim().toCharArray();
        data[1] = scan.nextLine().trim().toCharArray();
        data[2] = scan.nextLine().trim().toCharArray();
       
        solve(data);
        //System.out.println(f(data));
    }

}



注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2020 ITdaan.com