博弈训练——sg函数
关于sg函数：
———————————————————————
转自：http://blog.csdn.net/luomingjun12315/article/details/45555495
Sprague-Grundy定理（SG定理）：
游戏和的SG函数等于各个游戏SG函数的Nim和。这样就可以将每一个子游戏分而治之，从而简化了问题。而Bouton定理就是Sprague-Grundy定理在Nim游戏中的直接应用，因为单堆的Nim游戏 SG函数满足 SG(x) = x。
SG函数：
首先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表示最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。
对于任意状态 x ， 定义 SG(x) = mex(S),其中 S 是 x 后继状态的SG函数值的集合。如 x 有三个后继状态分别为 SG(a),SG(b),SG(c)，那么SG(x) = mex{SG(a),SG(b),SG(c)}。 这样 集合S 的终态必然是空集，所以SG函数的终态为 SG(x) = 0,当且仅当 x 为必败点P时。
【实例】取石子问题
有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] }= mex{1} = 0;
x=3 时，可以取走3 - f{1,3}个石子，剩余{2,0}个，所以 SG[3] = mex{SG[2],SG[0]} = mex{0,0} =1;
x=4 时，可以取走4- f{1,3,4}个石子，剩余{3,1,0}个，所以 SG[4] = mex{SG[3],SG[1],SG[0]} = mex{1,1,0} = 2;
x=5 时，可以取走5 - f{1,3,4}个石子，剩余{4,2,1}个，所以SG[5] = mex{SG[4],SG[2],SG[1]} =mex{2,0,1} = 3;
以此类推…..
x 0 1 2 3 4 5 6 7 8….
SG[x] 0 1 0 1 2 3 2 0 1….
———————————————————————–
参考模板：http://blog.csdn.net/y990041769/article/details/21406335
int sg[N];
bool hash[N];
void sg_solve(int *s,int t,int N) //N求解范围 S[]数组是可以每次取的值，t是s的长度。
{
int i,j;
memset(sg,0,sizeof(sg));
for(i=1;i<=N;i++)
{
memset(hash,0,sizeof(hash));
for(j=0;j<t;j++)
if(i - s[j] >= 0)
hash[sg[i-s[j]]] = 1;
for(j=0;j<=N;j++)
if(!hash[j])
break;
sg[i] = j;
}
}————————————————————————–
其他：
ｓｇ函数的值，个人理解是ｉ结点对应的必败点（错误的理解）
经验证sg函数的最大值和set[]的元素个数密切相关，最大就是n
训练5题：
lightoj 1296 Again Stone Game
hdu 1848 Fibonacci again and again
hdu 1536 S-Nim
LightOJ 1315 Game of Hyper Knights
lightOJ 1199 Partitioning Game
lightoj 1296 Again Stone Game（sg博弈）
http://lightoj.com/login_main.php?url=volume_showproblem.php?problem=1296
大意：n堆石子，每次可以从其中一堆取出１－ｋ个，ｋ是不大于该堆石子个数一半的数字。不能取的人输。求解两人博弈结果。
分析：
每一堆石子的个数可达到1e9。计算每一个ｓｇ函数存储下来肯定不行，所有打表找找ｓｇ结果的规律。
打表sg[i]：
sg[0]=0; sg[1]=0;
for(int i=2;i<=15;i++){
int sta[20],top=0,L=i>>1;
for(int j=1;j<=L;j++){
sta[top++]=sg[i-j];
}
for(int j=0;j<=i;j++) {
bool tag=0;
for(int k=0;k<top;k++) if(j==sta[k]){ tag=1; break; }
if(tag==0) { sg[i]=j; break; }
}
}
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 2 | 1 | 3 | 0 | 4 | 2 | 5 | 1 | 6 | 3 | 7 | 0 |
可以发现当ｉ是偶数sg[i]=i/2, 当ｉ是奇数时，sg[i]=sg[i/2]
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1e3+10;
int calc(int n){
if((n&1)==0) return n/2;
return calc(n/2);
}
int main()
{
//freopen("cin.txt","r",stdin);
int t,n,a,ca=1;
cin>>t;
while(t--){
scanf("%d",&n);
int ans=0,a;
for(int i=0;i<n;i++){
scanf("%d",&a);
ans=ans^calc(a);
}
if(ans)printf("Case %d: Alice\n",ca++);
else printf("Case %d: Bob\n",ca++);
}
return 0;
}
hdu 1848 Fibonacci again and again（sg）
http://acm.hdu.edu.cn/showproblem.php?pid=1848
大意：3堆石子每次取石子的个数是菲波那切数列元素，最后取完所有石子的人为赢家。
分析：sg函数的简单应用
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int s[1005],len;
int sg[1005];
bool tag[1005];
void calc_sg(){
int i,j;
s[0]=1; s[1]=2;
for(i=2;i<1005;i++) {
s[i]=s[i-2]+s[i-1];
if(s[i]>1000) { len=i; break; }
}
for(i=1;i<=1000;i++){
memset(tag,0,sizeof(tag));
for(j=0;j<len;j++){
if(i<s[j]) break;
tag[sg[i-s[j]]]=1;
}
for(j=0;j<=1000;j++) if(tag[j]==0) break;
sg[i]=j;
}
}
int main()
{
calc_sg();
int m,n,p;
while(cin>>m>>n>>p){
if(m+n+p==0) break;
int ans=sg[m]^sg[n]^sg[p];
if(ans) puts("Fibo");
else puts("Nacci");
}
return 0;
}hdu 1536 S-Nim (sg)
http://acm.hdu.edu.cn/showproblem.php?pid=1536
背景故事——nim游戏：
Arthur and his sister Caroll have been playing a game called Nim for some time now. Nim is played as follows:
The starting position has a number of heaps, all containing some, not necessarily equal, number of beads.
The players take turns chosing a heap and removing a positive number of beads from it.
The first player not able to make a move, loses.
Arthur and Caroll really enjoyed playing this simple game until they recently learned an easy way to always be able to find the best move:
Xor the number of beads in the heaps in the current position (i.e. if we have 2, 4 and 7 the xor-sum will be 1 as 2 xor 4 xor 7 = 1).
If the xor-sum is 0, too bad, you will lose.
Otherwise, move such that the xor-sum becomes 0. This is always possible.
It is quite easy to convince oneself that this works. Consider these facts:
The player that takes the last bead wins.
After the winning player’s last move the xor-sum will be 0.
The xor-sum will change after every move.
现在每一次不能取非0任意数，求解胜利和失败的情况判别：
标准SG函数的应用。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1e4+10;
int s[105];
int sg[N];
bool tag[N];
void calc_sg(int n){
memset(sg,0,sizeof(sg));
int i,j;
for(i=1;i<N;i++){
memset(tag,0,sizeof(tag));
for(j=0;j<n;j++)
if(i-s[j]>=0) tag[sg[i-s[j]]]=1;
for(j=0;j<N;j++)
if(tag[j]==0) break;
sg[i]=j;
}
}
int main()
{
//freopen("cin.txt","r",stdin);
int n;
while(cin>>n&&n){
for(int i=0;i<n;i++){
scanf("%d",&s[i]);
}
calc_sg(n);
int t,m,num,ans;
scanf("%d",&t);
for(int i=0;i<t;i++){
scanf("%d",&m);
ans=0;
for(int j=0;j<m;j++){
scanf("%d",&num);
ans=ans^sg[num];
}
if(ans)printf("%c",'W');
else printf("%c",'L');
}
puts("");
}
return 0;
}LightOJ 1315 Game of Hyper Knights（sg博弈）
http://lightoj.com/login_main.php?url=volume_showproblem.php?problem=1315
大意：在如图的方格中进行两人博弈，棋子的走法有６种，不能走的人算输。
分析：递归类博弈。我只能说这题很神奇，我下面的tag数组设成全局的死活过不了，设成局部瞬间过了。因为棋子的走法只有６种，所以ｓｇ函数只有６种值0-5
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int N=1005,L=10;
int xx[6]={-2,-3,-2,-1,-1,1};
int yy[6]={1,-1,-1,-2,-3,-2};
int sg[N][N];
bool vis[N][N];
//int sta[L],top;
int calc_sg(int x,int y){
if(vis[x][y]) return sg[x][y];
bool tag[L];
memset(tag,0,sizeof(tag));
for(int i=0;i<L;i++) tag[i]=0;
for(int i=0;i<6;i++){
int tx=x+xx[i];
int ty=y+yy[i];
if(tx>=0 && ty>=0) tag[calc_sg(tx,ty)]=1; //sta[top++]=calc_sg(tx,ty);
}
vis[x][y]=1;
for(int i=0;i<L;i++){
if(tag[i]==0){ sg[x][y]=i; break; }
}
return sg[x][y];
}
int main(){
//freopen("cin.txt","r",stdin);
int t,ca=1;
int n;
cin>>t;
while(t--){
scanf("%d",&n);
int ans=0;
for(int i=0;i<n;i++){
int a,b;
scanf("%d%d",&a,&b);
ans=ans^calc_sg(a,b);
}
printf("Case %d: ",ca++);
if(ans) puts("Alice");
else puts("Bob");
}
return 0;
}lightOJ 1199 Partitioning Game（sg博弈）
http://lightoj.com/login_main.php?url=volume_showproblem.php?problem=1199
大意：给出Ｎ个堆，针对每个堆每一次取１－ｋ，ｋ小于Ｎ的一半，不能取的人失败。
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int N=1e4+10;
int sg[N];
bool vis[N];
void init(int n){
sg[1]=sg[2]=0;
sg[3]=1; sg[4]=0;
for(int i=5;i<n;i++){
memset(vis,0,sizeof(vis));
for(int j=1;2*j<i;j++) vis[sg[j]^sg[i-j]]=1;
int j=0;
while(vis[j]) j++; //能有效分割的次数
sg[i]=j;
}
}
int main()
{
//freopen("cin.txt","r",stdin);
init(N);
int t,n,ca=1;
cin>>t;
while(t--){
scanf("%d",&n);
int ans=0,a;
for(int i=0;i<n;i++){
scanf("%d",&a);
ans=ans^sg[a];
}
if(ans) printf("Case %d: Alice\n",ca++);
else printf("Case %d: Bob\n",ca++);
}
return 0;
}