一，極大極小搜尋及alpha-beta剪枝(參考這裡)
在博弈搜尋中，比如：圍棋，五子棋，象棋等，結果有三種可能：勝利，失敗和平局。

理論上可以窮舉所有的走法，這就需要生成整棵博弈樹。實際上不可行。因此搜尋時可以限制博弈樹的深度，到達該深度則不再往下搜，相當於只往前看n步。

假設：max和min對弈，輪到max走棋了，那麼我們遍歷max的每一個可能走棋方法，然後對於前面max的每一個走棋方法，遍歷min的每一個走棋方法，然後接著遍歷max的每一個走棋方法，。。。直到分出了勝負或者達到了搜尋深度的限制。若達到搜尋深度限制時尚未分出勝負，則根據當前局面的形式，給出一個得分，計算得分的方法被稱為估價函式，不同遊戲的估價函式如何設計和具體的遊戲相關。

在搜尋樹中，輪到max走棋的節點為極大結點，輪到min走棋的節點是極小節點。

極大極小搜尋
確定估價函式，來計算每個棋局結點的估價值，對max方有利，估價值為正，對max越有利，估價值越大；對min方有利，估價值為負，對min方越有利，估價值越小。

從當前棋局的結點要決定下一步如何走時，以當前棋局節點為根，生成一棵深度為n的搜尋樹。不妨總是假設當前棋局結點是max結點。

用局面估價函式計算出每個葉子結點的估價值。

若某個非葉子結點是極大結點，則其估價值為其子節點中估價最大的那個結點的估價值。
若某個非葉子結點是極小結點，則其估價值為其子結點中估價最小的那個結點的估價值。

max選當前棋局結點的估價值最大的那個子節點，作為此步行棋的走法。
虛擬碼如下(

function minimax(node, depth)
    if node is a terminal node or depth = 0
        return the heuristic value of node
    if the adversary is to play at node
        let α := +∞
        foreach child of node
            α := min(α, minimax(child, depth-1))
    else {we are to play at node}
        let α := -∞
        foreach child of
 
 node
            α := max(α, minimax(child, depth-1))
    return α

alpha和beta剪枝
若結點x是min結點，其兄弟結點中，已經求出來的最大估價值是b（有些兄弟結點還沒有算），那麼在對x的子節點進行考察的時候，一旦發現x的某子節點的估價值小於等於b，則不必在考察後邊x的結點了。這裡被剪掉的是x結點的子節點，也就是極大結點。同理對應的還有beta剪枝，剪掉的是極小結點。

二，例題
poj1568 Find the Winning Move
給定一個4*4的四子連珠棋盤的局面，現在輪到x先走，請問x下在哪裡可以必勝。

....
.xo.
.ox.
....

在窮盡搜尋中，而非搜幾層就停止的情況下，估價函式只有三種取值，正（inf），0，負（-inf），分別代表己方勝，平，負。

必勝是無論對手怎麼走，自己最後都能找到獲勝辦法，不是自己無論怎麼走都能獲勝。

如果能找到一個走法，其對應的結點估價值是inf，則就是一個必勝的策略。
具體程式碼如下：

/*************************************************************************
    > File Name: 1568.cpp
    > Author: gwq
    > Mail: [email protected] 
    > Created Time: 2015年09月01日 星期二 14時41分57秒
 ************************************************************************/

#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>

#define INF (INT_MAX / 10)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define pb push_back
#define sz(a) ((int)(a).size())

using namespace std;
typedef set<int> si;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef long long ll;

const double esp = 1e-5;

#define N 5

int ansx, ansy, cnt;
char mp[N][N], tp[N];

int max_search(int x, int y, int beta);

void print(void)
{
    for (int i = 0; i < 4; ++i) {
        printf("%s\n", mp[i]);
    }
}

bool check(int x, int y)
{
    bool flag = true;
    for (int i = 0; i < 4; ++i) {
        if (mp[x][i] != mp[x][y]) {
            flag = false;
            break;
        }
    }
    if (flag) {
        return true;
    }
    flag = true;
    for (int i = 0; i < 4; ++i) {
        if (mp[i][y] != mp[x][y]) {
            flag = false;
            break;
        }
    }
    if (flag) {
        return true;
    }
    int c = 0;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (i + j == x + y) {
                if (mp[i][j] == mp[x][y]) {
                    ++c;
                }
            }
        }
    }
    if (c == 4) {
        return true;
    }
    c = 0;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (i - j == x - y) {
                if (mp[i][j] == mp[x][y]) {
                    ++c;
                }
            }
        }
    }
    if (c == 4) {
        return true;
    } else {
        return false;
    }
}

