hdu 3595 （Every Sg 博弈）_hdu3595-优快云博客

本文解析了一道典型的EverySG博弈问题，通过贪心策略确保在多组游戏中取得胜利。介绍了如何计算不同游戏状态的SG值及步数，最终确定胜者。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3595

大致题意：

给你两堆石子，每次可以从一堆中取走另一堆的倍数个石子，N对石子堆同时进行操作，没有石子可移动者算输。

思路：

典型的evrey sg博弈，every sg和普通的s博弈的最大区别就是多个游戏同时进行且每个游戏都必须做出操作，其思路就是贪心的方法·：

对于自己必胜的游戏，要让游戏尽可能晚的结束，对于自己必输的游戏，要让游戏尽早的结束，这样才能让自己必胜的游戏覆盖掉自己必输的游戏，让最后结束的游戏是自己必胜的游戏，这样对于整个游戏自己就是必胜的。

对这道题来讲，我们求出来不同游戏的结束步数，然后比较求出来其中的最长步数如果这个步数是奇数则“MM”赢得整场游戏，否则“GG”赢得整场游戏。关键是如何求这个步数。

求这个步数需要记录每个状态的sg值，如果这个状态的sg值为1（表示这个状态是必胜态），则这个点的步数应该为子状态中所有必败态的最大步数+1，若为零，则为必胜态的最小值+1，对于求sg值，有若子状态中存在必败态则此状态为必胜态，否则为必败态。（也可以用sg定理）

代码给出两个版本一个是大神的版本，我感觉这个简直就是every sg 的模板代码，另一个是我参考大神写的dp版本，其中用了sg定理可能会慢一点

大神版：

#include<cstdio>
#include<cstdio>
#include<cstring>
#include<iostream>
#define M 1002
using namespace std;
int n,sg[M][M],step[M][M];
int find(int a,int b)
{

    if(sg[a][b]>=0) return sg[a][b];
    if(a>b) swap(a,b);
    int mi=99999999,ma=0;
    for(int i=a;i<=b;i+=a)
    {

        if(find(a,b-i)==0)//后一步是必败点
        {
            ma=max(ma,step[a][b-i]);//当前点是必胜点，所以要延时
            sg[a][b]=sg[b][a]=1;
        }
        else mi=min(mi,step[a][b-i]);
    }

    if(sg[a][b]==1)
    {

        step[a][b]=step[b][a]=ma+1;
        return 1;
    }

    step[a][b]=step[b][a]=mi+1;
    return sg[a][b]=sg[b][a]=0;
}

int main(){

    memset(sg,-1,sizeof(sg));
    for(int i=0;i<=1000;i++) step[0][i]=step[i][0]=sg[i][0]=sg[0][i]=0;
    while(~scanf("%d",&n)){

        int ma=0,ma1=0,a,b;
        while(n--)
        {
           scanf("%d %d",&a,&b);
           if(a==0||b==0) continue;
           if(find(a,b)==1)
           {
               if(step[a][b]>ma)
               ma=step[a][b];
           }
           else
           {
               if(step[a][b]>ma1)
               ma1=step[a][b];
           }

        }
         puts(ma>ma1?"MM":"GG");
      }
      return 0;
}

自己的dp版本：

//hdu 3595(every sg)
#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <algorithm>
#include <vector>
#define INF 2<<29
#define eps 1e-9
using namespace std;
const int MAX_M=200;
const int MAX_N=1010;
int sg[MAX_N][MAX_N],step[MAX_N][MAX_N];
bool used[MAX_N];
int GetStep(int a,int b)
{
    if(step[a][b]!=-1) return step[a][b];
    if(a<b) swap(a,b);
    int ma,mi;
    for(int i=1;i<=a;i++){
        step[i][0]=0;
        for(int j=1;j<=b;j++){
            ma=0,mi=INF;
            memset(used,0,sizeof(used));
            for(int k=j;k<=i;k+=j){
                if(!sg[i-k][j]||!sg[j][i-k]){
                    if(j<i-k) ma=max(ma,step[i-k][j]);
                    else ma=max(ma,step[j][i-k]);
                }
                else{
                    if(j<i-k) mi=min(mi,step[i-k][j]);
                    else mi=min(mi,step[j][i-k]);
                }
                if(i-k<j) used[sg[j][i-k]]=1;
                else used[sg[i-k][j]]=1;
            }
            for(int k=0;k<INF;k++){
                if(!used[k]){
                    sg[i][j]=sg[j][i]=k;
                    break;
                }
            }
            if(sg[i][j]) step[i][j]=step[j][i]=ma+1;
            else step[i][j]=step[j][i]=mi+1;
        }
    }
    return step[a][b];
}
int main()
{
    int T,a,b,ans;
    for(int i=0;i<=1000;i++)   step[i][0]=step[0][i]=sg[i][0]=sg[0][i]=0;
    for(int i=0;i<=1000;i++) memset(step[i],-1,sizeof(step[i]));
    while(scanf("%d",&T)!=EOF){
        ans=0;
        GetStep(1000,1000);
        while(T--){
            scanf("%d%d",&a,&b);
            ans=max(ans,step[a][b]);
        }
        if(!(ans%2)) puts("GG");
        else puts("MM");
    }
    return 0;
}

就是这样了~~ 自己加油