sg函数例题

最新推荐文章于 2022-01-20 22:25:33 发布
最新推荐文章于 2022-01-20 22:25:33 发布
阅读量320 收藏
点赞数 1
分类专栏： 博弈 
转自http://blog.csdn.net/u014355480/article/details/47397913
ZOJ - 2083 - Win the Game

题目传送：Win the Game

最近正在慢慢体会博弈里面的SG函数的意义

此题是最简单的SG博弈问题，只需打个表就OK了

AC代码：

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>
#define LL long long
#define INF 0x7fffffff
using namespace std;

int sg[55];
int vis[55];

void get_sg() {
    sg[0] = 0;
    sg[1] = 0;
    for(int i = 2; i < 55; i ++) {
        memset(vis, 0, sizeof(vis));
        vis[sg[i - 2]] = 1;
        for(int j = 1; j + 2 <= i; j ++) {
            vis[sg[j] ^ sg[i - j - 2]] = 1;
        }
        for(int j = 0;; j ++) {
            if(!vis[j]) {
                sg[i] = j;
                break;
            }
        }
    }
}

int n;

int main() {
    get_sg();
    //for(int i = 0; i < 55; i ++) cout << sg[i] << " ";
    while(scanf("%d", &n) != EOF) {
        int SG = 0, t;
        for(int i = 0; i < n; i ++) {
            scanf("%d", &t);
            SG ^= sg[t];
        }
        if(SG == 0) {
            printf("No\n");
        }
        else printf("Yes\n");
    }
    return 0;
}





ZOJ - 2507 - Let’s play a game

题目传送：Let’s play a game

AC代码：

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>
#define LL long long
#define INF 0x7fffffff
using namespace std;

int T;

int main() {
    scanf("%d", &T);
    while(T --) {
        int n, t, cnt = 0;;
        int SG = 0;
        scanf("%d", &n);
        for(int i = 0; i < n; i ++) {
            scanf("%d", &t);
            SG ^= t;
            if(t > 1) cnt ++;
        }
        if(cnt == 0) {
            if(SG == 1) {
                printf("2\n");
            }
            else printf("1\n");
        }
        else {
            if(SG) {
                printf("1\n");
            }
            else printf("2\n");
        }
    }
    return 0;
}




ZOJ - 3529 - A Game Between Alice and Bob

题目传送：A Game Between Alice and Bob

和之前UVA那个题类似，也是打表筛出素因子个数，然后套SG即可

AC代码：

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 5000005;

int n;

int a[100005];

int chu[maxn];
int to[maxn];

void init() {
    to[1] = 0;
    for(int i = 2; i < maxn; i ++) chu[i] = i;

    for(int i = 2; i < maxn; i ++) {
        if(to[i]) continue;
        to[i] ++;
        for(int j = 2 * i; j < maxn; j += i) {
            while(chu[j] % i == 0) {
                to[j] ++;
                chu[j] /= i;
            }
        }
    }
}

int main() {
    init();
    //for(int i = 1; i < 10; i ++) cout << to[i] << " ";
    int cas = 1;
    while(scanf("%d", &n) != EOF) {
        int SG = 0, t;
        for(int i = 0; i < n; i ++) {
            scanf("%d", &t);
            a[i] = to[t];       
            SG ^= a[i];
        }
        if(SG == 0) {
            printf("Test #%d: Bob\n", cas);
        }
        else {
            printf("Test #%d: Alice", cas);
            for(int i = 0; i < n; i ++) {
                if(a[i] > (a[i] ^ SG)) {
                    printf(" %d\n", i + 1);
                    break;
                }
            }
        }

        cas ++;
    }
    return 0;
}




ZOJ - 3513 - Human or Pig

题目传送：Human or Pig

注意题目要输出的P点和H点的含义。

含义是：

    P点，此时的状态为猪，且随便怎么走都能够满足条件，即落入水中时的状态为猪，然后可以永远变为人类
    H点，此时的状态为人类，且只需要下一状态有一个为猪即可，因为状态为猪时随便走都可以满足条件

