求解Grundy算法(在线等待)

[hxzb7215191]

例1：如果桌上有10个数，规定甲乙两人轮流取子。每次只准取1、2或5个子。
首先令g（0）=0，那么
１．如果还剩下１颗子，可以取１个，则变为只有０个子，而g（０）＝０，
　　所以g（1）＝１；
２．如果还剩下２颗子，ａ．可以取１个，则变为只有１个子，而g（１）＝１，
　　　　　　　　　　　ｂ．可以取２个，则变为只有０个子，而g（０）＝０，
所以g（２）＝２；
３．如果还剩下３颗子，ａ．可以取１个，则变为只有２个子，而g（２）＝２，
　　　　　　　　　　　ｂ．可以取２个，则变为只有１个子，而g（１）＝１，
所以g（３）＝０；
４．如果还剩下４颗子，ａ．可以取１个，则变为只有３个子，而g（３）＝０，
　　　　　　　　　　　ｂ．可以取２个，则变为只有２个子，而g（２）＝２，
所以g（４）＝１；
５．如果还剩下５颗子，ａ．可以取１个，则变为只有４个子，而g（４）＝１，
　　　　　　　　　　　ｂ．可以取２个，则变为只有３个子，而g（３）＝０，
　　　　　　　　　　　ｃ．可以取５个，则变为只有０个子，而g（０）＝０，
所以g（５）＝２；
６．如果还剩下６颗子，ａ．可以取１个，则变为只有５个子，而g（５）＝２，
　　　　　　　　　　　ｂ．可以取２个，则变为只有４个子，而g（４）＝１，
　　　　　　　　　　　ｃ．可以取５个，则变为只有１个子，而g（１）＝１，
所以g（６）＝０；
．．．．．．

以此类推得出：
　　X ＝ ０　　１　　２　　３　　４　　５　　６　　７　　８　　９　　１０
ｇ（X）＝ ０　　１　　２　　０　　１　　２　　０　　１　　２　　０　　　１
如果还剩１０个棋子，那么先取的一定获胜。

我要写出一这样的函数int g(int param)
来得到对应的数值。
有哪位高人能写出来。
100分送上。

[goodheartppl]

UP

[hxzb7215191]

帮忙啊。

我看了半天没有看来这个规律的。

请大虾们给点思想吧。

[hxzb7215191]

游戏规则要实现两种：
两堆棋子情形：你和电脑轮流取子。由电脑决定谁先取子，每人每次可以在其中一堆取任意个（但至少取一个），或者在两堆取同样多个。最后一定是电脑使棋子数变为0而获胜。
多堆棋子情形：桌上有若干种颜色的棋子，每种均有两堆。你和电脑轮流取子，由电脑决定谁先取子，每人每次可以在其中一堆取任意个（但至少取一个），或者在同色的两堆中取相同多棋子。最后一定是电脑使棋子数变为0则获胜。
注意：每堆棋子个数随机生成。
要求一共有以下几个模块：
输入模块：问用户是玩两堆还是多堆 。
显示模块：显示有多少棋子；是电脑先取,还是你先取计算Grundy函计算Grundy函数值模块：显示函数值（该模块是我这个设计的核心）
计算机取子模块：电脑每次取多少，并监督其取子的合法性
用户取子模块：用户每次取多少，并监督其取子的合法性
显示模块： 显示每次取子之后，棋子的状态




下面是Grundy函数方法：（就是求以下的这个g（x））
定义：设局势X经过一切可能的合法动作，可以分别变为局势Y1、Y2…Yk（称为X的后继），则g（x）定义为最小的没有赋给任一后继的非负整数。

以下只是一个Grundy函数的最简单例子：