int min_search(int x, int y, int alpha)
{
    int ans = INF;

    if (check(x, y)) {
        return INF;
    }
    if (cnt == 16) {
        return 0;
    }
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (mp[i][j] == '.') {
                mp[i][j] = 'o';
                ++cnt;
                int tmp = max_search(i, j, ans);
                ans = min(ans, tmp);
                mp[i][j]= '.';
                --cnt;
                if (ans <= alpha) {
                    return ans;
                }
            }
        }
    }
    return ans;
}

int max_search(int x, int y, int beta)
{
    int ans = -INF;

    if (check(x, y)) {
        return -INF;
    }
    if (cnt == 16) {
        return 0;
    }

    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (mp[i][j] == '.') {
                mp[i][j] = 'x';
                ++cnt;
                int tmp = min_search(i, j, ans);
                ans = max(ans, tmp);
                mp[i][j]= '.';
                --cnt;
                if (ans >= beta) {
                    return ans;
                }
            }
        }
    }
    return ans;
}

bool solve(void)
{
    int alpha = -INF;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            if (mp[i][j] == '.') {
                mp[i][j] = 'x';
                ++cnt;
                int tmp = min_search(i, j, alpha);  // X走過之後O走
                mp[i][j] = '.';
                --cnt;
                if (tmp == INF) {
                    ansx = i;
                    ansy = j;
                    return true;
                }
            }
        }
    }
    return false;
}

int main(int argc, char *argv[])
{
    while (scanf("%s", tp) != EOF) {
        if (tp[0] == '$') {
            break;
        }
        cnt = 0;
        for (int i = 0; i < 4; ++i) {
            scanf("%s", mp[i]);
            for (int j = 0; j < 4; ++j) {
                if (mp[i][j] != '.') {
                    ++cnt;
                }
            }
        }

        if (cnt <= 4) {     // 這一步直接從2S+到0ms,然而並不知道為啥
            printf("#####\n");
            continue;
        }

        if (solve()) {
            printf("(%d,%d)\n", ansx, ansy);
        } else {
            printf("#####\n");
        }
    }
    return 0;
}

poj 1085 Triangle War
兩個遊戲者輪流填充虛線三角形，每次只能填充一條短邊，若某遊戲者填充一條短邊後組成了一個小三角形，則該遊戲者擁有這個三角形，並且可以繼續填充。

當所有邊都被填充之後，擁有三角形數目多的遊戲者獲勝。給定一個局面，問誰可以贏。

三角形的個數是9，當一個人擁有5個及以上個三角形是這個人就必勝。這裡的估價函式定義為a的三角形數-b的三角形數。
程式碼如下：

/*************************************************************************
    > File Name: 1085.cpp
    > Author: gwq
    > Mail: [email protected] 
    > Created Time: 2015年09月01日 星期二 16時35分54秒
 ************************************************************************/

#include <cmath>
#include <ctime>
#include <cctype>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>

#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>

#define INF (INT_MAX / 10)
#define clr(arr, val) memset(arr, val, sizeof(arr))
#define pb push_back
#define sz(a) ((int)(a).size())

using namespace std;
typedef set<int> si;
typedef vector<int> vi;
typedef map<int, int> mii;
typedef pair<int, int> pii;
typedef long long ll;

const double esp = 1e-5;

#define N 20