AC代码：

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include <utility>
#include <iostream>
#include <algorithm>
#include <functional>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 40005;
int mp[maxn];//由于X*Y<=40000，但是这里开40000*40000的数组又太大了，所以这里我们应该用一维数组来模拟二维数组

int X, Y;//行数以及列数

int& get_pos(int x, int y) {//获取一维数组上对应的二维数组上的那个值
    return mp[(x - 1) * Y + y];
}

//这里需要注意P点和H点的含义，即
//H点代表此时只能是人类，才能确保落入水中时的状态是猪
//P点代表此时是猪，也能确保落入水中时的状态是猪，这一步只需要保证他的后继状态都是H或者直接掉入水中即可
//
//通俗一点的来说就是随便乱走都可以满足条件的就是P点，然后可以根据后继状态有P来确保满足条件的就是H点

char get_char(int x, int y) {//获取一次的
    int &ret = get_pos(x, y);
    ret = 'P';//先初始化为P点，P点代表此时是猪，因为猪是没思想的，可以随便走，所以初始化为这个

    //只要当前状态的后继状态出现了P点就可以转化成H点，因为H点代表人类，人类是有思想的，可以指定选择走到P点，而走到P点后随意走都可以满足条件
    //如果当前状态的后继状态出现了P点，而又没有转化，则当前不能确保能满足条件
    for(int k = 1; y > k * x; k ++) {
        if(get_pos(x, y - k * x) == 'P') {
            ret = 'H';
            break;
        }
    }

    for(int k = 1; x > k * y; k ++) {
        if(get_pos(x - k * y, y) == 'P') {
            ret = 'H';
            break;
        }
    }

    return ret;
}

int main() {
    int cas = 1;
    while(scanf("%d %d", &X, &Y) != EOF) {
        printf("Case #%d:\n", cas ++);
        for(int i = 1; i <= X; i ++) {
            for(int j = 1; j <= Y; j ++) {
                putchar(get_char(i, j));
            }
            puts("");
        }
    }
    return 0;
}

转自http://blog.csdn.net/thearcticocean/article/details/51240388

hdu 3032 Nim or not Nim？

http://acm.hdu.edu.cn/showproblem.php?pid=3032
大意：和普通的nim游戏相比，这里新添加了一种操作，可以把数字分成更小的两份。
分析：
sg[0]=0
当i=1，取走1后剩下0，mex[1]=1. sg[1]=1
当i=2时，可以取1，2，剩下1，0，sg[1]=1，sg[0]=0，分解成1+1，sg[1]^sg[1]=0，即分解相同的两部分和取走全部的效果是一样的。mex(2)=2 sg[2]=2
当i=3时，可以取1，2，3，剩下2，1，0，sg[2]=2, sg[1]=1, sg[0]=0，分解: sg[1]^sg[2]=3，所以mex(3)=4. sg[3]=4
当i=4时，取：1，2，3，4，剩下：sg[3]=4, sg[2]=2, sg[1]=1, sg[0]=0, 分解: sg[1]^sg[3]=5 mex(5)=3. sg[4]=3.

打表：

int sg[N];
bool vis[N];
void init(int n){
    int i,j;
    for(i=2;i<n;i++){
        memset(vis,0,sizeof(vis));
        for(j=1;j<=n;j++) vis[sg[i-j]]=1; // 取
        for(j=1;j+j<=n;j++) vis[sg[j]^sg[i-j]]=1;  // 分解
        j=0;
        while(vis[j]) j++;
        sg[i]=j;
    }
}
/*
1: 1
2: 2
3: 4
4: 3
5: 5
6: 6
7: 8
8: 7
9: 9
10: 10
11: 12
12: 11
13: 13
14: 14
15: 16
16: 15
17: 17
18: 18
19: 20
20: 19
21: 21
22: 22
23: 24
24: 23
*/
1



