SG函数

SG函数

有个讲得不错的博客：http://blog.csdn.net/strangedbly/article/details/51137432

简单介绍：

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 有三个后继状态分别为 a, b, c，那么SG(x) = mex{SG(a),SG(b),SG(c)}。 这样 集合S 的终态必然是空集，所以SG函数的终态为 SG(x) = 0,当且仅当 x 为必败点P时。

 

解题模型：

1. 把原游戏分解成多个独立的子游戏，则原游戏的SG函数值是它的所有子游戏的SG函数值的异或。

       即sg(G) = sg(G₁) ^ sg(G₂) ^ ... ^ sg(G_n)

2. 分别考虑每一个子游戏，计算其SG值。

3. 若sg(G)=0，则为P-Position(必败态)，否则为N-Position(必胜态)。

 

SG值的计算方法：(重点)

1.可选步数为1~m的连续整数，直接取模即可，SG(x) = x % (m+1);

2.可选步数为任意步，SG(x) = x；

3.可选步数为一系列不一定连续的数，用模板计算(模板在下面模板题代码中)。

 

模板题：HDU 1536 -- S-Nim

AC代码+详细注释：

#include <iostream>
#include <algorithm>
#include <cstring>
#define MAXN 10010  // 最大堆数
#define MAXM 110    // 最多有MAXM种不同个数的取石子方法
using namespace std;
int f[MAXM];   // f为可取石子数的集合
int sg[MAXN];  // sg[i]表示石子数为i时的sg函数值
bool Hash[MAXN];  // 标记一个数是否在mex{}集合中出现
// 打表预处理sg数组
void getSG(int m) {
    memset(sg, 0, sizeof(sg));
    for (int i = 1; i < MAXN; i++) {
        memset(Hash, false, sizeof(Hash));
        for (int j = 0; j < m && f[j] <= i; j++)
            Hash[sg[i-f[j]]] = true;  // 当前石子数为i，i-f[i]表示由i所能达到的石子数，将其sg值标记为已出现
        for (int j = 0; j < MAXN; j++) {  // mex(minimal excludant)运算
            if (!Hash[j]) {
                sg[i] = j;
                break;
            }
        }
    }
}
// 加一个dfs预处理sg数组，注意sg数组需要初始化为-1，而上面打表解法需要初始化为0
// 一般首选打表预处理，难以打表才用dfs
int SG_dfs(int x) {
    if (sg[x] != -1) return sg[x];
    memset(Hash, false, sizeof(Hash));
    for (int i = 0; i < m && f[i] <= x; i++) { // m为集合f的大小
        SG_dfs(x - f[i]);
        Hash[sg[x-f[i]]] = true;
    }
    for (int i = 0; i < MAXN; i++) {
        if (!Hash[i]) {
            return sg[x] = i;
        }
    }
}

int main() {
    int n, m;
    while (cin >> m && m) {
        for (int i = 0; i < m; i++) cin >> f[i];
        sort(f, f + m);
        getSG(m);
        cin >> n;
        while (n--) {
            int num, sum = 0;
            cin >> num;
            for (int i = 0; i < num; i++) {
                int each; cin >> each;
                sum ^= sg[each];
            }
            if (sum) cout << 'W';
            else cout << 'L';
        }
        cout << endl;
    }
    return 0;
}

HDU 1517 -- A Multiplication Game (典型的有向图游戏)：

#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
typedef long long LL;
map<LL, int> mp;
LL n;

int sg(LL x) {
    if (x >= n) return 0;
    if (mp.count(x)) return mp[x];
    vector<LL> mex;
    for (int i = 2; i <= 9; i++) {
        mex.push_back(sg(x * i));
    }
    sort(mex.begin(), mex.end());
    int len = mex.size();
    for (int i = 0; i < len; i++) {
        if (i != mex[i]) return mp[x] = i;
    }
    return mp[x] = mex[len-1] + 1;
}

int main() {
    while (cin >> n) {
        mp.clear();
        if (sg(1ll)) cout << "Stan wins." << endl;
        else cout << "Ollie wins." << endl;
    }
    return 0;
}

HDU 1847 -- Good Luck in CET-4 Everybody! (简单求sg)：

#include <iostream>
#include <cstring>
#define MAXN 1010
#define MAXM 11
using namespace std;
int sg[MAXN], f[MAXM];
bool Hash[MAXN];

void getSG(int m) {
    memset(sg, 0, sizeof(sg));
    for (int i = 1; i < MAXN; i++) {
        memset(Hash, false, sizeof(Hash));
        for (int j = 0; j < m && f[j] <= i; j++)
            Hash[sg[i-f[j]]] = true;
        for (int j = 0; j < MAXN; j++) {
            if (!Hash[j]) {
                sg[i] = j;
                break;
            }
        }
    }
}

