使用 C 中的结构返回多个极小极大值 [score, x, y]

问题描述

我的代码中的问题在于极大极小算法，更具体地说是返回值。我目前用 C++ 编写的解决方案如下，使用元组，返回分数，x 和 y 位置。 我决定使用 struct 在 C 中做类似的事情。

该算法正确地找到给定当前棋盘位置 [3468] 的所有可能的结束状态，但没有返回正确的下一步移动坐标。

鉴于现在是 X-s 轮，我们应该从函数中得到 [score = 0,x = 0,y = 1]。当前返回值为 [score = 1,x = 1,y = 0]。

我应该如何正确实现结构以使算法正常工作？

#include <stdio.h>

int s = 3; //Board size
int cnt = 0;
char player = 'X',opponent = 'O';

struct Best {
  int score,x,y;
};

void printBoard(char v[][s]);
char eval(char v[][s]);
struct Best miniMax(char Table[][s],int depth,bool isMaximising); //Problem: structs?

int main(int argc,char const *argv[]) {
  char b[3][3] = {
    {'X','_','_'},{'_','O','_'}
  };
  printBoard(b);

  struct Best s = miniMax(b,true);
  printf("Possible games: %d\n",cnt);
  cnt = 0;
  printf("Score: %d,Best move: [%d][%d]\n",s.score,s.x,s.y);

  return 0;
}
void printBoard(char v[][s]){
  for (size_t i = 0; i < s; i++){
    for (size_t j = 0; j < s; j++){
      printf("%c|",v[i][j]);
    }
    printf("\n");
  }
  printf("\n");
}
char eval(char v[][s]){
  for (size_t i = 0; i < s; i++) {
    if (v[i][0] == v[i][1] && v[i][1] == v[i][2] && v[i][0] != '_') //Row
    return v[i][0];
    if (v[0][i] == v[1][i] && v[1][i] == v[2][i] && v[0][i] != '_') //Col
    return v[0][i];
  }
  if (v[0][0] == v[1][1] && v[1][1] == v[2][2] && v[0][0] != '_') //Diag
  return v[0][0];

  if (v[0][2] == v[1][1] && v[1][1] == v[2][0] && v[0][2] != '_') //Diag2
  return v[0][2];

  for (size_t i = 0; i < s; i++) {
    for (size_t j = 0; j < s; j++) {
      if (v[i][j] == '_')
      return '\0';
    }
  }
  return '=';
}

这是 C 中存在问题的 miniMax 函数实现：

struct Best miniMax(char Table[][s],bool isMaximising) {
  struct Best v;
  char result = eval(Table);
  if (result == 'X') {
    cnt++;
    v.score = 1;
    v.x = 0;
    v.y = 0;
    return v;
  }
  if (result == 'O') {
    cnt++;
    v.score = -1;
    v.x = 0;
    v.y = 0;
    return v;
  }
  if (result == '=') {
    cnt++;
    v.score = 0;
    v.x = 0;
    v.y = 0;
    return v;
  }
  if (isMaximising) {
    int bestScore = -100;
    for (size_t i = 0; i < s; i++) {
      for (size_t j = 0; j < s; j++) {
        if (Table[i][j] == '_') {
          Table[i][j] = player;
          v = miniMax(Table,depth + 1,false);
          if (v.score > bestScore) {
            bestScore = v.score;
            v.score = bestScore;
            v.x = i;
            v.y = j;
          }
          Table[i][j] = '_';
        }
      }
    }
    return v;
  } else {
    int bestScore = 100;
    for (size_t i = 0; i < s; i++) {
      for (size_t j = 0; j < s; j++) {
        if (Table[i][j] == '_') {
          Table[i][j] = opponent;
          v = miniMax(Table,true);
          if (v.score < bestScore) {
            bestScore = v.score;
            v.score = bestScore;
            v.x = i;
            v.y = j;
          }
          Table[i][j] = '_';
        }
      }
    }
    return v;
  }
}

在 C++ 中的实现：

#include <tuple>
#include <iostream>
using namespace std;

tuple <int,int,int> Minimax(char Board[][s],bool isMaximising){
  char res = eval(Board);

  if (res == 'X') {
    cnt++;
    return {1,0};
  }
  if (res == 'O') {
    cnt++;
    return {-1,0};
  }
  if (res == '=') {
    cnt++;
    return {0,0};
  }

  if (isMaximising) {
    int bestScore = -100;
    int px = 0,py = 0;
    for (size_t i = 0; i < s; i++) {
      for (size_t j = 0; j < s; j++) {
        if (Board[i][j] == '_') {
          Board[i][j] = player;
          auto [score,y] = Minimax(Board,false);
          if (score > bestScore) {
            bestScore = score;
            px = i;
            py = j;
          }
          Board[i][j] = '_';
        }
      }
    }
    return {bestScore,px,py};
  } else {
    int bestScore = 100;
    int qx = 0,qy = 0;
    for (size_t i = 0; i < s; i++) {
      for (size_t j = 0; j < s; j++) {
        if (Board[i][j] == '_') {
          Board[i][j] = opponent;
          auto [score,true);
          if (score < bestScore) {
            bestScore = score;
            qx = i;
            qy = j;
          }
          Board[i][j] = '_';
        }
      }
    }
    return {bestScore,qx,qy};
  }
}

解决方法

基本问题是，每次 miniMax 递归调用自身时，它都会用返回值覆盖 v，从而丢失任何早期迭代中保存的最佳值。所以你总是从最后一个测试位置得到 x/y，而不是找到最好的位置。

添加一个新的 struct Best best 值，该值是您在发现更好的移动时更新和返回的值。请注意，您也不需要 bestScore 本地 - 您可以使用 best.score