ACM——博弈论 （以SG的求法为主）

最新推荐文章于 2022-10-14 21:39:27 发布
最新推荐文章于 2022-10-14 21:39:27 发布
阅读量873 收藏
点赞数
分类专栏： 博弈论

HDU 1847Good Luck in CET-4 Everybody! 转自：http://blog.csdn.net/jxy859/article/details/6722660

n个石子取2的次幂个，0为terminal position

P/N分析和求SG值方法都可以，找规律的话模3余0也能过

主要是为了练习SG的求法

[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3. //单纯博弈型 也可用P/N分析法  
  4. int x[12],SG[1050];  
  5. bool vis[1050];  
  6.   
  7. void init()  
  8. {  
  9.     for (int i=0 ; i<11 ; ++i)  
  10.         x[i]=1<<i;  
  11.     SG[0]=0;  
  12.     for (int i=1 ; i<1002 ; ++i)//get Sprague-Grundy value;  
  13.     {  
  14.         memset (vis , 0 , sizeof(vis));  
  15.         for (int j=0 ; x[j]<=i ; ++j)  
  16.         {  
  17.             vis[SG[i-x[j]]]=true;  
  18.         }  
  19.         for (int j=0 ; ; ++j)  
  20.         {  
  21.             if(!vis[j]){SG[i]=j;break;}  
  22.         }  
  23.     }  
  24.     for (int i=0 ; i<100 ; ++i)  
  25.     printf("num=%d sg=%d\n",i,SG[i]);  
  26. }  
  27.   
  28. int main ()  
  29. {  
  30.     int n;  
  31.     init();  
  32.     while (~scanf("%d",&n))  
  33.     {  
  34.         if(SG[n])puts("Kiki");  
  35.         else puts("Cici");  
  36.     }  
  37.     return 0;  
  38. }  


 

HDU 3980 Paint Chain

n元环，每次取连续的m个元素，最先不能取者败。

可以考虑n<m和n>=m两种情况，第一种情况结果显然，第二种将取过1次后剩下的n-m元链进行求SG值，前m-1个状态的SG值明显为0，m为1，之后的状态取走m元素之后，会将剩下的2段分成2份（考虑0的情况），分别求其SG值，从而得到当前的状态的一个后继SG值。

 

 

[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3.   
  4. const int maxn=1005;  
  5. int SG[maxn];  
  6. bool vis[maxn];  
  7.   
  8. bool sg(int n , int m)//get SG value  
  9. {  
  10.     memset(SG , 0 , sizeof(SG));  
  11.     SG[m]=1;  
  12.     for (int i=m+1 ; i<=n ; ++i)  
  13.     {  
  14.         memset (vis , 0 , sizeof(vis));  
  15.         for (int j=0 ; j<i-m ; ++j)  
  16.         {  
  17.             vis[SG[j]^SG[i-m-j]]=true;  
  18.         }  
  19.         for (int j=0 ; ; ++j)  
  20.         {  
  21.             if(!vis[j]){SG[i]=j;break;}  
  22.         }  
  23.     }  
  24.     //for (int i=0 ; i<=n ; ++i)  
  25.         //printf("%d %d \n",i,SG[i]);  
  26.     return SG[n];  
  27. }  
  28.   
  29. int main ()  
  30. {  
  31.     int cas;  
  32.     int n,m;  
  33.     scanf("%d",&cas);  
  34.     for (int I=1 ; I<=cas ; ++I)  
  35.     {  
  36.         scanf("%d%d",&n,&m);  
  37.         if(m>n)printf("Case #%d: abcdxyzk\n",I);  
  38.         else if(sg(n-m,m))printf("Case #%d: abcdxyzk\n",I);  
  39.         else printf("Case #%d: aekdycoin\n",I);  
  40.     }  
  41.     return 0;  
  42. }  


POJ 3537 Crosses and Crosses

 

 

给一个1*n的长方形格子，在格子里轮流画X，最先得到3个连续X的人即为winner

[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3. const int maxn=2005;  
  4. int SG[maxn];  
  5. bool vis[maxn];  
  6.   
  7. void sg()  
  8. {  
  9.     memset (SG , 0 , sizeof(SG));  
  10.     SG[1]=1;SG[2]=1;SG[3]=1;//SG[4]=1;  
  11.     for (int i=4; i<maxn ; ++i)  
  12.     {  
  13.         memset (vis , 0 , sizeof(vis));  
  14.         for (int j=2 ; j<i ; ++j)  
  15.         {  
  16.             if((i-j-1<2))vis[SG[j-2]^0]=true;  
  17.             else vis[SG[j-2]^SG[i-j-1-2]]=true;  
  18.         }  
  19.         for (int j=0 ;  ; ++j)  
  20.             if(!vis[j]){SG[i]=j ; break;}  
  21.     }  
  22.     //for (int i=0; i<50 ; ++i)  
  23.     //printf("SG%d=%d\n",i,SG[i]);  
  24. }  
  25.   
  26. int main ()  
  27. {  
  28.     sg();  
  29.     int n;  
  30.     while (~scanf("%d",&n))  
  31.     {  
  32.         if(SG[n])puts("1");  
  33.         else puts("2");  
  34.     }  
  35.     return 0;  
  36. }  


 

 

POJ 2425 A Chess Game
在DAG上搜索的NIM游戏，其实和在多堆石子里拿东西是一样的，要熟练各种游戏模型之间的转化，找出更新SG的方法就可以了
一开始清空vis和visit的时候 把visit的大小写成了sizeof(vis) DT了一天才发现Bug >< 
[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3.   
  4. const int maxm=2005000;  
  5. const int maxn=1005;  
  6. struct Edge {  
  7.     int v,next;  
  8. }edge[maxm];  
  9. int head[maxn],cnt;  
  10.   
  11. void addedge(int u,int v)  
  12. {  
  13.     edge[cnt].v=v;  
  14.     edge[cnt].next=head[u];  
  15.     head[u]=cnt++;  
  16. }  
  17.   
  18. bool vis[maxn],visit[maxn][maxn];//for dfs   for sg;  
  19. int SG[maxn];  
  20.   
  21. void dfs (int u)  
  22. {  
  23.     if(~SG[u]) return ;  
  24.     //vis[u]=true;  
  25.     int p=head[u];  
  26.   
  27.     for ( ; ~p ; p=edge[p].next)  
  28.     {  
  29.         int v=edge[p].v;  
  30.         //printf("%d ",u);  
  31.         //if(vis[v])continue;  
  32.         dfs(v);  
  33.         visit[u][SG[v]]=true;  
  34.     }  
  35.   
  36.     for (int i=0 ; true ; ++i)  
  37.     {  
  38.         if(!visit[u][i]){SG[u]=i;break;}  
  39.     }  
  40. }  
  41.   
  42. int main ()  
  43. {  
  44.     int n,node,v,m,t;  
  45.     while (~scanf("%d",&n))  
  46.     {  
  47.         memset (head , -1 , sizeof(head));  
  48.         memset (SG , -1 , sizeof(SG));  
  49.         cnt=0;  
  50.         for (int u=0 ; u<n ; ++u)  
  51.         {  
  52.             scanf("%d",&node);  
  53.             if(!node)SG[u]=0;  
  54.             for (int i=0 ; i<node ; ++i)  
  55.             {  
  56.                 scanf("%d",&v);  
  57.                 addedge(u , v);  
  58.             }  
  59.         }  
  60.         memset (vis , false , sizeof(vis));  
  61.         memset (visit , false , sizeof(visit));  
  62.         for(int i=0 ; i<n ; ++i)  
  63.         {  
  64.             if(vis[i])continue;  
  65.             dfs(i);  
  66.         }  
  67.         /*for (int i=0 ; i<n ; ++i) 
  68.         { 
  69.             printf("%d\t",SG[i]); 
  70.         }*/  
  71.         while (scanf("%d",&m),m)  
  72.         {  
  73.             int nim=0;  
  74.             for(int i=0 ; i<m ; ++i)  
  75.             {  
  76.                 scanf("%d",&t);  
  77.                 nim^=SG[t];  
  78.             }  
  79.             puts(nim?"WIN":"LOSE");  
  80.         }  
  81.     }  
  82.     return 0;  
  83. }  
POJ 1704 Georgia and Bob（ 阶梯博弈（目标的NP态只和奇数阶的NP态有关） ）
 
知道如何转换的话就很简单，关键是我不知道，推了半天，蒙了各种感觉有道理的转化方法都WA了，最后还是看了题解，还是很好理解的。
我的理解：对于棋盘上棋子，我们两两对其绑定，如果是奇数个，我们可以看做是和0处的一个棋子绑定，通过找规律我们可以发现，每对棋子的前一个棋子移动之后，后一个棋子可以移动和前一个棋子相同的步数是不影响结果的，即这是一个相对于比赛结果的平衡态，所以我们可以把所有的棋子对都平移到左边并保持棋子对之间的距离不变，这时我们发现我们要做得只是让每对棋子的后者和前者距离变为1，以及向前平移每对棋子，这两种操作后者是不影响结果的，于是我们将前者的操作转化成相应数值的NIM型博弈，剩下的大家就都能知道了
[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <algorithm>  
  3.   
  4. using namespace std;  
  5.   
  6. const int maxn=1005;  
  7.   
  8. int nim[maxn];  
  9. int n;  
  10. int main ()  
  11. {  
  12.     int cas;  
  13.     scanf("%d",&cas);  
  14.     while (cas--)  
  15.     {  
  16.         scanf("%d",&n);  
  17.         int ans=0;  
  18.         nim[0]=0;  
  19.         for (int i=1 ; i<=n ; ++i)  
  20.         {  
  21.             scanf("%d",nim+i);  
  22.         }  
  23.   
  24.         sort(nim,nim+n+1);  
  25.   
  26.         for (int i=0 ; i<(n+1)/2 ; ++i)  
  27.         {  
  28.             ans^=(nim[n-2*i]-nim[n-2*i-1]-1);  
  29.             //printf("%d  %d  %d\n",nim[n-2*i],nim[n-2*i-1],ans);  
  30.         }  
  31.         puts(ans?"Georgia will win":"Bob will win");  
  32.     }  
  33.     return 0;  
  34. }  

 JOJ 2520  A special queen
 
[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3. int SG[105][105];  
  4. bool vis[5000];  
  5. /*棋盘上的2维SG递推，非组合游戏可以不用SG*/  
  6. /*输出格式很恶心*/  
  7. int main ()  
  8. {  
  9.     int l,w;  
  10.     SG[0][0]=0;  
  11.     for (int i=1 ; i<105 ; ++i)  
  12.     {  
  13.         SG[i][0]=i;  
  14.         for (int j=1 ; j<105 ; ++j)  
  15.         {  
  16.             SG[0][j]=j;  
  17.             if(i==j){SG[i][i]=i+1;continue;}  
  18.             memset (vis , 0 , sizeof(vis));  
  19.             for (int k=0 ; k<j ; ++k)  
  20.                 vis[SG[i][k]]=true;  
  21.             for (int k=0 ; k<i ; ++k)  
  22.                 vis[SG[k][j]]=true;  
  23.             for (int k=1 ; k<=i&&k<=j ; ++k)  
  24.                 vis[SG[i-k][j-k]]=true;  
  25.             for (int k=0 ;  ; ++k)  
  26.             if(!vis[k]){SG[i][j]=k ; break;}  
  27.         }  
  28.     }  
  29. /* 
  30.     for (int i=0 ; i<25 ; ++i) 
  31.     { 
  32.         for (int j=0 ; j<25 ; ++j) 
  33.             printf("%d ",SG[i][j]); 
  34.         puts(""); 
  35.     } 
  36. */  
  37.     while (~scanf("%d*%d",&l,&w))  
  38.     {  
  39.         if(l==1 || w==1){printf("G will win\n");continue;}  
  40.         bool flag=false;  
  41.         bool first=false;  
  42.         for (int i=0 ; i<l ; ++i)  
  43.         {  
  44.             if(!SG[i][w-1])  
  45.             {  
  46.                 flag=true;  
  47.                 if(first)printf(" ");  
  48.                 printf("(%d,%d)",i,w-1);  
  49.                 first=true;  
  50.             }  
  51.         }  
  52.         for (int i=0 ; i<w-1 ; ++i)  
  53.         {  
  54.             if(!SG[l-1][i])  
  55.             {  
  56.                 flag=true;  
  57.                 if(first)printf(" ");  
  58.                 printf("(%d,%d)",l-1,i);  
  59.                 first=true;  
  60.             }  
  61.         }  
  62.         if(!flag)printf("G will win");  
  63.         printf("\n");  
  64.     }  
  65.     return 0;  
  66. }  

 
 
ZOJ Monthly, September 2011  A Game Between Alice and Bob 博弈论
nim的变形，合数分解，被常数给坑了
[cpp]  view plain copy print ?
  1. #include <cstdio>  
  2. #include <cstring>  
  3. #include <cmath>  
  4. #define abs(a) (a)>(0)?(a):(-(a))  
  5. #define  min(a,b) (a>b?b:a)  
  6.   
  7. const int maxn=100000+123;  
  8. typedef int  typen;  
  9. typen a[maxn];  
  10. typen count[maxn];  
  11.   
  12. const int maxp = 5000;  
  13. int prime[maxp + 1];//prime[0] is the counter  
  14. int getPrime()  
  15. {  
  16.     memset (prime, 0, sizeof (prime));  
  17.     for (int i = 2 ; i <= maxp ; i++)  
  18.     {  
  19.         if (!prime[i]) prime[++prime[0]] = i;  
  20.         for (int j = 1; j <= prime[0] && prime[j] * i <= maxp ; j++)  
  21.         {  
  22.             prime[prime[j]*i] = 1;  
  23.             if (i % prime[j] == 0) break;  
  24.         }  
  25.     }  
  26.     return prime[0];  
  27. }  
  28.   
  29. int getFactors(typen x)  
  30. {  
  31.     int facCnt = 0;  
  32.     typen tmp = x;  
  33.     for(int i = 1; prime[i]*prime[i] <= tmp ; ++i)  
  34.     {  
  35.         if(tmp % prime[i] == 0)  
  36.         {  
  37.             while(tmp % prime[i] == 0)  
  38.             tmp /= prime[i],++facCnt;  
  39.         }  
  40.     }  
  41.     if(tmp != 1)  
  42.         ++facCnt;  
  43.     return facCnt;  
  44. }  
  45.   
  46. int cas=0;  
  47. int main ()  
  48. {  
  49.     int n;  
  50.     getPrime();  
  51.     while ( ~scanf("%d",&n) )  
  52.     {  
  53.         memset (count , 0 , sizeof(count));  
  54.         int sum=0;  
  55.         for (int i=0 ; i<n ; ++i)  
  56.         {  
  57.             scanf("%d",a+i);  
  58.             count[i]=getFactors(a[i]);  
  59.         }  
  60.         for (int i=0 ; i<n ; ++i)  
  61.         {  
  62.             sum^=count[i];  
  63.         }  
  64.         if(sum)  
  65.         {  
  66.             int i;  
  67.             for (i=0 ; i<n ; ++i)//从  
  68.             {  
  69.                 if((sum^count[i])<count[i])break;  
  70.             }  
  71.             printf("Test #%d: Alice %d\n",++cas,i+1);  
  72.         }  
  73.         else printf("Test #%d: Bob\n",++cas);  
  74.     }  
  75.     return 0;  
  76. }  
sxk_sxy
关注
专栏目录
博弈论——acm
Glder_sky
11-13 2万+
序：博弈是信息学和数学试题中常会出现的一种类型，算法灵活多变是其最大特点，而其中有一类试题更是完全无法用常见的博弈树来进行解答。 寻找必败态即为针对此类试题给出一种解题思路。 此类问题一般有如下特点： 1、博弈模型为两人轮流决策的非合作博弈。即两人轮流进行决策，并且两人都使用最优策略来获取胜利。 2、博弈是有限的。即无论两人怎样决策，都会在有限步后决出胜负。 3、公平博弈。即两人进行决
ACM之博弈论
lumingran的博客
10-03 1107
1.巴什博弈 所谓巴什博弈，是ACM题中最简单的组合游戏，大致上是这样的： 只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取1个，最多取m个，最后取光者得胜。 显然，如果n = m + 1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则： 如果 n = (m + 1) * r + s ，(r为任意自然数，s≤m)，即n%(m+1) != 0，则先手必胜。 巴什博弈还是很好理解的，以你是先手的角度考虑。你想把对手给弄垮
ACM之博弈论.pdf
07-25
想成为神牛，必须得学好博弈论啊。加油看啊
ACM 数论-博弈 （比赛用）
Romantic Chopin in C Sharp Minor
08-09 848
1.    Bash博弈（巴什博弈）       只有一堆n个物品，两个人轮流从中取物，规定每次最少取一个，最多取m个，最后取光者为胜。       /*       if(n%(m+1)==0)         cout&lt;&lt;"后手必胜"&lt;&lt;endl;       else        cout&lt;&lt;"先手必胜"&lt;&lt;endl;       */ 2...
ACM 数论篇——博弈论
TinyDolphin的博客
07-20 1608
此类问题一般有如下特点：1、博弈模型为两人轮流决策的非合作博弈。即两人轮流进行决策，并且两人都使用最优策略来获取胜利。2、博弈是有限的。即无论两人怎样决策，都会在有限步后决出胜负。3、公平博弈。即两人进行决策所遵循的规则相同。NO.1 巴什博弈问题模型：只有一堆 n 个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取 m 个，最后取光者得胜。解决思路： 必胜攻略——只要保证能够给对手留
【算法竞赛学习笔记】博弈论（二）——SG函数及经典问题
SC_Linno的博客
11-17 3180
title : 博弈论（二） date : 2021-11-6 tags : ACM,数学,博弈论 author : Linno 前置芝士——SG函数 可以看我上一篇博客：https://blog.csdn.net/SC_Linno/article/details/121181361 首先给出一种ICG博弈游戏模型，给定一个有向无环图和一个起始顶点上的一枚棋子，两名选手交替的将这枚棋子沿有向边进行移动，无法移动者判负。 将ICG问题进行转换：任何一个ICG都可以通过把每个局面看成一个顶点，对每个局面和.
ACM-博弈论
zeng_wei_jie的博客
09-18 246
首先要明确明白博弈的基本思路是要寻找必败点与必胜点 必胜点：在这一点轮到我那我赢定了。性质：从必胜点出发一定会走到至少一个必败点（我在这里必胜是因为我走一步一定能让我的对手必败）。 必败点：我走到这一点我输定了。性质：从必败点出发前方全是必胜点（即我在必败点无论怎么走都是对面的必胜点）。 例1：15张牌，每次只能取1、3、4张牌，谁赢？ 画表：0 1 2 3 4 5 6 7 8 9...
巴什博奕，威佐夫博奕，尼姆博奕，斐波那契博弈模板
别止的博客
08-21 397
1.巴什博奕 只有一堆n个物品，两个人轮流从这堆物品中取物，规定每次至少取一个，最多取m个。最后取光者得胜。  显然，如果n=m+1，那么由于一次最多只能取m个，所以，无论先取者拿走多少个，后取者都能够一次拿走剩余的物品，后者取胜。因此我们发现了如何取胜的法则：如果n=（m+1）r+s，（r为任意自然数，s≤m),那么先取者要拿走s个物品，如果后取者拿走k（≤m)个，那么先取者再拿走m+1-k
ACM---博弈论
05-27
ACM－－－－博弈论
博弈_acm_Game_theory_入门
06-03
博弈论的经典入门书,适合于学习ACM的人或想学习写AI的人-Classic introductory book on game theory, ACM for learning to write the person or AI who want to learn 对于搞ACM/ICPC有很大帮助,里面涉及博弈论，图论，矩阵，计算几何，状态压缩等算法思想的描述
ACM算法之博弈论
cfn0324的博客
10-14 553
ACM算法之博弈论(笔记)
ACM博弈论中的SG定理
li_wei_quan的博客
02-06 968
Sprague-Grudy定理： 令N = {0, 1, 2, 3, ...} 为自然数的集合。Sprague-Grundy 函数给游戏中的每个状态分配了一个自然数。结点v的Grundy值等于没有在v的后继的Grundy值中出现的最小自然数. 形式上：给定一个有限子集 S ⊂ N,令mex S(最小排斥值)为没有出现在S中的最小自然数。定义mex(minimal excludant)运算，这是
博弈论基础-ACM
Kingfish404的博客
07-16 1244
博弈论基础 博弈论是ACM比赛中的一个很重要的理论，虽然很多情况可以套用公式 本文主要介绍博弈论的经典类型和公式
关于ACM博弈论的总结1
driver13的博客
09-10 1906
初学博弈论受益匪浅，将个人的博弈论解题总结一下。 １.威佐夫博弈论（证明真的没有的离散数学技巧是绝对这几个表情可以较好描述你的表情发展过程） １）问题：首先有两堆石子，博弈双方每次可以取一堆石子中的任意个，不能不取，或者取两堆石子中的相同个。先取完者赢。 解题思路：说实话对这种题唯一的方法是打表，当然比赛时候打表不好搞，尽量将新的状态转到老的已确定的状态，然后再找规律。 （０，０）（１
博弈，求SG值
幸福在路上
01-09 2945
#include using namespace std; #define MAX 1005 /* 计算从1-n范围内的SG值。 Array(存储可以走的步数，Array[0]表示可以有多少种走法) Array[]需要从小到大排序 /*HDU1847博弈SG函数 1.可选步数为1-m的连续整数，直接取模即可，SG(x) = x % (m+1); 2.可选步数为任意步，SG(x) = x; 3.可
ACM 博弈
chx
10-13 538
http://www.cnblogs.com/kuangbin/archive/2011/08/28/2156426.html http://blog.csdn.net/logic_nut/article/details/4711489 http://www.cppblog.com/sdfond/archive/2010/02/06/107364.aspx http://blog.s
ACM博弈论（入门）
qq_37618760的博客
04-05 888
传送门（参考博客）：https://www.cnblogs.com/ECJTUACM-873284962/p/6921829.html 一、必胜点和必败点 必胜点（N）、必败点（P）这里我也非常不理解为什么和英文反着。 然后我觉得如果单纯解释必胜点和必败点是没有什么意思的，所以我们通过具体的题目看一下： hdu 1847 Good Luck in CET-4...
ACM基础博弈论知识总结（一）
mumei的博客
08-21 2794
前两天做了学长拉的博弈论的专题。今天终于把基本的简单的知识给搞定的，便来做个博弈论知识点的总结。 在比赛中用到博弈大多是 ，巴什博弈，斐波那契博弈，威佐夫博弈以及尼姆博弈，这是最常见的，也是用的比较多的，特别是最后一个博弈，可以延伸出很多知识，sg函数（sg定理），组合博弈等等。除此之外还有：取火柴游戏，阶梯博弈，反尼姆博弈，以及树上green博弈，基本上都算是尼姆博弈的变形，所以说尼姆博弈真的...
博弈论与ACM中的SG函数解析
"SG函数-ACM之博弈论.pdf" SG函数是博弈论中的一个重要概念，特别是在解决有向无环图(DAG)上的博弈问题时。SG函数全称为Shapley值函数，它用于计算博弈中各个参与者对于整体收益的贡献。在给定的有向无环图中，g(x)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值