算法笔记--博弈

runnerxin runnerxin 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 300+累计阅读 320平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-06-29 00:08:49 发布 320 阅读 AI 写同款· GEO 优化 ›
算法笔记 经典取石子游戏总结 博弈论 经典取石子游戏总结 1.巴什博弈 有一堆石子共n个，A和B轮流取，A先取。每次最少取1个，最多取m个，先取完者获胜（即没有石子取的人失败）。A与B都足够聪明，问A能否获胜。 结论：当n%(m+1)!=0时A必胜，否则必败。 2.斐波那契博弈 有一堆石子共n个，A和B轮流取，A先取。每次最少取1个。第一次不能取完。从第二次开始，每个人取的石子数至少为1，至多为前一个人取的石子数的2倍。先取完者获胜。... 阅读详情

（一）巴什博奕（Bash Game）：只有一堆n个物品，两个人轮流从这堆物品中取物，规
定每次至少取一个，最多取m个。最后取光者得胜。
n=（m+1）r+s

（二）威佐夫博奕（Wythoff Game）：有两堆各若干个物品，两个人轮流从某一堆或同
时从两堆中取同样多的物品，规定每次至少取一个，多者不限，最后取光者得胜。
奇异局势（先手输）。前几个奇异局势是：（0，0）、（1，2）、（3，5）、（4，7）、（6，
10）、（8，13）、（9，15）、（11，18）、（12，20）
ak =[k（1+√5）/2]，bk= ak + k （k=0，1，2，…,n 方括号表示取整函数)

if(n<m) swap(n,m);
int k=n-m;
n=(int)(k*(1+sqrt(5))/2.0);
if(n==m) printf("0\n");
else printf("1\n");

（三）尼姆博奕（Nimm Game）：有三堆各若干个物品，两个人轮流从某一堆取任意多的
物品，规定每次至少取一个，多者不限，最后取光者得胜。

取完胜

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main(){
    int n;
    int a[22];
    while(scanf("%d",&n)!=EOF){
        int out=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
             out^=a[i];
        }
        if(out==0) printf("No\n");
        else printf("Yes\n");
    }
    return 0;
}

取完负

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>

using namespace std;

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        scanf("%d",&n);
        int ans=0;
        int flag=0;
        for(int i=0;i<n;i++){
            int x;
            scanf("%d",&x);
            ans^=x;
            if(x>1) flag=1;
        }
        if((ans&&!flag)||(!ans&&flag)) printf("Brother\n");
        else printf("John\n");
    }
    return 0;
}

（四）SG博奕（通用）
我们把整个博弈过程抽象为有向无环图
mex求最小非负整数mex{} = 0,mex{0,1,2,4} = 3,mex{1,2,4} = 0
sg[x] =mex{sg[y]|y是x的后继}//就是石头变少的继
这样sg就满足几个性质

  1. sg[x] == 0时，它的后继都不为零

  2. sg[x] != 0时，它的后继一定有为零的

  3. 当x点没有出边时，sg[x] == 0

这三个性质恰好与P-positon（先手必败）的性质相同：
（1）.无法进行任何移动的局面（也就是terminal position）是P-position；
（2）.可以移动到P-position的局面是N-position；
（3）.所有移动都导致N-position的局面是P-position。
由此可知：sg[x] == 0,x就是p-position

eg-hdu3980
一个圆环N个数，每次每个人只能给连续的M个数抹漆，最后不能抹的就算输
比如（5,2） +++++，
当前边空0个时子游戏为（0,2）（3,2）
当前边空1个时子游戏有（1,2）（2,2）
当前边空2个时子游戏有（2,2）（1,2）
当前边空3个时子游戏有（3,2）（0,2）

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<queue>
#include<vector>
#include<map>
#include<stack>
#include<set>
using namespace std;
typedef long long LL;
int SG[1005];

int getSG(int n,int m){
    if(n<m) return SG[n]=0;
    if(SG[n]!=-1) return SG[n];
    bool visit[1005];// //下边递归了。。不要放全局去。。。

    memset(visit,false,sizeof(visit));
    for(int i=0;i<=n-m;i++){
        visit[getSG(i,m)^getSG(n-m-i,m)]=true;
    }
    for(int i=0;;i++){
        if(visit[i]==false){
            SG[n]=i;
            break;
        }
    }
    return SG[n];
}
int main(){
    int t;
    scanf("%d",&t);
    for(int test=1;test<=t;test++){
        int n,m;
        scanf("%d %d",&n,&m);
        memset(SG,-1,sizeof(SG));
        printf("Case #%d: ",test);
        if(n<m||getSG(n-m,m)) printf("abcdxyzk\n");
        else printf("aekdycoin\n");
    }
    return 0;
}

