博弈本意是：下棋。引申义是：在一定条件下，遵守一定的规则，一个或几个拥有绝对理性思维的人或团队，从各自允许选择的行为或策略进行选择并加以实施，并从中各自取得相应结果或收益的过程。有时候也用作动词，特指对选择的行为或策略加以实施的过程。
一个完整的博弈应当包括五个方面的内容：
第一，博弈的参加者，即博弈过程中独立决策、独立承担后果的个人和组织；
第二，博弈信息，即博弈者所掌握的对选择策略有帮助的情报资料；
第三，博弈方可选择的全部行为或策略的集合；
第四，博弈的次序，即博弈参加者做出策略选择的先后；
第五，博弈方的收益，即各博弈方做出决策选择后的所得和所失。
而我们在计算机中，遇到博弈问题时大多数以模拟实现的方式解决问题。
对于大部分可以直接进行模拟实现的，可以直接使用暴力破解的方式解决。
【问题描述】大数学家高斯有个好习惯：无论如何都要记日记。
他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210
后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？
高斯出生于：1777年4月30日。
在高斯发现的一个重要定理的日记上标注着：5343，因此可算出那天是：1791年12月15日。
高斯获得博士学位的那天日记上标着：8113
请你算出高斯获得博士学位的年月日。
思路：从问题本质来看，这个问题意在设计一个日期计算器，那么我们可根据高斯的生日为起点，让日记记载的天数按需加入到年月日当中，直接暴力破解得出答案。
我要评论
public class GaussDiary {
static boolean isLeapYear(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 String day_jurge(int days) {
String s = "";
int year = 1777;
int month = 4;
int day = 30;
int[] M = {0,31,28,31,30,31,30,31,31,30,31,30,31};
while(day != days) {
days--;
if(isLeapYear(year)) {
M[2] = 29;
}else {
M[2] = 28;
}
if(day > M[month]) {
month++;
if(month > 12) {
month = 1;
year++;
}
day = 0;
}
day++;
}
s = s + year +"-"+month+"-"+day;
return s;
}
public static void main(String[] args) {
System.out.println(day_jurge(8113));
}
}
对于上题，我们也可以直接延申到两日期计算差的问题上来，同理也可以使用暴力破解，唯一不同是，两日期差计算是没有基准的，那么我们可以人为制造基准，假设以1年1月1日起计算，那么两日期距离这个基准的天数相减，就是所需两日期只差了。
public class DateDifferenceMatter {
static boolean isYearLeap(int y) {
boolean tag = false;
if(y % 4 == 0)
tag = true;
if(y % 100 == 0)
tag = false;
if(y % 400 == 0)
tag = true;
return tag;
}
static int dayCalculation(int year1,int month1,int day1,
int year2,int month2,int day2) {
return daDate(year2,month2,day2) - daDate(year1,month1,day1);
}
static int daDate(int year,int month,int day) {
int sumdays = 0;
int[] M = {0,31,28,31,30,31,30,31,31,30,31,30,31};
for(int i = 1;i<year;i++) {
sumdays += 365;
if(isYearLeap(i)) {
sumdays++;
}
}
if(isYearLeap(year)) {
M[2] = 29;
}
for(int i = 1;i<month;i++) {
sumdays += M[i];
}
sumdays += day;
return sumdays;
}
public static void main(String[] args) {
System.out.println(dayCalculation(1997,12,26,2020,06,21));
}
}
【问题描述】1949年的国庆节（10月1日）是星期六。
今年（2012）的国庆节是星期一。
那么，从建国到现在，有几次国庆节正好是星期日呢？
只要答案，不限手段！
可以用windows日历，windows计算器，Excel公式，。。。。。
当然，也可以编程！
思路：这个真题就是不限手段的，但在不使用网络的情况下，显然用日历去数，还是找计算规律，都不如直接使用编程模拟实现来的方便，同理如上题，使用暴力破解模拟实现。
我们要找那些年份国庆节在周日，只需要判断哪些年份国庆节在周日。
我们发现题目所求1949年10月2日为周日，那么只要所判断年份与1949年10月2日的差能被7整除，必定是在周日。
而日期只差仿效上题可实现。
public class NationalDayOnSunday {
static boolean isYearLeap(int y) {
boolean tag = false;
if(y % 4 == 0)
tag = true;
if(y % 100 == 0)
tag = false;
if(y % 400 == 0)
tag = true;
return tag;
}
static int daDate(int year,int month,int day) {
int sumdays = 0;
int[] M = {0,31,28,31,30,31,30,31,31,30,31,30,31};
for(int i = 1;i<year;i++) {
sumdays += 365;
if(isYearLeap(i)) {
sumdays++;
}
}
if(isYearLeap(year)) {
M[2] = 29;
}
for(int i = 1;i<month;i++) {
sumdays += M[i];
}
sumdays += day;
return sumdays;
}
public static void main(String[] args) {
int total = 0;
int sum = 0;
for(int i = 1950;i<2012;i++) {
total = (daDate(i,10,1) - daDate(1949,10,2));
if(total % 7 == 0) {
System.out.println(i+"年10月1日");
sum++;
}
}
System.out.println("总数："+sum);
}
}
【问题描述】今盒里有n个小球，A、B两人轮流从盒中取球。
每个人都可以看到另一个人取了多少个，也可以看到盒中还剩下多少个。
两人都很聪明，不会做出错误的判断。
每个人从盒子中取出的球的数目必须是：1，3，7或者8个。
轮到某一方取球时不能弃权！
A先取球，然后双方交替取球，直到取完。
被迫拿到最后一个球的一方为负方（输方）
编程确定出在双方都不判断失误的情况下，对于特定的初始球数，A是否能赢？
思路：同样的暴力破解模拟实现，但可以使用递归算法，将本体视为一个博弈者，完成所需完成步骤后，将下一个递归看作另外一个博弈者，如果上一个博弈者输了，那现在的博弈者就是赢了。
public class TakeBallGame {
static boolean takeBall(int n) {
if(n == 0)
return true;
if(n >= 1 && takeBall(n-1) == false)
return true;
if(n >= 3 && takeBall(n-1) == false)
return true;
if(n >= 7 && takeBall(n-1) == false)
return true;
if(n >= 8 && takeBall(n-1) == false)
return true;
return false;
}
public static void main(String[] args) {
for(int i = 1;i<50;i++) {
System.out.println(i+":"+takeBall(i));
}
}
}
【问题描述】俗话说：十赌九输。因为大多数赌局的背后都藏有阴谋。
不过也不尽然，有些赌局背后藏有的是：“阳谋”。
有一种赌局是这样的：桌子上放六个匣子，编号是1至6。
多位参与者（以下称玩家）可以把任意数量的钱押在某个编号的匣子上。
所有玩家都下注后，庄家同时掷出3个骰子（骰子上的数字都是1至6）。
输赢规则如下：
1.若只有1个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目赔付（即1比1的赔率）。
2.若2个骰子上的数字与玩家所押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的2倍赔付（即1比2的赔率）。
3.若3个骰子上的数字都与玩家押注的匣子号相同，则玩家拿回自己的押注，庄家按他押注的数目的10倍赔付（即1比10的赔率）。
乍一看起来，好像规则对玩家有利，庄家吃亏。但经过大量实战，会发现局面很难说，于是怀疑是否庄家做了手脚，庄家则十分爽快地说：可以由玩家提供骰子，甚至也可以由玩家来投掷骰子。
你的任务是：通过编程模拟该过程。模拟50万次，假定只有1个玩家，他每次的押注都是1元钱，其押注的匣子号是随机的。再假定庄家有足够的资金用于赔付。最后计算出庄家的盈率（庄家盈利金额/押注总金额）。
思路：暴力破解，随机数模拟骰子和人会选择的数，记录庄家赢取的金额。
public class FraudulentGambling {
static long solution() {
int a = (int)(Math.random() * 6 + 1);
int b = (int)(Math.random() * 6 + 1);
int c = (int)(Math.random() * 6 + 1);
int cilence = (int)(Math.random() * 6 + 1);
int n = 0;
if(cilence == a)
n++;
if(cilence == b)
n++;
if(cilence == c)
n++;
if(n == 1)
return -1;
if(n == 2)
return -2;
if(n == 3)
return -10;
return 1;
}
public static void main(String[] args) {
int N = 500*10000;
int sum = 0;
for(int i = 0;i<N;i++) {
sum += solution();
}
System.out.println((double)sum/N*100 + "%");
}
}
对于相对困难，需要对字符或字符串进行操作，或者更复杂的情况，我们可以考虑使用排列组合中试探的方式实现。
【问题描述】K大师在纸上画了一行n个格子，要小明和他交替往其中填入字母。
- 轮到某人填的时候，只能在某个空格中填入L或O
- 谁先让字母组成了“LOL”的字样，谁获胜。
- 如果所有格子都填满了，仍无法组成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
思路：使用试探，尝试填入“L”“O”，再经递归实现博弈现象，当然会返回两个不同的值，-1和0，-1说明对方输，则返回1，0说明平局，返回0，如此解决问题。
import java.util.Scanner;
public class AlphabetGame {
static int game(String s) {
if(s.contains("LOL"))
return -1;
if(s.contains("*") == false)
return 0;
boolean ping = false;
char[] x = s.toCharArray();
for(int i = 0;i<x.length;i++) {
if(x[i] == '*') {
try {
x[i] = 'L';
switch(game(String.valueOf(x))){
case -1 : return 1;
case 0: ping = true;
}
x[i] = 'O';
switch(game(String.valueOf(x))){
case -1 : return 1;
case 0: ping = true;
}
}
finally {
x[i] = '*';
}
}
}
if(ping)
return 0;
return -1;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
String[] srr = new String[n];
for(int i = 0;i<n;i++) {
srr[i] = sc.next();
}
for(int i = 0;i<n;i++) {
System.out.println(game(srr[i]));
}
}
}
【问题描述】古时丧葬活动中经常请高僧做法事。
仪式结束后，有时会有“高僧斗法”的趣味节目，以舒缓压抑的气氛。
节目大略步骤为：先用粮食（一般是稻米）在地上“画”出若干级台阶（表示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 FightingMethodOfEminentMonks {
static boolean nim(int[] nim) {
int sum = 0;
for(int i=0;i<nim.length-1;i+=2) {
sum ^= nim[i+1] - nim[i] - 1;
}
return sum != 0;
}
static void solution(int[] arr) {
for(int i = 0;i<arr.length-1;i++) {
for(int j = arr[i]+1;j<arr[i+1];j++) {
int old = arr[i];
try {
arr[i] = j;
if(nim(arr) == false) {
System.out.println(old+" "+j);
}
}
finally {
arr[i] = old;
}
}
}
}
public static void main(String[] args) {
solution(new int[] {1,5,9});
solution(new int[] {1,5,8,10});
}
}
【问题描述】
这是一个纵横火柴棒游戏。
如图1，在3x4的格子中，游戏的双方轮流放置火柴棒。
其规则是：
- 不能放置在已经放置了火柴棒的地方（即只能在空格中放置）。
- 火柴棒的方向只能是竖直或水平放置。
- 火柴棒不能与其它格子中的火柴“连通”。
所谓连通是指两根火柴棒可以连成一条直线，且中间没有其它不同方向的火柴“阻拦”。
例如：
图1所示的局面下，可以在C2位置竖直放置（为了方便描述格子位置，图中左、下都添加了标记），但不能水平放置，因为会与A2连通。
同样道理，B2，B3，D2此时两种方向都不可以放置。
但如果C2竖直放置后，D2就可以水平放置了，因为不再会与A2连通（受到了C2的阻挡）。- 游戏双方轮流放置火柴，不可以弃权，也不可以放多根。
如某一方无法继续放置，则该方为负（输的一方）。
游戏开始时可能已经放置了多根火柴。你的任务是：编写程序，读入初始状态，计算出对自己最有利的放置方法并输出放置后的局面。
图1的局面表示为：
00-1
-000
0100
即用“0”表示空闲位置，用“1”表示竖直放置，用“-”表示水平放置。
解法不唯一，找到任意解法即可。
例如，局面：
0111
-000
-000
的解：
-111
-000
-000
再例如，局面：
1111
横横横横
0010
的解：
1111
横横横横
0110
import java.util.Scanner;
public class MatchGame {
static void show(char[][] srr) {
System.out.println();
for(int i = 0;i<srr.length;i++) {
System.out.println(String.valueOf(srr[i]));
}
}
static boolean jurge(char[][] srr) {
for(int i = 0;i<srr.length;i++) {
String s = new String(srr[i]).replaceAll("0", "");
if(s.contains("--"))
return true;
}
for(int i = 0;i<srr[0].length;i++) {
String s = (""+srr[0][i]+srr[1][i]+srr[2][i]).replaceAll("0", "");
if(s.contains("11"))
return true;
}
for(int i = 0;i<srr.length;i++) {
for(int j = 0;j<srr[i].length;j++) {
if(srr[i][j] == '0') {
try {
srr[i][j] = '1';
if(jurge(srr) == false)
return true;
srr[i][j] = '-';
if(jurge(srr) == false)
return true;
}
finally {
srr[i][j] = '0';
}
}
}
}
return false;
}
static void solution(char[][] srr) {
for(int i = 0;i<srr.length;i++) {
for(int j = 0;j<srr[0].length;j++) {
if(srr[i][j] == '0') {
try {
srr[i][j] = '1';
if(jurge(srr) == false) {
show(srr);
return;
}
srr[i][j] = '-';
if(jurge(srr) == false) {
show(srr);
return;
}
}
finally {
srr[i][j] = '0';
}
}
}
}
System.out.println("you loset!");
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
char[][] match = new char[3][];
match[0] = sc.nextLine().trim().toCharArray();
match[1] = sc.nextLine().trim().toCharArray();
match[2] = sc.nextLine().trim().toCharArray();
solution(match);
}
}
我们日常生活中还有很多经典的博弈问题，他们同样可以使用上面的方法进行编程解决。
【问题描述】三个妃子分金币，韩非子规定：A、B、C三人分100枚金币，按顺序提议A->B->C，如果提议未获半数以上通过，半数以上不包括半数，提议人就要被处死。
处死后，剩下的人继续提议，如果通过了，即获得半数以上通过，不包括半数。
前提是：1、三个妃子都是绝对聪明的，会以如何让自己获得最大利益为目标。
2、人性本恶，三人都是邪恶的，不会考虑他人生命安全。那么在这样的规则下，谁是最危险的？假设你是A你会怎么提议？
【问题描述】由两个人玩抢"20"的游戏,游戏规则是这样的,第一个先说"1"或"1,2",第二个人要接着往下说一个或两个数,然后轮到第一个人,再接着往下说一个或两个数,这样两个人反复轮流,每次每人说一个或两个都可以,但是不可以连说三个数,谁先抢到20,谁就获胜你认为这个游戏公平吗?(1)若不公平,它偏向哪个报数人?(2)让你先说,你有必胜的把握吗?说出你获胜的策略
本文地址：https://blog.csdn.net/qq_40893595/article/details/106899036
如对本文有疑问， 点击进行留言回复！！
【2020-07】js获取访客百度搜索关键词最新方法（SEO、竞价、推广、访客浏览页）
JS call apply bind原理与实现和函数柯理化总结
let a = {n : 1}；let b = a；a.x = a = {n: 2}；console.log(a.x) console.log(b.x)
网友评论