Minimax 算法表现异常

Question

我正在做作业。 我想创建一个由计算机模拟和玩的游戏。 这是一个合乎逻辑的游戏，目标是收集最多且价值最高的代币。 程序首先要求以这种格式输入（“END”表示输入结束，正在努力将其删除）：

N:1,2 
W:3,5
E:9,1,1,1
S:1,7
END

字母代表方向，如东、西、北、南。 指示后的数字是具有价值的标记。 您只能从一个方向的末端拾取标记。 收集最有价值的代币的玩家获胜。

我需要让游戏以最佳方式发挥作用，找到了极小极大算法。 但我完全不知道如何正确实施它。

我在问一些善良的灵魂，帮助我让它正常工作。 至少给一些提示：）

这就是我尝试过的。 它以某种方式工作，但不是最佳方式。 例如在输入中我提供的最佳结果是：

A/B: 15/16

但我得到：

A/B: 14/17

我的代码在这里。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#define MAX_TOKENS 100

struct Game
{
    //lists with the values ​​of the tokens on the individual arms of the cross
    int *north;
    int *west;
    int *east;
    int *south;
    //lengths of token value lists
    int north_size;
    int west_size;
    int east_size;
    int south_size;
    //scores of players A and B
    int score_a;
    int score_b;
};
void remove_token(struct Game *game, int player, char direction)
{
    //variable for the token taken
    int token;

    //according to the direction, remove the token and add its value to the player's score
    switch (direction)
    {
    case 'N':
        //remove the token from the N arm
        token = game->north[game->north_size - 1];
        //reduce the length of the token value list by 1
        game->north_size--;
        //add the chip value to the player's score
        if (player == 0)
            game->score_a += token;
        else
            game->score_b += token;
        break;
    case 'W':
        //remove the token from the W arm
        token = game->west[game->west_size - 1];
        //reduce the length of the token value list by 1
        game->west_size--;
        //add the chip value to the player's score
        if (player == 0)
            game->score_a += token;
        else
            game->score_b += token;
        break;
    case 'E':
        //remove the token from the E arm
        token = game->east[game->east_size - 1];
        //reduce the length of the token value list by 1
        game->east_size--;
        //add the chip value to the player's score
        if (player == 0)
            game->score_a += token;
        else
            game->score_b += token;
        break;
    case 'S':
        //remove the token from the S arm
        token = game->south[game->south_size - 1];
        //reduce the length of the token value list by 1
        game->south_size--;
        //add the chip value to the player's score
        if (player == 0)
            game->score_a += token;
        else
            game->score_b += token;
        break;
    default:
        //throw an error if the player entered an invalid direction
        printf("Neplatný směr pro odebrání žetonu!\n");
    }
}
char minimax(struct Game *game, int depth, int player, int alpha, int beta)
{
    //if all arms are empty or we have reached the maximum depth, return the best direction
    if (game->north_size == 0 && game->west_size == 0 && game->east_size == 0 && game->south_size == 0 || depth == 0)
        return 'X';

    //the best move value for player A
    int best_score_a = INT_MIN;
    //the best move value for player B
    int best_score_b = INT_MAX;
    //direction for best move
    char best_direction;

    //go through all arms to find the best move
    if (game->north_size > 0)
    {
        //copy the game state
        struct Game game_copy = *game;
        //remove the token from the N arm
        remove_token(&game_copy, player, 'N');
        //find out the best move for your opponent
        int score = minimax(&game_copy, depth - 1, player == 0 ? 1 : 0, alpha, beta);
        //update the best move for player A
        if (player == 0 && score > best_score_a)
        {
            best_score_a = score;
            best_direction = 'N';
        }
        //update the best move for player B
        if (player == 1 && score < best_score_b)
        {
            best_score_b = score;
            best_direction = 'N';
        }
        //update alpha and beta
        if (player == 0)
            alpha = fmax(alpha, score);
        else
            beta = fmin(beta, score);
        //if beta is less than alpha, we end traversing the tree
        if (beta <= alpha)
            return best_direction;
    }
      if (game->west_size > 0)
    {
        //copy the game state
        struct Game game_copy = *game;
        //remove the token from the W arm
        remove_token(&game_copy, player, 'W');
        //find out the best move for your opponent
        int score = minimax(&game_copy, depth - 1, player == 0 ? 1 : 0, alpha, beta);
        //update the best move for player A
                if (player == 0 && score > best_score_a)
        {
            best_score_a = score;
            best_direction = 'W';
        }
        //update the best move for player B
        if (player == 1 && score < best_score_b)
        {
            best_score_b = score;
            best_direction = 'W';
        }
        //update alpha and beta
        if (player == 0)
            alpha = fmax(alpha, score);
        else
            beta = fmin(beta, score);
        //if beta is less than alpha, we end traversing the tree
        if (beta <= alpha)
            return best_direction;
    }
    if (game->east_size > 0)
    {
        //copy the game state
        struct Game game_copy = *game;
        //remove the token from the E arm
        remove_token(&game_copy, player, 'E');
        //find out the best move for your opponent
        int score = minimax(&game_copy, depth - 1, player == 0 ? 1 : 0, alpha, beta);
        //update the best move for player A
        if (player == 0 && score > best_score_a)
        {
            best_score_a = score;
            best_direction = 'E';
        }
        //update the best move for player B
        if (player == 1 && score < best_score_b)
        {
            best_score_b = score;
            best_direction = 'E';
        }
        //update alpha and beta
        if (player == 0)
            alpha = fmax(alpha, score);
        else
            beta = fmin(beta, score);
        //if beta is less than alpha, we end traversing the tree
        if (beta <= alpha)
            return best_direction;
    }
    if (game->south_size > 0)
    {
        //copy the game state
        struct Game game_copy = *game;
        //remove the token from the S arm
        remove_token(&game_copy, player, 'S');
        //find out the best move for your opponent
        int score = minimax(&game_copy, depth - 1, player == 0 ? 1 : 0, alpha, beta);
        //update the best move for player A
        if (player == 0 && score > best_score_a)
        {
            best_score_a = score;
            best_direction = 'S';
        }
        //update as soon as possible
                if (player == 1 && score < best_score_b)
        {
            best_score_b = score;
            best_direction = 'S';
        }
        //update alpha and beta
        if (player == 0)
            alpha = fmax(alpha, score);
        else
            beta = fmin(beta, score);
        //if beta is less than alpha, we end traversing the tree
        if (beta <= alpha)
            return best_direction;
    }

    //return the best move
    return player == 0 ? best_direction : best_direction;
}
void read_tokens(int *north, int *west, int *east, int *south, int *north_size, int *west_size, int *east_size, int *south_size)
{
    //buffer for reading in input
    char buffer[MAX_TOKENS];

    //read in the input line by line
    while (fgets(buffer, MAX_TOKENS, stdin) != NULL)
    {
        //remove the newline character from the end of the line
        buffer[strcspn(buffer, "\n")] = 0;
        //check for the "END" string to end the input
        if (strcmp(buffer, "END") == 0)
            break;
        //split the line at the colon character
        char *direction = strtok(buffer, ":");
        char *tokens = strtok(NULL, ":");

        //split the tokens at each comma
        char *token = strtok(tokens, ",");

        //determine the direction and store the tokens in the appropriate array
        if (strcmp(direction, "N") == 0)
        {
            while (token != NULL)
            {
                north[*north_size] = atoi(token);
                (*north_size)++;
                token = strtok(NULL, ",");
            }
        }
        else if (strcmp(direction, "W") == 0)
        {
            while (token != NULL)
            {
                west[*west_size] = atoi(token);
                (*west_size)++;
                token = strtok(NULL, ",");
            }
        }
        else if (strcmp(direction, "E") == 0)
        {
            while (token != NULL)
            {
                east[*east_size] = atoi(token);
                (*east_size)++;
                token = strtok(NULL, ",");
            }
        }
        else if (strcmp(direction, "S") == 0)
        {
            while (token != NULL)
            {
                south[*south_size] = atoi(token);
                (*south_size)++;
                token = strtok(NULL, ",");
            }
        }
        else
        {
            //invalid direction = error
            printf("Nespravny vstup.\n");
        }
    }
}