eg-hdu5724
给一个n*20的棋盘，先给出了一堆棋子的位置，两个人轮流着进行操作。
操作：可以将棋子移到右边的第一个空位上，（不能多隔空位）
11100之后的状态可以有。11010,10110,01110.
假如直接将这种状态看成一个数（20位，不大），所以直接状压预处理出所有状态的SG，然后N行直接多问题SG亦或。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
bool SG[2000004];
int a[24];
bool visit[24];

int pow2[22];

inline void getp(){
    pow2[0]=1;
    pow2[1]=2;
    for(int i=2;i<=20;i++) pow2[i]=pow2[i-1]*2;
}
inline void geta(int x){
    int cnt=20;
    memset(a,0,sizeof(a));
    while(x){
        a[cnt--]=x%2;
        x=x/2;
    }
}
inline int getnew(int x,int i,int j){
    return x-pow2[i-1]+pow2[j-1];
}

void getSG(){
    memset(SG,0,sizeof(SG));
    int zhuang=(1<<20)-1;
    for(int i=1;i<=zhuang;i++){
        geta(i);
        memset(visit,0,sizeof(visit));
        int k=21;
        for(int j=20;j>=1;j--){
            if(a[j]==0){
                k=j;
                continue;
            }
            if(k==21) continue;
            visit[SG[getnew(i,21-j,21-k)]]=true;
        }
        for(int j=0;;j++){
            if(visit[j]==false){
                SG[i]=j;
                break;
            }
        }
    }
}
int main(){
    getp();
    getSG();
    int t;
    scanf("%d",&t);
    while(t--){
        int n;
        int out=0;
        scanf("%d",&n);
        while(n--){
            int pp=0,w,c;
            scanf("%d",&c);
            while(c--){
                scanf("%d",&w);
                pp+=pow2[20-w];
            }
            out^=SG[pp];
        }
        if(out) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

eg–hdu5795
两个人轮流从n堆石子里取走任意个（至少一个），或则不拿走石子，但是讲石子分成3堆。每堆至少为一个。最后没有石子去的人输。对于如果没有第二种分石子情况就是nim博弈，但是加了第二种状态后就不是了。因此对于每一堆石子都因该有一个SG值，因此直接对一堆石子打表SG然后找下规律就可以发现。当x%8==0 sg=x-1,当x%8==7 sg=x+1,其他的sg=x。所以所有堆sg亦或就是答案。

#include<cstdio>
#include<cstring>
using namespace std;

int SG[10006];
int getSG(int x){  //针对于一堆而言
    if(SG[x]!=-1) return SG[x];
    if(x==0) return 0; //0个可以输
    if(x==1) return 1; //1个可以赢

    int visit[10006];
    memset(visit,0,sizeof(visit));

    for(int i=0;i<x;i++) visit[getSG(i)]=1; //当成一堆时的可到状态

    for(int i=1;i<x;i++){  //分成3堆
        for(int j=i;j<x;j++){
            for(int k=j;k<x;k++){
                if(i+j+k==x){ //子问题的亦或是可到状态
                    visit[getSG(i)^getSG(j)^getSG(k)]=1;
                }
            }
        }
    }

    for(int i=0;;i++){
        if(visit[i]==0){
            return i;
        }
    }
}
int n;
int x;
int main(){
    /*
    memset(SG,-1,sizeof(SG));
    for(int i=1;i<100;i++){
        SG[i]=getSG(i);
        printf("%2d:%d\n",i,SG[i]);
    }*/

    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        int ans=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&x);
            if(x%8==0) ans^=(x-1);
            else if(x%8==7) ans^=(x+1);
            else ans^=x;
        }
        if(ans) printf("First player wins.\n");
        else printf("Second player wins.\n");
    }
    return 0;
}

eg–hdu4111

题意：有一堆的数字，两种操作：1：将某一个数值减1、2：将两个数字合并
解法：SG[i][j]表示有i个石子数为1的堆数，其它堆合并再取完的步数为j。直接SG扫就好了。。。
有几个地方重点说一下，我最开始也是没理解，后来懂了。。
（1）if(one>=1&&!getSG(one-1,sumstep)) return SG[one][sumstep]=1;
比赛时和菊苣手动模拟了一下，其实每一种状态，不管是怎样合并或取数只要子状态里出现了先手必输的状态，因此该状态可以转移到让对手必输，所以自己必赢。。。（也就只有这个点比赛时发现了）
(2) if(one>=1&&sumstep>=1&&!getSG(one-1,sumstep+1)) return SG[one][sumstep]=1;
将一个1合并到非1的上去，其他的操作步数为什么时+1，而不是2（合并+去掉），因为+2其实就是他本身的等价状态并不是子状态。+1（去掉）才是子状态。同理类推第四种情况的时候。