int main() {
    int n, num = 1;
    for (int i = 0; i < MAXM; num <<= 1, i++) f[i] = num;
    getSG(MAXM);
    while (cin >> n) {
        if (sg[n]) cout << "Kiki" << endl;
        else cout << "Cici" << endl;
    }
    return 0;
}

HDU 1848 -- Fibonacci again and again (分为三个子游戏，求原游戏sg值)：

#include <iostream>
#include <cstring>
#define MAXN 1010
#define MAXM 100
using namespace std;
int sg[MAXN], f[MAXM];
bool Hash[MAXN];

int getFib() {
    int i;
    f[0] = 1, f[1] = 2;
    for (i = 2; f[i] <= MAXN; i++) f[i] = f[i-1] + f[i-2];
    return i;
}
void getSG(int m) {
    memset(sg, 0, sizeof(sg));
    for (int i = 1; i < MAXN; i++) {
        memset(Hash, false, sizeof(Hash));
        for (int j = 0; j < m && f[j] <= i; j++)
            Hash[sg[i-f[j]]] = true;
        for (int j = 0; j < MAXN; j++) {
            if (!Hash[j]) {
                sg[i] = j;
                break;
            }
        }
    }
}

int main() {
    int a, b, c;
    getSG(getFib());
    while (cin >> a >> b >> c && (a || b || c)) {
        if (sg[a] ^ sg[b] ^ sg[c]) cout << "Fibo" << endl;
        else cout << "Nacci" << endl;
    }
    return 0;
}

HDU 1079 -- Calendar Game (细致模拟)：

#include <iostream>
#include <cstring>
using namespace std;
int sg[110][15][40];
int day[110];
int mm[15] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

int get_sg(int y, int m, int d) {
    if (sg[y][m][d] != -1) return sg[y][m][d];
    if (m < 12 && d == mm[m] && d > mm[m+1]) {
        if (get_sg(y, m + 1, 1)) return sg[y][m][d] = 0;
        else return sg[y][m][d] = 1;
    }
    int a, b;
    if (m == 2 && d == day[y] || m < 12 && d == mm[m] && d <= mm[m+1]) {
        a = get_sg(y, m + 1, d), b = get_sg(y, m + 1, 1);
    }
    else if (m == 2 && d < day[y] || m < 12 && d < mm[m]) {
        a = get_sg(y, m, d + 1), b = get_sg(y, m + 1, d);
    }
    else if (m == 12 && d < mm[12]) {
        a = get_sg(y + 1, 1, d), b = get_sg(y, m, d + 1);
    }
    else if (m == 12 && d == mm[12]) {
        a = get_sg(y + 1, 1, d), b = (y + 1, 1, 1);
    }
    if (a == 0 || b == 0) return sg[y][m][d] = 1;
    else return sg[y][m][d] = 0;
}

int main() {
    int y, m, d, t;
    memset(sg, -1, sizeof(sg));
    for (int i = 1900; i <= 2001; i++) {
        if (i % 4 == 0 && i % 100 || i % 400 == 0) day[i-1900] = 29;
        else day[i-1900] = 28;
    }
    sg[101][11][4] = 0;
    for (int i = 5; i <= mm[11]; i++) sg[101][11][i] = 1;
    for (int i = 1; i <= mm[12]; i++) sg[101][12][i] = 1;
    cin >> t;
    while (t--) {
        cin >> y >> m >> d;
        y -= 1900;
        if (get_sg(y, m, d)) cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}

HDU 1404 -- Digital Deletions (暴力打sg表)：

#include <stdio.h>
#include <cstring>
#define N 1000000
using namespace std;
bool sg[N];

int get_len(int n) {
    int k = 1;
    while (n /= 10) k++;
    return k;
}
void get_sg(int n) {
    int len = get_len(n);
    int base = 1;
    for (int i = 0; i < len; i++) { // 将某一位变大都为必胜态
        int m = n;
        int tem = (m % (10 * base)) / base;
        m -= tem * base;
        for (int j = tem + 1; j <= 9; j++) sg[m+j*base] = true;
        base *= 10;
    }
    base = 1;
    while (len++ < 6) { // n后面补0...都为必胜态
        n *= 10;
        for (int i = 0; i < base; i++) sg[n+i] = true;
        base *= 10;
    }
}

int main() {
    memset(sg, false, sizeof(sg));
// 1为必败态，能一步到达必败态的都为必胜态，不能一步到达必败态的都为必败态
    for (int i = 1; i < N; i++) if (!sg[i]) get_sg(i);
    char s[10];
    while (gets(s)) {
        if (s[0] == '0') puts("Yes");
        else {
            int n = 0;
            for (int i = 0; s[i]; i++) n = n * 10 + s[i] - '0';
            if (sg[n]) puts("Yes");
            else puts("No");
        }
    }
    return 0;
}