Something about 博弈（POJ 3922 A simple stone game）

先是题目，本来是第三次训练的题，在这特别提出来讲。

先是题目：

E - A simple stone game Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit   Status   Practice   POJ 3922 Description After he has learned how to play Nim game, Mike begins to try another stone game which seems much easier.

The game goes like this: Two players start the game with a pile of n stones. They take stones from the pile in turn and every time they take at least one stone. The one who goes first can take at most n-1 stones for his first move. From then on a player can take at most k times as many stones as his opponent has taken last time. For example, if one player take m stones in his turn, then the other player can take at most k * m stones next time. The player who takes the last stone wins the game. Suppose that those two players always take the best moves and never make mistakes, your job is to find out who will definitely win the game. Input The first line contains a integer t, indicating that there are t test cases following.(t<=20). Each test case is a line consisting of two integer n and k.(2<=n<=10 8,1<=k<=10 5). Output For each test case, output one line starting with “Case N: ”, N is the case number. And then, if the first player can ensure a winning, print the minimum number of stones he should take in his first turn. Otherwise, print "lose". Please note that there is a blank following the colon. Sample Input 5 16 1 11 1 32 2 34 2 19 3

Sample Output  Case 1: lose Case 2: 1 Case 3: 3 Case 4: lose Case 5: 4

Hint When k = 1, the first player will definitely lose if the initial amount of stones is in the set {2, 4, 8, 16, 32, ...}. Let's call this kind of set “first-player-lose set”.

When k = 2, the first-player-lose set is {2, 3, 5, 8, 13, 21, 34, 57 ...} , which happens to be the Fibonacci sequence starting from 2.

先是一大神解法&分析：

来自：http://hi.baidu.com/lccycc_acm/item/a6f0dd0ec5c44a39f3eafcd3

两人取一堆n个石子 先手不能全部取完 之后每人取的个数不能超过另一个人上轮取的数*K

给n，K判断先手必胜并求第一步

博弈题

这题的思考过程非常有意义。

当k=1的时候 可知必败局面都是2^i  将n分解成二进制，然后先手取掉最后一个1.然后对方必然无法去掉更高的1，而对方取完我方至少还能拿掉最后一个1 导致对方永远取不完。

当k=2的时候，必败局面都是斐波那契数列。利用“先手去掉最后一个1，则后手必不能去掉更高阶的1导致取不完”的思想，斐波那契数列有一个非常好的性质就是：任意一个整数可以写成斐波那契数列中的不相邻的项的和，于是将n写成这种形式，先取走最后一个1，对方能取的数是这个数*2，小于高2位的1，所以取不完。

当K的时候， 想办法构造数列，将n写成数列中一些项的和，使得这些被取到的项的相邻两个倍数差距>k 那么每次去掉最后一个1 还是符合上面的条件。设这个数列已经被构造了i 项，第 i 项为a[ i ]，前 i 项可以完美对1..b[ i ] 编码使得每个编码的任意两项倍数>K 那么有

a[ i+1 ] = b[ i ] + 1;这是显然的 因为b[ i ] + 1没法构造出来，只能新建一项表示

然后计算b[ i+1] 既然要使用 a[ i+1 ] 那么下一项最多只能是某个 a[ t ] 使得 a[ t ] * K < a[ i+1 ] 于是

b[ i ] = b[ t ] + a[ i+1 ]

然后判断n是否在这个数列里面

如果在，那么先手必败。否则不停的减掉数列a中的项构造出n的分解，最后一位就是了。

代码:

 #include<stdio.h>
 #define N 2000000
 int a[N],b[N];
 int n,k,t,cas=;
 int main()
 {
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d%d",&n,&k);
         int i=,j=;
         a[]=b[]=;
         while(a[i]<n)
         {
             i++;
             a[i]=b[i-]+;   //b[i-1]是由a[0]...a[i-1]组成的自大的数，所以b[i-1]+1不能用a[0]……a[i-1]组成
             while(a[j+]*k<a[i])
                 j++;
             if(a[j]*k<a[i])  //要求b[j]，表示a[0]……a[i]组成，那么显然是要用到a[i]的，不然不就成了b[i-1]，既然用了a[i]，但是又要使相邻的倍数在K以上。则找到最大的j，使a[j]*k<a[i]那么满足条件，便是a[0]……a[j]能组成的最大的数，加上a[i]
                 b[i]=b[j]+a[i];
             else
                 b[i]=a[i];   //当前项不能和之前项组合，那么最大的数就只能是本身

         }
         printf("Case %d: ",++cas);
         if(a[i]==n)
             puts("lose");
         else
         {
             int ans;
             while(n)
             {
                 if(n>=a[i])
                 {
                     n-=a[i];
                     ans=a[i];
                 }
                 i--;
             }
             printf("%d\n",ans);
         }
     }
     return ;
 }

32MS

 #include<stdio.h>
 #include<cstdlib>
 int a[];
 int main()
 {
     int t,ti=;
     scanf("%d",&t);
     while(t--)
     {
         int n,m,i,k=;
         scanf("%d%d",&n,&m);
         a[]=;
         bool flag=;
         for(i=;a[i]<=n;i++)
         {
             if(a[i]==n) flag=;
             while(a[k]*m<a[i]) k++;
             a[i+]=a[i]+a[k];
         }
         if(flag) printf("Case %d: lose\n",ti++);
         else
         {
             while(n!=a[i])
             {
                 n%=a[i];
                 i--;
             }
             printf("Case %d: %d\n",ti++,n);
         }
     }
     return ;
 }

79MS

 #include<stdio.h>
 #define N 2000000
 int a[N],b[N];
 int n,k,t,cas=;
 int main(){
     scanf("%d",&t);
     while(t--){
         scanf("%d%d",&n,&k);
         int i=,j=;
         a[]=b[]=;
         while(a[i]<n){
             i++;
             a[i]=b[i-]+;
             while(a[j+]*k<a[i])
                 j++;
             if(a[j]*k<a[i])
                 b[i]=b[j]+a[i];
             else
                 b[i]=a[i];
         }
         printf("Case %d: ",++cas);
         if(a[i]==n)
             puts("lose");
         else{
             int ans;
             while(n){
                 if(n>=a[i]){
                     n-=a[i];
                     ans=a[i];
                 }
                 i--;
             }
             printf("%d\n",ans);
         }
     }
     return ;
 }

47ms
看这组数据就会懂了：

这是把a[i]打出来了.......