《数据结构与算法分析：C语言描述》复习——第十章“算法设计技巧”——Minimax策略

2014.07.08 20:53

简介：

　　Minimax策略描述的是二人在轮流操作的博弈中，尽力使自己的利益最大化（Max），使对手利益最小化（Min）的一种策略。

　　这样的游戏有很多种，其中最典型的就是双人棋牌类游戏：中国象棋、五子棋、扑克牌等等。

　　这样的游戏的特点是：

　　　　1. 两人交替操作，一方先开始

　　　　2. 两人的操作互相独立，没有协作

　　游戏的种类实在太多，生活中处处是游戏。

　　“游戏”和“博弈”的英语释义都是“game”，所以我们其实可以认为理论上它们是一回事，只不过一个通俗，一个深奥。

图示：

　　本次我们使用书上给出的一个非常简单的棋牌游戏“三连棋”作为例子，来解释Minimax策略。

　　如图：

　　

　　给定一个3X3的棋盘，两人轮流在上面画“O”和“X”，谁能先将三个相同符号连成一条线（横竖斜皆可），就算赢。

　　本次的代码会实现这个游戏的AI，允许你和程序来玩这个游戏。运行程序后，你会发现不论你怎么下棋，你都赢不了的。

　　因为这个游戏是公平的，没有必胜策略，因此电脑程序总能和你打成平局。

　　如果你不好好下棋，当然也会输掉。

　　

　　下面我们开始讨论Minimax策略的理论部分。

　　下面是一棵树（分叉数量我们不关心）：

　　

　　上面这棵树叫“博弈树”，英文是game tree。其中Max层和Min层交替出现。关于这棵树有四点需要解释：

　　　　1. Max层表示轮到我操作，期望我的利益最大化，所以标记为Max层

　　　　2. Min层表示轮到对手操作，期望我的利益最小化，所以标记为Min层

　　　　3. 节点中有一个数值，这个莫名其妙的数值是本章最难理解的东西——利益

　　　　4. 树的底层总是叶子节点，此处每个叶子节点都表示游戏的一种结局，因为游戏结束了，树才不会继续延伸下去

　　利益是什么？金钱，高考分数，身高体重，房子面积。总之说多了都是泪。

　　游戏中的“利益”不能用一个“赢”字来概括，否则你无法着手去分析赢的办法。

　　此处的利益，应该是具有多个参数的一个函数F(...)，函数值越大，你离“赢”就越近。

　　

　　比如下象棋，“赢”的定义是吃掉对手的“将”或者“帅”。所以你不能将“对手的将是否存在”作为利益的判断条件。

　　如果你手上现在有7个棋子，而对手只剩2个，那么很有可能你会赢，因此将双方棋子的数量差作为“利益”的标准，可能会更好。

　　同样是象棋棋子，“车”的攻击力巨大，“马”的行动灵活，“士”的防御至关重要，因此不同的棋子为你带来的潜在利益各不相同。

　　正是由于实际的游戏如此复杂，想用一个包含了很多参数的函数F(...)来表达利益才显得非常困难。

　　对于中国象棋之类的游戏，这个估值函数可以复杂到让人吐血，也可以很简单。至于用户能看到的区别，就是“电脑厉害死了”和“电脑弱爆了”。

　　

　　至此，你要随时记住一个游戏中的两个条件：

　　　　1. 赢的标准是什么（走象棋，吃掉对方的将帅）

　　　　2. 为了达到“赢”，我应该朝什么方向努力（走象棋，努力吃掉对方的棋子）

　　

　　那么三连棋呢：

　　　　1. 赢的标准，三个棋子连成一条线

　　　　2. 为了达到“赢”，你应该尽力把自己的棋子连在一起

　　

　　至此我已经不知道该怎么继续讲了，因为我思考到这儿之后就直接开始编写代码了。

　　现在你可以运行下面的代码，试试和电脑下棋，并单步调试观察运行过程。

　　如果你要自己编码实现这个程序，请记住一条原则：你如果赢了电脑，那程序就是错的。

　　在阅读代码的过程中，请尝试理解这个程序中是如何定义“利益”的。

实现：

 感谢 @无聊的豆子君 指出代码中的错误。

// 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 (humanWin(board)) {
        result = 1;
        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 (computerWin(board)) {
        result = -1;
        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;
}