poj 1085 Triangle War 1568 Find the Winning Move 极大极小搜索 alpha-beta剪枝

一，极大极小搜索及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: gwq5210@qq.com 
    > 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: gwq5210@qq.com 
    > 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;
}