int num[N], who, n, cnt, ans[2];
int dx[] = {1, 1, 2, 2, 2, 3, 3, 4, 5, 4, 4, 5, 5, 6, 6, 7, 8, 9};
int dy[] = {2, 3, 3, 4, 5, 5, 6, 5, 6, 7, 8, 8, 9, 9, 10, 8, 9, 10};
int mp[][N] = {
    {0, 1, 2},
    {2, 4, 5},
    {3, 4, 7},
    {5, 6, 8},
    {7, 10, 11},
    {11, 12, 16},
    {8, 12, 13},
    {9, 10, 15},
    {13, 14, 17}
};

int getid(int a, int b)
{
    int aa = min(a, b);
    int bb = max(a, b);
    for (int i = 0; i < 18; ++i) {
        if (aa == dx[i] && bb == dy[i]) {
            return i;
        }
    }
    return -1;
}

// 檢查三角形的時候，需要注意，因為加入的時候可能組成兩個三角形
int check(int id)
{
    int ret = 0;
    for (int i = 0; i < 9; ++i) {
        if (mp[i][0] == id || mp[i][1] == id || mp[i][2] == id) {
            int flag = 0;
            for (int j = 0; j < 3; ++j) {
                flag += num[mp[i][j]];
            }
            if (flag == 3) {
                ret++;
            }
        }
    }
    return ret;
}

int min_search(int alpha, int a, int b);

int max_search(int beta, int a, int b)
{
    if (cnt == 18) {
        return a > b ? INF : -INF;
    }
    if (a >= 5) {
        return INF;
    }
    if (b >= 5) {
        return -INF;
    }

    int tmp = -INF;
    for (int i = 0; i < 18; ++i) {
        if (!num[i]) {
            num[i] = 1;
            ++cnt;
            // 改變後需要恢復，索性存起來
            int aa = a;
            int bb = b;
            int cc = check(i);
            aa += cc;
            if (cc) {
                // 這裡傳入的值需要注意，這個的父節點是max，
                // 所以這裡的剪枝需要beta，而不是tmp，即當前
                // min結點獲得的最大值。下邊類似
                tmp = max(max_search(beta, aa, bb), tmp);
            } else {
                tmp = max(min_search(tmp, aa, bb), tmp);
            }
            num[i] = 0;
            --cnt;
            if (tmp >= beta) {
                return tmp;
            }
        }
    }
    return tmp;
}

int min_search(int alpha, int a, int b)
{
    if (cnt == 18) {
        return a > b ? INF : -INF;
    }
    if (a >= 5) {
        return INF;
    }
    if (b >= 5) {
        return -INF;
    }

    int tmp = INF;
    for (int i = 0; i < 18; ++i) {
        if (!num[i]) {
            num[i] = 1;
            ++cnt;
            int aa = a;
            int bb = b;
            int cc = check(i);
            bb += cc;
            if (!cc) {
                tmp = min(max_search(tmp, aa, bb), tmp);
            } else {
                tmp = min(min_search(alpha, aa, bb), tmp);
            }
            --cnt;
            num[i] = 0;
            if (tmp <= alpha) {
                return tmp;
            }
        }
    }
    return tmp;
}

int main(int argc, char *argv[])
{
    int t;
    int cs = 0;
    scanf("%d", &t);
    while (t--) {
        scanf("%d", &n);
        clr(num, 0);
        clr(ans, 0);
        who = 0;
        cnt = n;
        for (int i = 0; i < n; ++i) {
            int a, b;
            scanf("%d%d", &a, &b);
            int id = getid(a, b);
            num[id] = 1;
            int cc = check(id);
            if (cc) {
                ans[who] += cc;
            } else {
                who = !who;
            }
        }
        int ret = 0;
        if (!who) {
            ret = max_search(INF, ans[0], ans[1]);
        } else {
            ret = min_search(-INF, ans[0], ans[1]);
        }
        printf("Game %d: %c wins.\n", ++cs, ret == INF ? 'A' : 'B');
    }
    return 0;
}