《数据结构与算法分析：C语言描述》复习——第十章“算法设计技巧”——Alpha-Beta剪枝

2014.07.08 22:43

简介：

　　“搜索”与“剪枝”几乎是如影随形的。此处的“搜索”指的是带有回溯算法的深度优先搜索。

　　在之前的“Minimax策略”中我们给出了一个三连棋的程序，运行后你就知道计算一步棋要花多少时间。

　　为了计算最优的一步棋，我们可能需要递归9万多次。毫无疑问这种阶乘式的穷举过程必须通过剪枝来加速。

　　本篇介绍一种用于Minimax策略的剪枝思路——α-β剪枝。

　　剪枝的英语是pruning，所以不要想当然说成trimming。

图示：

　　在上一篇讲解Minimax策略的博文中我们给出了一棵博弈树：

　　

　　如果按照这棵树的形状来看，延伸下去应该会造成指数级的时间增长。

　　那么如果我们想做到“全知全能”，就得在下第一步棋的时候穷举所有可能的结局。因此你走一步棋就得推理9万多次。

　　按照这种脑力消耗，就是诸葛亮也吃不消，于是我们有两种办法可以偷懒：

　　　　1. 截断：我的脑容量没那么大，所以我只考虑三步棋以内的结果。三步棋之外的结果，姑且不管了。

　　　　2. 剪枝：有些结局实际上根本不需要分析，因为我们有充分的理由提前放弃那条路径。

　　本次不考虑截断的问题，只谈剪枝。

　　我们将刚才那棵博弈树中的两个结点标记为红色：

　　

　　此处我们强调两条性质：

　　　　1. 对于Min层的每个节点，它的任何子节点的值都不小于它自身。

　　　　2. 对于Max层的每个节点，它的任何子节点的值都不大于它自身。

　　这棵树中78和36两个结点下方的节点不会被访问到，因为没有必要。

　　注意78所处的是Min层，对手为了使我的利益最小化，会尽力找出最小值。而68比78小，因此在78的下方不可能找到小于68的节点。所以没有必要继续深入78中。

　　36的道理相同，只不过处于Max层，所以解释自然是相反的。

　　在每一层都可能会有这样的节点，因此随时留意这样的剪枝机会，能极大地提高效率。

　　如果我没记错，经过这种剪枝的程序最多只需要递归一百多次，和9万多次相比确实快了不少。

　　因为Min和Max层交替出现，因此这种剪枝也需要两套代码逻辑，分别称为α剪枝与β剪枝。二者合称α-β剪枝。

　　教材中只给出了其中一个剪枝的伪代码，如果你没想明白，肯定写不出另一个的。

　　接下来请运行代码吧，看看效率上的差异。不过可能的话，我还是建议你在不看代码的情况下，自己修改三连棋的程序来实现α-β剪枝。

　　

　　别忘了确保程序的正确性：如果你赢了电脑，那程序肯定是错的。

　　（提问：对于一个没有必胜策略的游戏，完美的AI是无法打败的，你只能打平手或者输给它，是这样吗？）

实现：

// Optimization for Minimax game strategy, using Alpha-Beta Pruning.
// You can watch over the 'function_call_count' variable.
#include <iostream>
#include <vector>
using namespace std;

int function_call_count;

bool computerWin(const vector<int> &board)
{
    int i, j;
    
    for (i = 0; i < 3; ++i) {
        for (j = 0; j < 3; ++j) {
            if (board[i * 3 + j] != -1) {
                break;
            }
        }
        if (j == 3) {
            return true;
        }
    }
    
    for (i = 0; i < 3; ++i) {
        for (j = 0; j < 3; ++j) {
            if (board[j * 3 + i] != -1) {
                break;
            }
        }
        if (j == 3) {
            return true;
        }
    }
    
    if (board[0] == board[4] && board[4] == board[8] && board[8] == -1) {
        return true;
    }
    
    if (board[2] == board[4] && board[4] == board[6] && board[6] == -1) {
        return true;
    }
    
    return false;
}