void print_progress(struct Game *game, int player, char direction)
{
    char letter_player = ' ';
    if (player == 0)
    {
        letter_player = 'A';
    }
    else
        letter_player = 'B';
    //printing of individual steps
    switch (direction)
    {
    case 'N':
        printf("%c: %c[%d] (%d)\n", letter_player, direction, game->north_size, game->north[game->north_size - 1]);
        break;
    case 'W':
        printf("%c: %c[%d] (%d)\n", letter_player, direction, game->west_size, game->west[game->west_size - 1]);
        break;
    case 'E':
        printf("%c: %c[%d] (%d)\n", letter_player, direction, game->east_size, game->east[game->east_size - 1]);
        break;
    case 'S':
        printf("%c: %c[%d] (%d)\n", letter_player, direction, game->south_size, game->south[game->south_size - 1]);
        break;
    default:
        break;
    }
}

void play(struct Game *game, int depth)
{
    //variable for current player (A or B)
    int player = 0;

    //until all chips are taken, alternate players taking chips
    while (game->north_size > 0 || game->west_size > 0 || game->east_size > 0 || game->south_size > 0)
    {
        //player A
        if (player == 0)
        {
            //function on the selection of a token
            char direction = minimax(game, depth, 0, INT_MIN, INT_MAX);
            print_progress(game, player, direction);
            //remove the token from the game
            remove_token(game, player, direction);
        }
        //player B
        else
        {
            //function on the selection of a token
            char direction = minimax(game, depth, 1, INT_MIN, INT_MAX);
            print_progress(game, player, direction);
            //remove the token from the game
            remove_token(game, player, direction);
        }

        //switch players
        player = (player + 1) % 2;
    }
}
int main(void)
{
    //field for token values
    int north[MAX_TOKENS], west[MAX_TOKENS], east[MAX_TOKENS], south[MAX_TOKENS];
    //sizes of token value fields
    int north_size = 0, west_size = 0, east_size = 0, south_size = 0;
    printf("Input:\n");
    //fetch token values ​​from input
    read_tokens(north, west, east, south, &north_size, &west_size, &east_size, &south_size);

    //creating a game
    struct Game game;
    game.north = north;
    game.west = west;
    game.east = east;
    game.south = south;
    game.north_size = north_size;
    game.west_size = west_size;
    game.east_size = east_size;
    game.south_size = south_size;
    game.score_a = 0;
    game.score_b = 0;
    //set the maximum depth of the minimax search tree
    int depth = 1;
    //start the game using the play() function
    play(&game, depth);

    //evaluation of the result of the game

    printf("Celkem A/B: %d/%d\n", game.score_a, game.score_b);

    return 0;
}