#include<bits/stdc++.h>
using namespace std;
int SG[55][55000];
//SG[i][j]表示有i个石子数为1的堆数，其它堆合并再取完的步数为j。
//若值为1则先取者胜，为0为先取者输
int getSG(int one,int sumstep){
    if(SG[one][sumstep]!=-1) return SG[one][sumstep];
    //没有1的时候就是各取一个
    if(one==0&&sumstep%2==1) return SG[one][sumstep]=1;
    else if(one==0&&sumstep%2==0) return SG[one][sumstep]=0;
    //当其他的步数为1时，
    if(sumstep==1) return SG[one][sumstep]=getSG(one+1,0);

    //只要找到一种是输的其他状态。那他就能赢
    SG[one][sumstep]=0;
    //1的个数去掉一个
    if(one>=1&&!getSG(one-1,sumstep)) return SG[one][sumstep]=1;
    //非1的个数去掉一个
    if(sumstep>=1&&!getSG(one,sumstep-1)) return SG[one][sumstep]=1;
    //将1的合并到非1的上去
    if(one>=1&&sumstep>=1&&!getSG(one-1,sumstep+1)) return SG[one][sumstep]=1;
    //将两个1的合并
    if(one>=2){
        //非1的为0，相当于将一个1加到另一个1上，
        if(sumstep==0&&!getSG(one-2,sumstep+2)) return SG[one][sumstep]=1;
         //非1的为0，相当于将两个1加到非1上，
        else if(sumstep!=0&&!getSG(one-2,sumstep+3)) return SG[one][sumstep]=1;
    }
    return SG[one][sumstep];
}

int main(){
    int t;
    scanf("%d",&t);
    memset(SG,-1,sizeof(SG));
    for(int cas=1;cas<=t;cas++){
        int n;
        int one=0,sumstep=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            if(x==1) one++;
            else sumstep+=x+1;//合并，去掉
        }
        if(sumstep) sumstep--; //合并为p-1次，
        if(getSG(one,sumstep)) printf("Case #%d: Alice\n",cas);
        else printf("Case #%d: Bob\n",cas);
    }
    return 0;
}

SG 模板写法
#include<bits/stdc++.h>
using namespace std;
int SG[55][55000];
int getSG(int one,int sumstep){
    if(SG[one][sumstep]!=-1) return SG[one][sumstep];
    if(one==0&&sumstep%2==1) return SG[one][sumstep]=1;
    else if(one==0&&sumstep%2==0) return SG[one][sumstep]=0;

    if(sumstep==1) return SG[one][sumstep]=getSG(one+1,0);

    //SG[one][sumstep]=0;
    bool visit[2];
    memset(visit,false,sizeof(visit));

    if(one>=1) visit[!getSG(one-1,sumstep)]=true;
    if(sumstep>=1)visit[!getSG(one,sumstep-1)]=true;
    if(one>=1&&sumstep>=1) visit[!getSG(one-1,sumstep+1)]=true;
    if(one>=2){
        if(sumstep==0) visit[!getSG(one-2,sumstep+2)]=true;
        else visit[!getSG(one-2,sumstep+3)]=true;
    }
    if(visit[1]==true) return SG[one][sumstep]=1;//推出来的
    else return SG[one][sumstep]=0;
}

int main(){
    int t;
    scanf("%d",&t);
    memset(SG,-1,sizeof(SG));
    for(int cas=1;cas<=t;cas++){
        int n;
        int one=0,sumstep=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            if(x==1) one++;
            else sumstep+=x+1;//合并，去掉
        }
        if(sumstep) sumstep--; //合并为p-1次，
        if(getSG(one,sumstep)) printf("Case #%d: Alice\n",cas);
        else printf("Case #%d: Bob\n",cas);
    }
    return 0;
}
收录于
算法--数论博弈

当前文章被收录于：