得到规律：
sg[4n+3]=4n+4
sg[4n]=4n-1
sg[i]=i

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

int main()
{
    //freopen("cin.txt","r",stdin);
    int n,t;
    cin>>t;
    while(t--){
        scanf("%d",&n);
        int a,ans=0;
        for(int i=0;i<n;i++){
            scanf("%d",&a);
            if((a&3)==3) {  // a%4==3
                ans=ans^(a+1);
            }
            else if((a&3)==0){  // a%4==0
                ans=ans^(a-1);
            }
            else ans=ans^a;
        }
        if(ans) puts("Alice");
        else puts("Bob");
    }
    return 0;
}



acdream 1112 Alice and Bob

http://acdream.info/problem?pid=1112
大意：给出一堆数字，每一个数字可以被不是它本身的约数（包括1）替代，或者分解成两个约数。比如6可以变成：2, 3, (2,3)
分析：一开始使用直接分解计算的方法果断超时。事实上这个问题完全可以从另一个角度看，由算术基本定理可知， n=ap11ap22⋯apkk

那么n变小的过程就是素因子减少的过程。由此问题变成n的素因子个数变少的sg问题。
对于范围是5e6的未知数，可以猜想他的素因子的个数一定小于30（1<<30一定大于它）
由此我们可以算出每一个数字的素因子的个数，然后计算出这30个数字的sg函数值（预处理）。
至于如何计算出每一个数字的素因子的个数，可以使用前缀和的思想，sum[n]=sum[n/p]+1 （假设p是n的最小素因子）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
const int N=5e6+10;
int sg[N],minp[N],sum[N];
int maxs,cnt;
vector<int> prim;
bool vis[N];
void get_minp(){
    minp[0]=minp[1]=0;
    for(int i=2;i<N;i++) minp[i]=i;
    for(int i=2;i<N;i++){
        if(!vis[i]){ prim.push_back(i); cnt++; }
        for(int j=0;j<cnt && prim[j]*i<N;j++){
            int t=i*prim[j];
            vis[t]=1;
            minp[t]=min(minp[t],prim[j]);
            if(i%prim[j]==0) break;
        }
    }
}
void get_sg(){
    sg[0]=0;
    sum[0]=sum[1]=0;
    maxs=0;
    int i,j;
    for(i=2;i<N;i++){
        sum[i]=sum[i/minp[i]]+1;
        maxs=max(maxs,sum[i]);
    }
    for(i=1;i<=maxs;i++){
        for(j=0;j<=i+1;j++) vis[j]=0;  // important!!!
        for(j=1;j+j<=i;j++){
            int t1=sg[j], t2=sg[i-j];
            vis[t1]=vis[t2]=vis[t1^t2]=1;
        }
        vis[0]=1;  // 用1代替原数字  
        j=0;
        while(vis[j]) j++;
        sg[i]=j;
    }
}
int main()
{
    //freopen("cin.txt","r",stdin);
    get_minp();
    get_sg();
    int n,a;
    while(~scanf("%d",&n)){
        int ans=0;
        for(int i=0;i<n;i++){
            scanf("%d",&a);
            ans=ans^sg[sum[a]];
        }
        if(ans) puts("Alice");
        else puts("Bob");
    }
    return 0;
}



Treblecross

