博弈论中的极小极大算法设置 5（Zobrist 哈希）

以前关于此主题的帖子：博弈论中的极小极大算法、博弈论中的评估函数、井字棋 AI – 寻找最佳移动、Alpha-Beta 剪枝。

Zobrist Hashing 是一种广泛用于 2 人棋盘游戏的散列函数。它是转置表中最常用的散列函数。换位表基本上存储了先前棋盘状态的评估值，因此如果再次遇到它们，我们只需从换位表中检索存储的值。我们将在后面的文章中介绍换位表。在本文中，我们将以国际象棋棋盘为例并为此实现散列函数。

伪代码：

// A matrix with random numbers initialized once
Table[#ofBoardCells][#ofPieces] 

// Returns Zobrist hash function for current conf-
// iguration of board.
function findhash(board):
    hash = 0
    for each cell on the board :
        if cell is not empty :
            piece = board[cell]
            hash ^= table[cell][piece]
    return hash

解释 ：

Zobrist Hashing 背后的想法是，对于给定的棋盘状态，如果给定单元格上有一块棋子，我们将使用表中相应单元格中该棋子的随机数。

如果随机数中有更多位，则散列冲突的机会就越小。因此，通常使用 64 位数字作为标准，这样大的数字发生哈希冲突的可能性很小。该表在程序执行期间只需初始化一次。

Zobrist Hashing 在棋盘游戏中被广泛使用的另一个原因是，当玩家移动时，不需要从头开始重新计算哈希值。由于 XOR 运算的性质，我们可以简单地使用少量 XOR 运算来重新计算哈希值。

执行 ：

我们将尝试为给定的电路板配置找到一个哈希值。

// A program to illustrate Zobeist Hashing Algorithm
#include 
using namespace std;
  
unsigned long long int ZobristTable[8][8][12];
mt19937 mt(01234567);
  
// Generates a Randome number from 0 to 2^64-1
unsigned long long int randomInt()
{
    uniform_int_distribution
                                 dist(0, UINT64_MAX);
    return dist(mt);
}
  
// This function associates each piece with
// a number
int indexOf(char piece)
{
    if (piece=='P')
        return 0;
    if (piece=='N')
        return 1;
    if (piece=='B')
        return 2;
    if (piece=='R')
        return 3;
    if (piece=='Q')
        return 4;
    if (piece=='K')
        return 5;
    if (piece=='p')
        return 6;
    if (piece=='n')
        return 7;
    if (piece=='b')
        return 8;
    if (piece=='r')
        return 9;
    if (piece=='q')
        return 10;
    if (piece=='k')
        return 11;
    else
        return -1;
}
  
// Initializes the table
void initTable()
{
    for (int i = 0; i<8; i++)
      for (int j = 0; j<8; j++)
        for (int k = 0; k<12; k++)
          ZobristTable[i][j][k] = randomInt();
}
  
// Computes the hash value of a given board
unsigned long long int computeHash(char board[8][9])
{
    unsigned long long int h = 0;
    for (int i = 0; i<8; i++)
    {
        for (int j = 0; j<8; j++)
        {
            if (board[i][j]!='-')
            {
                int piece = indexOf(board[i][j]);
                h ^= ZobristTable[i][j][piece];
            }
        }
    }
    return h;
}
  
// Main Function
int main()
{
    // Uppercase letters are white pieces
    // Lowercase letters are black pieces
    char board[8][9] =
    {
        "---K----",
        "-R----Q-",
        "--------",
        "-P----p-",
        "-----p--",
        "--------",
        "p---b--q",
        "----n--k"
    };
  
    initTable();
  
    unsigned long long int hashValue = computeHash(board);
    printf("The hash value is     : %llu\n", hashValue);
  
    //Move the white king to the left
    char piece = board[0][3];
  
    board[0][3] = '-';
    hashValue ^= ZobristTable[0][3][indexOf(piece)];
  
    board[0][2] = piece;
    hashValue ^= ZobristTable[0][2][indexOf(piece)];
  
  
    printf("The new hash value is : %llu\n", hashValue);
  
    // Undo the white king move
    piece = board[0][2];
  
    board[0][2] = '-';
    hashValue ^= ZobristTable[0][2][indexOf(piece)];
  
    board[0][3] = piece;
    hashValue ^= ZobristTable[0][3][indexOf(piece)];
  
    printf("The old hash value is : %llu\n", hashValue);
  
    return 0;
}

输出 ：

The hash value is     : 14226429382419125366
The new hash value is : 15124945578233295113
The old hash value is : 14226429382419125366

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。