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 有三個后繼狀態分別為 SG(a),SG(b),SG(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;
}