bool humanWin(const vector<int> &board)
{
    int i, j;
    
    for (i = 0; i < 3; ++i) {
        for (j = 0; j < 3; ++j) {
            if (board[i * 3 + j] != 1) {
                break;
            }
        }
        if (j == 3) {
            return true;
        }
    }
    
    for (i = 0; i < 3; ++i) {
        for (j = 0; j < 3; ++j) {
            if (board[j * 3 + i] != 1) {
                break;
            }
        }
        if (j == 3) {
            return true;
        }
    }
    
    if (board[0] == board[4] && board[4] == board[8] && board[8] == 1) {
        return true;
    }
    
    if (board[2] == board[4] && board[4] == board[6] && board[6] == 1) {
        return true;
    }
    
    return false;
}

bool fullBoard(const vector<int> &board)
{
    for (int i = 0; i < 9; ++i) {
        if (board[i] == 0) {
            return false;
        }
    }
    
    return true;
}

void findComputerMove(vector<int> &board, int &best_move, int &result, 
    int alpha, int beta)
{
    void findHumanMove(vector<int> &, int &, int &, int, int);
    int dc, i, response;
    
    ++function_call_count;
    best_move = -1;

    if (fullBoard(board)) {
        result = 0;
        return;
    }
    
    if (computerWin(board)) {
        result = -1;
        return;
    }
    
    result = alpha;
    for (i = 0; i < 9 && result > beta; ++i) {
        if (board[i] != 0) {
            continue;
        }
        board[i] = -1;
        findHumanMove(board, dc, response, result, beta);
        board[i] = 0;
        
        if (best_move == -1 || response < result) {
            result = response;
            best_move = i;
        }
    }
}

void findHumanMove(vector<int> &board, int &best_move, int &result, int alpha, 
    int beta)
{
    void findComputerMove(vector<int> &, int &, int &, int, int);
    int dc, i, response;
    
    ++function_call_count;
    best_move = -1;

    if (fullBoard(board)) {
        result = 0;
        return;
    }
    
    if (humanWin(board)) {
        result = 1;
        return;
    }
    
    result = beta;
    for (i = 0; i < 9 && result < alpha; ++i) {
        if (board[i] != 0) {
            continue;
        }
        board[i] = 1;
        findComputerMove(board, dc, response, alpha, result);
        board[i] = 0;
        
        if (best_move == -1 || response > result) {
            result = response;
            best_move = i;
        }
    }
}

void printBoard(const vector<int> &board)
{
    cout << "  1 2 3" << endl;
    int i, j;
    
    for (i = 0; i < 3; ++i) {
        cout << i + 1;
        for (j = 0; j < 3; ++j) {
            cout << ' ';
            switch(board[i * 3 + j]) {
            case -1:
                cout << 'X';
                break;
            case 0:
                cout << '.';
                break;
            case 1:
                cout << 'O';
                break;
            }
        }
        cout << endl;
    }
}

int main()
{
    vector<int> board;
    int n;
    int result;
    
    board.resize(9, 0);
    while (cin >> n) {
        if (n < 0 || n >= 9 || board[n]) {
            cout << "Invalid move" << endl;
            continue;
        }

        board[n] = 1;
        printBoard(board);
        if (humanWin(board)) {
            cout << "You win." << endl;
            break;
        }
        
        if (fullBoard(board)) {
            cout << "Draw." << endl;
            break;
        }
        
        result = 1;
        function_call_count = 0;
        findComputerMove(board, n, result, 1, -1);
        cout << "Number of function calls: " << function_call_count << endl;
        board[n] = -1;
        printBoard(board);
        if (computerWin(board)) {
            cout << "Computer win." << endl;
            break;
        }
        
        if (fullBoard(board)) {
            cout << "Draw." << endl;
            break;
        }
    }
    
    return 0;
}