Answer 1

这不是答案。 不过，OP 确实要求提供“提示”。 这里有一些：

1. 不要为您可以/应该实现的单个函数 ( fmax() ) 拖入浮点库 (math.h)，尤其是在处理整数值和结果时。

这里有两个“无分支”语句返回两个整数的最小值或最大值：i & j。

int minVal = j ^ ((i^j) & -(i<j));
int maxVal = j ^ ((i^j) & -(i>j));

2. 您可以安全地从数据文件中删除END 。 fgets()会找到 4 行，然后返回 NULL，完成初始值的加载。

3. 就目前而言，初始值是单个 ASCII 数字。 而不是调用atoi() ，仅从每个 ASCII 数字中减去 ASCII 字符'0'将产生预期的（二进制）整数值。 （您可能会考虑在初始数据中使用“A”-“Z”，而不是“0”-“9”，以增加得分范围并掩盖赢得比赛的最佳途径。

3a) 数据文件可以包含“N1564”而不是“N:1,5,6,4”，从而避免使用strtok() ... 只需按顺序使用每个字符。

4. 作为初学者，您已经编写了涉及 4 个罗盘点的“文字”游戏，这是完全可以理解的。 您编写的代码很难更改为有 5 个或 6 个（或更多）“堆栈”值可供选择。

如果您使用的不是名为“north...”、“west...”等的离散变量，而是使用一个包含 4 个元素的数组，那么大多数使源代码大小膨胀的复制/粘贴/改编都会融化循环处理 4 个（或 5 个或 6 个）“堆栈”中的每一个。 imo，编码的艺术正在平衡“使某些东西工作”的动力与尽可能重用代码的必要性。 寻找冗余并努力消除它。

5. 在fgets()填满输入缓冲区后，您的代码消除了尾随的 '\n'。 然后，您继续将字符数组转换为离散整数值数组。 然后，minimax 函数在玩游戏时递归地修剪这些数组的副本。

考虑保留并使用原始字符数组（字符串）。 当“用户”选择最后一个“字符”（堆栈顶部）作为他们的“移动”时，只需缩短该堆栈的字符串即可。 （使用 C 的string.h字符串处理功能，而不是使用您自己的整数数组自己完成工作。）（字符串""没有更多可用标记。您的代码不需要为每个“方向”维护一个计数器。 )

6. （这可能是最简单的。）当你开始使用 4 个数组时——“N”、“W”、“E”和“S”中的每一个——你会发现罗盘点的固定让你看不到使用“A”、“B”、“C”和“D”代替...鉴于“ABCD”的“非特殊”性质，编写适用于“ABCDE”或“ABCDEF”的代码成为目标”。

简介： 通过用重复使用的代码替换复制的代码，您的程序将缩小到易于管理的程度。 当功能被重新使用并成为“通用”时，您将可能能够改进 minimax 处理。 花在寻找这些“改进”上的时间将得到丰厚的回报。

把我的钱放在嘴边，下面是 OP 发布的 59 行函数之一的 28 行版本。 这仍然为每个“罗盘方向”使用离散变量。 如果将它们捆绑到一个数组中，这也可以再写成 1/2 的行数。

void remove_token( struct Game *game, int player, char direction ) {
    int *arr, arr_sz;

    //according to the direction, remove the token and add its value to the player's score
    switch( direction ) {
        case 'N':
            arr = game->north;
            arr_sz = --game->north_size;
            break;
        case 'W':
            arr = game->west;
            arr_sz = --game->west_size;
            break;
        case 'E':
            arr = game->east;
            arr_sz = --game->east_size;
            break;
        case 'S':
            arr = game->south;
            arr_sz = --game->south_size;
            break;
    }

    //add the chip value to the player's score
    if (player == 0)
        game->score_a += arr[ arr_sz ];
    else
        game->score_b += arr[ arr_sz ];
}