此题类似于： uva 10561
https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1502
大意：对一个一维的棋带，两人玩游戏，每一个人将其中的 ‘.’ 变成 ‘x’ ,谁最先满足走一步棋后又3个连续的x排列在一起谁就胜利。
分析：《算法竞赛 训练指南》 p139
对于：_ _ x的情况再走一步棋必败，所以得到 _ _ x _ _ 的影响领域，
进一步分析：
这里写图片描述
一个x的影响：sg(x)=mex(sg(x-3), sg(x-4), sg(x-5), sg(1)^sg(x-6), sg(2)^(sg(x-7)……)
所以枚举每一个点，然后计算sg异或结果，得到能够放棋子的位置
初始值：
sg(0)=0
sg(1)=sg(2)=sg(3)=1

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=210,inf=0x3f3f3f3f;
char str[N];
int sg[N];
int mex(int n){  // 递归求解sg[n]
    if(sg[n]!=-1) return sg[n];
    if(n==0) return sg[0]=0;
    bool tag[N];
    memset(tag,0,sizeof(tag));
    /*for(int i=3;i<6&&i<=n;i++) tag[mex(n-i)]=1;
    for(int i=6;i<=n;i++){
        int g=mex(n-i)^mex(i-5);
        tag[g]=1;
    }*/
    for(int i=1;i<=n;i++){
        int g=mex(max(0,i-3))^mex(max(0,n-i-2));
        tag[g]=1;
    }
    for(int i=0;i<N;i++)
        if(tag[i]==0) return sg[n]=i;
}
bool win(int n,int dex){ // 检测 XXX 区域
    char ch=str[dex];
    str[dex]='X';
    for(int i=0;i+2<n;i++){
        if(str[i]=='X' && str[i+1]=='X' && str[i+2]=='X') {
            str[dex]=ch;
            return true;
        }
    }
    str[dex]=ch;
    return false;
}
bool will_win(int n,int dex){  // 检测 . 区域
    char ch=str[dex];
    str[dex]='X';
    for(int i=0;i<N;i++){  // 第二种情况里的假设可能造成第一种情况成立，
        if(str[i]=='.'){   //但它不属于第二种情况
            if(win(n,i)) {
                str[dex]=ch;
                return false;
            }
        }
    }

    int ans=0,temp=0;
    for(int i=0;i<n;i++){
        if(str[i]=='X' || (i-1>=0&&str[i-1]=='X') || (i-2>=0&&str[i-2]=='X')
           || (i+1<n&&str[i+1]=='X') || (i+2<n&&str[i+2]=='X')){
            ans=ans^mex(temp);
            temp=0;
        }
        else temp++;
    }
    ans=ans^mex(temp);
    str[dex]=ch;
    return ans==0;
}
int main()
{
    //freopen("cin.txt","r",stdin);
    memset(sg,-1,sizeof(sg));
    //sg[0]=0;
    //sg[1]=sg[2]=sg[3]=1;
    int t,ca=1;
    cin>>t;
    while(t--){
        scanf("%s",str);
        int n=strlen(str);
        int ans[N],top=0;
        for(int i=0;i<n;i++){
            if(str[i]=='X') continue;
            if(win(n,i) || will_win(n,i)) ans[top++]=i+1;
        }
        if(top) {
            printf("Case %d: ",ca++);
            for(int i=0;i<top-1;i++) printf("%d ",ans[i]);
            printf("%d\n",ans[top-1]);
        }
        else printf("Case %d: 0\n",ca++);
    }
    return 0;
}
wspl654321
关注
专栏目录
【博弈 —— SG函数详解+例题解析】
Gene_I must wait for the sunrise
04-09 2560
SG函数解析： 博弈游戏的本质是一个有向图游戏，每个状态(局面)是一个图中一个节点，每个节点可以通向其他多个状态，而每个节点又由nnn个子游戏组成。 如下图所示，y1y_1y1​、y2y_2y2​、y3y_3y3​…都是一个状态，这些状态是不能同时到达的。而G1G_1G1​、G2G_2G2​、G3G_3G3​…属于y4y_4y4​状态(局面)中的mmm个子游戏，这mmm个子游戏是同时存在的，但是这...
非常简单的理解-关于sg函数的理解+例题HDU - 1848
Starry_Sky_Dream的博客
05-03 385
百度百科上对sg函数有如下介绍 定义 任何一个公平组合游戏都可以通过把每个局面看成一个顶点，对每个局面和它的子局面连一条有向边来抽象成这个“有向图游戏”。下 面我们就在有向无环图的顶点上定义Sprague-Grundy函数。首先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{1,3,5}=...
SG函数总结+例题
weixin_43819578的博客
09-12 1812
SG函数 先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。 对于任意状态 x ，SG函数的终态为 SG(x)=0,当且仅当 x 为必败点P时。 有1堆n个的石子，每次只能取{ 1, 3, 4 }个石子，先取完石子者胜利，那么各个数的SG值为多少？ SG[0...
SG函数应用加简单题目
DS00HY的小博客
04-26 312
首先推荐几个不错的博客，1点击打开链接这个博客讲的很全，但是后面有点抽象，2点击打开链接这个博客在看懂前一个博客基础上来看很舒服，语言很通俗；在搞懂了NP状态下，一切就可以好好解释了。N状态是当前必胜态，P是当前必输态，当我们判断当前状态是N还是P的时候我们可以这样判断。通过题目给你的要求我们可以将当前未知情况转移的已知问题结果上面：1.如果可以转移的所有子问题状态都是N 那我们可以得出结论，当前...
sg函数入门题
渐近自由
07-24 789
poj 2311： 题意： 给一个 w * h 的矩形纸片，每次可以剪一刀，谁先剪到1 * 1谁就赢。 解析： 用sg函数来找必胜态和必败态，然后类似记忆化搜索，不断往下找。 代码： #include #include #include #include #include #include #include #include #include #inc
博弈论SG函数-算法介绍及例题
Gaoithe的博客
08-24 1985
一、 基本概念： 1. Impartial Combinatorial Games(ICG) 公平组合游戏： 1. 两名选手 2. 交替进行某种游戏规定的操作，每操作一次，选手可以在有限的操作（操作必须合法）集合中任选一种。 3. 对于游戏的任何一种可能的局面，合法操作集合只取决于这个局面本身，不取决于其它因素（跟选手，以前的所有操作无关） 4. 如果...
【acm 博弈论 】 之 Nim游戏与sg函数
weixin_45924828的博客
11-30 506
文章目录前言巴什博弈威佐夫博弈Nim游戏Nim游戏与sg函数题目题意样例思路代码 前言 从今天开始复习和整理下acm的部分模块，从博弈论开始。 著名的“取石子”游戏通常有3种类型，从简单到复杂依次是： 1.巴什博弈 2.威佐夫博弈 3.Nim游戏 4.Nim游戏与sg函数 复习Nim博弈之前，先复习下前两者。 巴什博弈 大意： 一堆物品有n个，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。最后取光者得胜，问最优策略下谁赢。 思路： 不难发现，当剩下m+1个物品时，先手必败。 所以，如果当前的
博弈例题、SG函数应用
_Griefs
08-24 330
一、取石子： 有1堆n个的石子，每次只能取{ 1, 3, 4 }个石子，先取完石子者胜利，那么各个数的SG值为多少？ SG[0]=0，f[]={1,3,4}, x=1 时，可以取走1 - f{1}个石子，剩余{0}个，所以 SG[1] = mex{ SG[0] }= mex{0} = 1; x=2 时，可以取走2 - f{1}个石子，剩余{1}个，所以 SG[2] = mex{ SG[1] }= ...
博弈论之SG函数
Recalling_Clouds的博客
01-20 1063
下面的所有知识均属博弈论范畴。 SG⁡\operatorname{SG}SG 函数 Nim⁡\operatorname{Nim}Nim 博弈 在介绍 SG⁡\operatorname{SG}SG 函数前，我们先介绍一种经典的博弈——Nim⁡\operatorname{Nim}Nim 博弈，并从中获得一定的启发。 问题：有 nnn 堆石子，第 iii 堆石子里面有 AiA_iAi​ 枚石子，每人每次可从任意且至多一堆石子里取出任意多枚石子扔掉，可以取完，不能不取，最后无石子可取的人判负。假如甲是先手，且
sg函数的一些题
小囧子的博客
06-04 571
模板1如下（SG打表）： //f[]：可以取走的石子个数   //sg[]:0~n的SG函数值   //hash[]:mex{}   int f[K],sg[N],hash[N];   void getSG(int n)   {           memset(sg,0,sizeof(sg));           for(int i=1; i<=n; i++) {
UVALive/LA 5059 Play with Stones 组合游戏/SG定理
冷月之殇
08-04 1230
#include using namespace std; #define LL long long LL SG(LL x) { return x%2==0?x/2:SG(x/2); } int main() { LL T; cin>>T; while(T--) { LL i,n,a,v=0; cin>>n;
SG博弈简单题
Never say never
08-12 1745
ZOJ - 2083 - Win the Game题目传送：Win the Game最近正在慢慢体会博弈里面的SG函数的意义此题是最简单的SG博弈问题，只需打个表就OK了AC代码：#include <map> #include <set> #include <list> #include <cmath> #include <deque> #include <queue> #include <stac
POJ2960(SG函数，模板题)
Cai_Haiq的博客
05-13 465
题目大意：已知一次可拿个数的种类；求出先手是否胜利，若胜利输出W否则输出L； SG函数模板：#include<string.h> const int N = 10008; int a[110],sg[N],f[N]; void sgt(int *a,int y,int z) { int i,j; memset(sg,0,sizeof(sg)); for(i=1;i<=z;i
SG函数模板题总结
C202044zxy的博客
02-13 591
S-Nim HDU 1536 应该是最板的一道题了qwqqwqqwq。 把kkk堆石子的博弈分解成kkk个子问题再把它们的 SG\text{SG}SG 函数值异或起来，sg[i]sg[i]sg[i]表示iii个石子的 SG\text{SG}SG 函数值，记忆化搜索即可，注意：搜索过程中算mexmexmex时visvisvis的大小就是操作集合的大小。 #include <cstdio>...
sg函数训练——开窍篇
theArcticOcean
04-25 825
个人觉得，能做一道经典的题并理解透彻，往往比做对难度系数很大的题目更有意义。最近又训练了博弈，记录一些题目，来个小总结。hdu 3032 Nim or not Nim？http://acm.hdu.edu.cn/showproblem.php?pid=3032 大意：和普通的nim游戏相比，这里新添加了一种操作，可以把数字分成更小的两份。 分析： sg[0]=0 当i=1，取走1后剩下0，m
博弈:关于SG函数的一些心得（知识总结+叙述证明+例题）
Code92007的博客
02-23 1953
思路来源 IOI2009集训队论文 贾志豪《组合游戏略述——浅谈SG游戏的若干拓展及变形》 翻硬币游戏部分： https://www.cnblogs.com/kuangbin/p/3218060.html 树的删边与图的删边部分： https://blog.csdn.net/wu_tongtong/article/details/79311284 http://blog.sina.co...
SG函数入门
Jiandong
10-11 868
参考博客：https://baike.baidu.com/item/SG%E5%87%BD%E6%95%B0/1004609 https://www.cnblogs.com/ECJTUACM-873284962/p/6921829.html 主要参考百度百科： 首先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表示最小的不属于这个集合的非负整数。例如mex{...
【POJ2425】A Chess Game 博弈，SG函数，裸题，模板题
辗转山河弋流歌
01-12 1305
转载请注明出处：http://blog.csdn.net/vmurder/article/details/42653921 其实我就是觉得原创的访问量比未授权盗版多有点不爽233。。。 题意：给一个有向无环图（拓扑图），有若干个棋子，两人轮流操作，每次可以把其中某棋子沿图走一步，无法操作者输。 题解：SG函数裸题，模板题 代码： #include #include #incl
组合游戏探秘：SG函数与NIM模型的应用
文章特别强调了SG函数和游戏图的概念，并鼓励读者通过学习SG函数的资料来加深理解。论文分为三个章节，第一章介绍SG函数、游戏图和NIM游戏，第二章探讨多种组合游戏的策略，第三章则关注竞赛中常见的组合模型并转化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值