例1：如果桌上有10个数，规定甲乙两人轮流取子。每次只准取1、2或5个子。
首先令g（0）=0，那么
１．如果还剩下１颗子，可以取１个，则变为只有０个子，而g（０）＝０，
　　所以g（1）＝１；
２．如果还剩下２颗子，ａ．可以取１个，则变为只有１个子，而g（１）＝１，
　　　　　　　　　　　ｂ．可以取２个，则变为只有０个子，而g（０）＝０，
所以g（２）＝２；
３．如果还剩下３颗子，ａ．可以取１个，则变为只有２个子，而g（２）＝２，
　　　　　　　　　　　ｂ．可以取２个，则变为只有１个子，而g（１）＝１，
所以g（３）＝０；
４．如果还剩下４颗子，ａ．可以取１个，则变为只有３个子，而g（３）＝０，
　　　　　　　　　　　ｂ．可以取２个，则变为只有２个子，而g（２）＝２，
所以g（４）＝１；
５．如果还剩下５颗子，ａ．可以取１个，则变为只有４个子，而g（４）＝１，
　　　　　　　　　　　ｂ．可以取２个，则变为只有３个子，而g（３）＝０，
　　　　　　　　　　　ｃ．可以取５个，则变为只有０个子，而g（０）＝０，
所以g（５）＝２；
６．如果还剩下６颗子，ａ．可以取１个，则变为只有５个子，而g（５）＝２，
　　　　　　　　　　　ｂ．可以取２个，则变为只有４个子，而g（４）＝１，
　　　　　　　　　　　ｃ．可以取５个，则变为只有１个子，而g（１）＝１，
所以g（６）＝０；
．．．．．．

以此类推得出：
　　X ＝ ０　　１　　２　　３　　４　　５　　６　　７　　８　　９　　１０
ｇ（X）＝ ０　　１　　２　　０　　１　　２　　０　　１　　２　　０　　　１
如果还剩１０个棋子，那么先取的一定获胜。


结论：
1. 若g(x)>0, 则存在一个合法动作使 x 的后继 y 有g（y）=0；
2. 若g(x)=0，则对 x 的任一后继 y 都有g(y)〉0
若g(x)〉0，则先动作者，有获胜策略
若g(x)=0，则后动作者，有获胜策略

我的游戏的Grundy函数大致如下：
两堆情形：局势X=（m，n），因为没考虑颜色，所以g（m，n）= g（n，m），假设m<=n. 设g(0，0)=0，
1. g（0，1）=1，因为可以取1个，变为局势（0，0），而g(0，0)=0；
2. g（0，2）=2，因为可以取1个，变为局势（0，1），而g(0，1)=1，
可以取2个，变为局势（0，0），而g(0，0)=0；
2. g（0，3）=2，因为可以取1个，变为局势（0，2），而g(0，2)=2，
可以取2个，变为局势（0，1），而g(0，1)=1，
可以取3个，变为局势（0，0），而g(0，0)=0；
．．．．．．
ｇ（０，ｎ）＝ｎ
两堆都还有棋子时：
1. ｇ（1，1）＝2，
在第1堆中取1个，变为局势（0，1），g（0，1）=g（1，0），而g（0，1）=1，
在第2堆中取1个，变为局势（1，0），而g（1，0）=1，
在2堆中都分别取1个，变为局势（0，0），而g（0，0）=0，

2. ｇ（１，2）＝0
因为在第1堆中取1个，变为局势（0，2），g（0，2）=2，
在第2堆中取2个，变为局势（1，0），g（0，1）=g（1，0），g（1，0）=1，
在第2堆中取１个，变为局势（1，1），g（1，1）=2，
在第１堆中取１个，在第2堆中取１个，变为局势（0，1），g（0，1）=1
．．．．．．

你可以设一个数组flag[N]，初始化设：flag[0]= flag[1]=…= flag[N]=0
一旦有某个ｇ值＝ｋ时，令flag[k]=1

[hxzb7215191]

请大家帮忙啊。。。

[bobob]

#include <iostream.h>

#include <iostream.h>

int g(const int);

int main()
{
int i;
cout<<"please input num:";
cin>>i;
cout<<"g("<<i<<")="<<g(i)<<endl;

return 0;

}

int g(const int num)
{
if(num == 0)
{
return 0;
}
if(num == 1)
{
return 1;
}
if(num == 2)
{
return 2;
}
if(num == 3)
{
return 0;
}
if(num == 4)
{
return 1;
}
if(num>=5)
{
int num1 ,num2,num3;
num1 = g(num-1);
num2 = g(num-2);
num3 = g(num-5);
if(num1!=0 && num2!=0 && num3!=0)
{//没有一个等于0，返回0
return 0;
}
if(num1!=1 && num2!=1 && num3!=1)
{//有一个等于0，没有一个等于1，返回1
return 1;
}
if(num1!=2 && num2!=2 && num3!=2)
{//有一个等于0，一个等于1，没有一个等于2，返回2
return 2;
}

return 3;
}
else
return -1;
}

[bobob]

超过40就很慢了!呵呵
我再改进一下