算法--数论博弈
4 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
算法博弈论笔记 - 3 梅尔森的引理 算法博弈论笔记 - 3 梅尔森的引理 因为感觉看英文教材比较不好理解，所以打算把重点记下来。 维氏拍卖作为一个好的拍卖(Awesome Auctions)，具有3个保证 [强动机保证] DSIC (Dominant Strategy Incentive Compatible). 即真实的竞价是优势策略，并且永远不会导致负的效益。 追求DSIC的理由有两个： 投标人只需要很轻易地投出对于他们来说最具有优势的价格； 如果所有投标人都按照优势策略的价格进行投标，那么我们能够很自信地预测拍卖的结果。 [ 阅读详情

相关推荐

算法博弈论笔记 - 4 算法机制设计

本节通过运用梅尔森的引理，在单一参数环境下设计对于背包问题的DSIC机制。 定义问题 在背包问题中，每位投标人iii都公开地有一个需要投标的size wisize \text{ }w_isize wi​表示大小，以及对于大小的一个私有的估价。设拍卖的容量为WWW，可行集合XXX是由0-1的集合(x1,…,xn)(x_1,\ldots,x_n)(x1​,…,xn​)组成，并且∑i=1nwixi<=W\sum _{i=1}^n w_ix_i <= W∑i=1n​wi​xi​&l.

sonetto的博客 1403

【算法设计与分析】三个博弈论算法分析

主要讨论三个比较常见的博弈游戏 Bash Game,Nim Game和Wythoff Game，较为领人惊叹的是，他们最后都是通过数论或者自然数性质完美解决： Bash    Game:同余理论 Nim      Game:异或理论 Wythoff Game:黄金分割 （1）Bash Game：一堆n个物品，两人轮流取，每次取1至m个，最后取完者胜           比如10个物品，

精灵的博客 1万+

《斯坦福算法博弈论二十讲》学习笔记（持续更新）

《斯坦福算法博弈论二十讲》学习笔记（持续更新）第一章 简介和实例第二章 机制设计基础第三章 迈尔森引理第四章 算法机制设计 第一章 简介和实例 羽毛球比赛中的规则漏洞 12年伦敦奥运会的羽毛球赛事中发生了一件钻规则漏洞的“丑闻”。赛制规则如下：共分为两个小组，每个小组四只队伍，小组赛阶段各个小组的前两名晋级，A组第1名对阵B组第2名，A组第2名对阵B组第1名，之后进行两两淘汰赛。 TZ是本届赛事公认的强队，已经提前小组赛出线。WY与JK进行一场小组赛，二者之间的胜者将会对阵TZ，因此两只队伍都不想赢，都在

dzc_go的博客 5058

四种博弈总结

1.巴什博弈 题目大意： 1、 本游戏是一个二人游戏; 2、 有一堆石子一共有n个； 3、 两人轮流进行; 4、 每走一步可以取走1…m个石子； 5、 最先取光石子的一方为胜； 显然如果n=m+1,最多只能取m个石子，所以不管先取者拿走多少个石子，后取者必能取光，后取者胜利。所以如果n%(m+1)==0，后取者胜利，反之先取者胜利。 [题目链接 HDU 2846](http:...

YOUNG的博客 3319

【算法竞赛学习笔记】博弈论（二）——SG函数及经典问题

title : 博弈论（二） date : 2021-11-6 tags : ACM,数学,博弈论 author : Linno 前置芝士——SG函数 可以看我上一篇博客：https://blog.youkuaiyun.com/SC_Linno/article/details/121181361 首先给出一种ICG博弈游戏模型，给定一个有向无环图和一个起始顶点上的一枚棋子，两名选手交替的将这枚棋子沿有向边进行移动，无法移动者判负。 将ICG问题进行转换：任何一个ICG都可以通过把每个局面看成一个顶点，对每个局面和.

SC_Linno的博客 3474

【第一篇】Xshell连接服务器部署前后端项目(连接服务器）

利用Xshell连接服务器部署前后端项目

blog 1074

威佐夫博奕

威佐夫博奕

SHUI 919

告别MATLAB环境！保姆级教程：用Application Compiler把你的GUI程序打包成独立exe（2020R版本实测）

本文详细介绍了如何使用MATLAB的Application Compiler工具将GUI程序打包成独立exe文件，特别针对2020R版本进行实测。从技术原理、配置详解到打包实战与问题排查，提供完整的解决方案，帮助开发者实现无需MATLAB环境的程序分发，提升工作效率。

weixin_30571465的博客 274

算法笔记：博弈问题

先找到XOR最高位1（即前面的所有位都为0），找所有堆数量的二进制位包含这位1（至少有一个，因为是奇数），将除这个数的其余均XOR，结果一定<这个数（设该位1为第x位，那么XOR结果前x位都为0，而这个数第x位为1），因此通过调整这个数，可以使得（这个数）XOR（其余数XOR结果）==0。=0，那么我一定可以通过玩一个小ICG游戏，使得总XOR值==0，即将敌方掉入必输局面（XOR==0，即SG总（x）== 0）。还是有必败点SG（0）== 0，设SG（x）== 0，表示当前局面必败；

GANIT的博客 583

Python实战：5分钟搞定N-CMAPSS航空发动机数据集解析（附完整代码）

本文提供了一份针对N-CMAPSS航空发动机数据集的快速解析实战指南。通过Python的h5py和Pandas库，详细演示了如何高效读取HDF5格式文件、理解数据结构、提取关键特征（如传感器数据与剩余使用寿命RUL），并整合为可用于预测性维护分析的DataFrame，帮助研究者和工程师快速上手这一重要的工业时序数据集。

weixin_29083373的博客 281

广东电信兆能Z82盒子救砖记：手把手教你用U盘强刷HI3798MV100固件（附短接图）

本文详细介绍了广东电信兆能Z82盒子变砖后的救砖方法，重点讲解了使用U盘强刷HI3798MV100固件的全流程，包括诊断、准备工作、短接操作及刷机后的优化设置。特别针对m8233主板和8188无线方案的机型，提供了实用的短接图和操作技巧，帮助用户成功恢复设备。

weixin_30325487的博客 404

组合博弈入门算法笔记

组合博弈入门算法笔记 取子游戏： 什么是组合游戏—— 有两个玩家； 游戏的操作状态是一个有限的集合（比如：限定大小的棋盘）； 游戏双方轮流操作； 双方的每次操作必须符合游戏规定； 当一方不能将游戏继续进行的时候，游戏结束，同时，对方为获胜方； 无论如何操作，游戏总能在有限次操作后结束。 概念：必败点和必胜点（P点&N点） 必败点（P点）：前一个选手（Previous player）将取胜的位置成为必败点。即下一个选手必败。 必胜点（N点）：下一个选手（Next player）将取胜的位置成为必

qq_51207080的博客 1347

用AT7456E给监控摄像头加OSD？5步搞定时间水印和Logo叠加

本文详细解析了如何使用AT7456E视频字符叠加芯片为监控系统添加专业级OSD功能，涵盖硬件设计、字符库编程和系统集成等关键步骤。通过5步操作实现时间水印和Logo叠加，提升监控系统的可用性和专业性，特别适合安防和工业视觉应用。

sea99的博客 1013

组合博弈算法笔记

简短地记录了一下自己对SG函数的理解，省略了一些组合博弈的内容

Shanhj的博客 378

CloudCompare 二次开发(9)——半径滤波

基于PCL对CloudCompare软件进行二次开发，实现的算法功能是半径滤波

点云侠的博客 1401

Android AVB 分析（十三）dm-verity 设备是如何映射的？

在上一篇《Android AVB 分析（十二）嵌入式设备安全中的 dm-verity 简介》介绍 dm-verity 原理的时候，作者提供了一个 dm-verity 演示的例子。本篇我们基于 AOSP 源码 `android-13.0.0_r41` 实际编译生成的 Google Pixel 7 (“panther”) 设备的 system 分区镜像进行 dm-verity 设备验证实战。

洛奇看世界 2438

算法笔记：博弈论之巴什博奕

巴什博奕: 巴什博奕： 两个顶尖聪明的人在玩游戏，有n个石子，每人可以随便拿1−m个石子，不能拿的人为败者，问谁会胜利 巴什博奕是博弈论问题中基础的问题 它是最简单的一种情形对应一种状态的博弈 博弈分析 我们从最简单的情景开始分析 当石子有1−m个时，毫无疑问，先手必胜 当石子有m+1个时，先手无论拿几个，后手都可以拿干净，先手必败 当石子有m+2−2m时，先手可以拿走几个，剩下m+1个，先...

kunyuwan的博客 1871

NSIS教程(2): 传统用户界面(Classic UI)

NSIS教程： 《NSIS用户手册 中文版》 《NSIS图文教程集锦 - 轻狂志》 本文以一个完整的、传统界面的网易云音乐安装包的脚本为示例，来介绍NSIS传统用户界面的开发流程。 NSIS脚本 # 单行注释用井号"#"或分号";"，跨行注释用可以用C/C++中注释语法。 # 使用!define定义一些常量（如安装包的版本号等） # 对常量或变量的引用可以使用如${PROD

while(1) { smile(); } 8万+

三个博弈-巴什博奕、威佐夫博弈、尼姆博弈。acm博弈算法笔记HDU 2149,1850,1527

博弈论 （一）、acm博弈基础算法 Bash Game,Nim Game和Wythoff Game（即 巴什博奕、尼姆博弈、威佐夫博弈） Bash    Game:   同余理论 Nim      Game:  异或理论 Wythoff Game:  黄金分割 （二）、三个博弈。 1、巴什博奕。 2、尼姆博弈 3、威佐夫博弈

雪的期许 1428

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

WINCC7.3破解文件

WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

算法笔记-博弈论

4.14 初稿。

2301_80105412的博客 431

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

【算法竞赛学习笔记】基础博弈-数学提升计划

title : 基础博弈 date : 2021-8-4 tags : ACM,博弈论 author : Linno 基本概念 ICG游戏：两个人参与的游戏，轮流做出对中间最有利的决策。 必败态：P-position（无法转移的状态），处于这种状态的人必输。 必胜态：N-position（可以转移到P的局面），处于这种状态的人必胜。 巴什博弈 一堆n个物品，两个人从中轮流取1~m个，最后不能继续取的人输。 同余定理：n=k*(m+1)+r；先取者拿走r个，那么后者无论拿走1~m个先者只要拿的数目之和为m.

SC_Linno的博客 2370

OV9734 DATASHEET，完整规格书

OV9734完整规格书，包括电气参数，尺寸规格，寄存器配置表等

【算法笔记】bash博弈（巴什博奕）

抛一道题解释： 虽然不想，但是现实总归是现实，Lele始终没有逃过退学的命运，因为他没有拿到奖学金。现在等待他的，就是像FarmJohn一样的农田生涯。 要种田得有田才行，Lele听说街上正在举行一场别开生面的拍卖会，拍卖的物品正好就是一块20亩的田地。于是，Lele带上他的全部积蓄，冲往拍卖会。 后来发现，整个拍卖会只有Lele和他的死对头Yueyue。 通过打听，Lele知道这场拍卖的规则是这样的：刚开始底价为0，两个人轮流开始加价，不过每次加价的幅度要在1～N之间，当价格大于或等于田地的成本价 M 时

Elly_Sware的博客 549

5.8学习笔记（博弈算法）

博弈策略 在环境中有一个反对者，博弈和搜索问题，（例如夏其中） 例如：对手做了A我们做B，等等。（确定）在基于加入对方走了啥，的搜索问题。 博弈是人工智能一个大的对象，例如国际象棋（35步，每个棋手100个位置）35的100此方=10的154此房的节点。实际中考虑后续三步 实例：1.西洋跳棋（1994），建立大的数据库（定义了所有的完美的走法。） 2.1949（香农）编写一个下国际象棋的程序，设想...

仓小小鼠 428

波恩大学算法博弈论笔记（一）

上一节我们通过具体例子看到了策略性行为的影响。现在，我们将其抽象化，给出拥堵博弈的一般形式化定义。一个拥堵博弈玩家集合 (N)这是所有参与博弈的玩家的集合。通常用表示，玩家数量为n。资源集合 ®这是博弈中所有可用资源的集合。例如，交通网络中的每条道路、通信网络中的每条链路。资源数量通常记为m。策略空间 (Σ_i)对于每个玩家i，其策略空间Σ_i是资源集合R的幂集的一个子集。简单来说，玩家的一个策略就是其可以选择使用的一组资源的组合。

龙哥盟 126

九章算法笔记D4-博弈型动态规划

tags: 算法 DP 动态规划 大家觉得还可以可以点赞、收藏、关注一下吧！ 也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn D4 博弈型动态规划 Coins in a Line Problems： 有 n 个硬币排成一条线。两个参赛者轮流从右边依次拿走 1 或 2 个硬币，直到没有硬币为止。拿到最后一枚硬币的人获胜。 请判定 先手玩家 必胜还是必败? 若必胜, 返回 true, 否则返回 false. 样例 : 输入: 4 输出: .

motongxue的博客 371

算法学习16：数学知识03（容斥原理、博弈论）

💕💕💕。

lenard-lhz的博客 842
上一篇： 算法笔记--逆元
下一篇： Java文件读写操作（FileInputStream、FileReader、BufferedReader）
点赞 0
评论 0
书签 书签 0
runnerxin
runnerxin
博客等级 码龄10年 12粉丝 39原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值