再看极大极小搜索与负极大值搜索

最新推荐文章于 2018-09-18 23:12:00 发布
最新推荐文章于 2018-09-18 23:12:00 发布
阅读量808 收藏 4
点赞数
文章标签： NegaSearch
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cprimesplus/article/details/81355091
版权

前两天写了关于极大极小搜索的文章，实际还是不够深入，而且有一定偏差。经过这两天的思考之后打算另写一篇来说一下我对极大极小搜索的的进一步理解(以井字棋为例)。
在这之前，首先值得注意的一点是，如果说我将初始深度赋值为9并作为参数传到函数中，并且目的是让函数一层层递归直到最后一步棋，那么我的函数传参如下:
MaxMinSearch ( Depth )——–Depth>0
可以看出，函数就是从根节点向叶子节点进行的，也就是从上向下深度依次递减，直到第Depth层深度为0为止。类比于DFS的标记数组visit变为1，井字棋也将走过的地方依次标记（虽然最后也会撤回），总在未走过的棋盘格中找最好最坏情况。就像是利用递归的方法求fib数列（虽然不太好），递归函数会被依次压栈，最后从栈底依次弹出并计算。这样，对于电脑这一方来说，上一层总会得到下一层传来的几个极小值，而电脑则会在这中间挑选出最大值。对于玩家来说则正好相反。
我们不能让递归无休止的进行下去，那么满足以下两种条件时势必会退出：
1.基于玩家和电脑全是各自的最好招法时，很有可能还未下满棋盘便已经分出胜负，那么当前层次的递归就无需再向下进行了，此时只需要根据下棋者是电脑还是玩家，直接对应的返回INT_MAX还是 –INT_MAX即可。

    if (COMPUTER == isEnd() || MANAGER == isEnd())
        return Evaluate();

2.如果玩家和电脑交替下棋到了最后一层，也要做出相应的评估（输 赢 平局）。

    if (depth == 0)
        return Evaluate();

极大极小搜索的评估函数：

int Evaluate()
{
    int count = 0;
    if (isEnd() == COMPUTER)    
        return INT_MAX;
    if (isEnd() == MANAGER)     
        return -INT_MAX;
    return count;
}

对于极大极小搜索：
引用一段话：我们把电脑方的价值总和叫做CpValue，对手方价值总和叫做OpValue，那么一个局面的估值Value就是电脑方和对手方的价值差。表达如下式：Value=CpValue-OpValue
这个Value也就是最终返回给搜索引擎的估值。
在基本的极大极小搜索的过程里估值的取得是和上式完全契合的，即无论任何时候取估值均由固定一方的值减去另一方的值。由于井字棋棋路简单，落子之后情况无非（输 赢 平）三种，因此当落子到一个地方之后，如果电脑赢。那么返回的值CpValue-OpValue应该是最大值，否则就是最小值。

负极大搜索的评估函数：

int Evaluate()
{
    int count = 0;
    if (isEnd() == COMPUTER)    
        return INT_MAX*player;
    if (isEnd() == MANAGER)     
        return -INT_MAX*player;
    return count;
}

对于负极大搜索：当前下棋者是电脑还是玩家对于结果来说是敏感的。
“原来在极大极小搜索算法中始终返回的是红方的优势，现在要改为当前走棋方的优势。”
对于赢家是电脑这一情况，如果当前下棋者就是电脑的话，那么显然这个落子点是理想的，因此返回的是正最大值；如果当前下棋者是玩家的话，那么这一点对于玩家来说就是很差劲的，因此返回负最大值。

附上负极大搜索的代码：

#include<stdio.h>
#include<windows.h>
typedef struct position {
    int x;
    int y;
}POS;   //坐标结构体
#define N 3
#define STEP 9
#define COMPUTER 1
#define MANAGER -1
int CurrentDepth;
int player;
int chess[N][N];
int TempChess[N][N];    //虚拟的chess
int isEnd();
int Evaluate();
int CountBlank(POS SaveBlank[STEP]);
int MaxMinSearch(int depth);
void SetChess(POS MarkPos);
void RemoveChess(POS MarkPos);
void InitBoard();   //初始化边界
void WhoPlayFirst();
void ManPlay();
void ComPlay();
void DrawBoard();
POS BestPosMark;
int main()
{
    int step = 0;
    CurrentDepth = STEP - 1;
    InitBoard();
    WhoPlayFirst();
    if (player == MANAGER)
    {
        for (step = 1;step <= STEP;)
        {
            ManPlay();
            DrawBoard();
            if (isEnd() == MANAGER)
            {
                printf("\n恭喜您战胜电脑！\n");
                system("pause");
                return 0;
            }
            step++;
            CurrentDepth--;
            if (CurrentDepth == -1)
            {
                printf("\n平局了！\n");
                system("pause");
                return 0;
            }
            player = (player == COMPUTER) ? MANAGER : COMPUTER;
            ComPlay();
            DrawBoard();
            if (isEnd() == COMPUTER)
            {
                printf("\n很遗憾，电脑战胜了您！\n");
                system("pause");
                return 0;
            }
            step++;
            CurrentDepth--;
            if (CurrentDepth == -1)
            {
                printf("\n平局了！\n");
                system("pause");
                return 0;
            }
            player = (player == COMPUTER) ? MANAGER : COMPUTER;
        }
    }
    if (player == COMPUTER)
    {
        for (step = 1;step <= STEP;)
        {
            ComPlay();
            DrawBoard();
            if (isEnd() == COMPUTER)
            {
                printf("\n很遗憾，电脑战胜了您！\n");
                system("pause");
                return 0;
            }
            step++;
            CurrentDepth--;
            if (CurrentDepth == -1)
            {
                printf("\n平局了！\n");
                system("pause");
                return 0;
            }
            player = (player == COMPUTER) ? MANAGER : COMPUTER;
            ManPlay();
            DrawBoard();
            if (isEnd() == MANAGER)
            {
                printf("\n恭喜您战胜电脑！\n");
                system("pause");
                return 0;
            }
            step++;
            CurrentDepth--;
            if (CurrentDepth == -1)
            {
                printf("\n平局了！\n");
                system("pause");
                return 0;
            }
            player = (player == COMPUTER) ? MANAGER : COMPUTER;
        }
    }
    return 0;
}
void DrawBoard()
{
    int i, j;
    for (i = 0;i < N;i++)
    {
        printf("-------------\n");
        for (j = 0;j < N;j++)
        {
            if (chess[i][j] == COMPUTER)
                printf("| X ");
            else if (chess[i][j] == MANAGER)
                printf("| O ");
            else
                printf("|   ");
        }
        printf("|\n");
    }
    printf("-------------\n");
}
int isEnd()
{
    int i, j;
    int count = 0;
    for (i = 0;i < N;i++)   //行
    {
        count = 0;
        for (j = 0;j < N;j++)
            count += chess[i][j];
        if (count == 3 || count == -3)
            return count / 3;
    }
    for (j = 0;j < N;j++)   //列
    {
        count = 0;
        for (i = 0;i < N;i++)
            count += chess[i][j];
        if (count == 3 || count == -3)
            return count / 3;
    }
    count = 0;
    count = chess[0][0] + chess[1][1] + chess[2][2];
    if (count == 3 || count == -3)
        return count / 3;
    count = chess[0][2] + chess[1][1] + chess[2][0];
    if (count == 3 || count == -3)
        return count / 3;
    return 0;
}
int CountBlank(POS SaveBlank[STEP])
{
    int i, j;
    int count = 0;
    for (i = 0;i < N;i++)
    {
        for (j = 0;j < N;j++)
        {
            if (chess[i][j] == 0)   //若未被占
            {
                SaveBlank[count].x = i;
                SaveBlank[count].y = j;
                count++;
            }
        }
    }
    return count;
}
int Evaluate()
{
    int count = 0;
    if (isEnd() == COMPUTER)    
        return INT_MAX*player;
    if (isEnd() == MANAGER)     
        return -INT_MAX*player;
    return count;
}
void RemoveChess(POS MarkPos)
{
    chess[MarkPos.x][MarkPos.y] = 0;
    player = (player == COMPUTER) ? MANAGER : COMPUTER;
}
void SetChess(POS MarkPos)
{
    chess[MarkPos.x][MarkPos.y] = player;
    player = (player == COMPUTER) ? MANAGER : COMPUTER;
}
int MaxMinSearch(int depth)
{
    int BestValue = 0;
    int Value = 0;
    int i, count = 0;
    POS SaveBlank[STEP];
    if (COMPUTER == isEnd() || MANAGER == isEnd())
        return Evaluate();
    if (depth == 0)
        return Evaluate();
    BestValue = -INT_MAX;
    count = CountBlank(SaveBlank);
    for (i = 0;i < count;i++)
    {
        POS MarkPos = SaveBlank[i];
        SetChess(MarkPos);
        Value = -MaxMinSearch(depth - 1);
        RemoveChess(MarkPos);
        if (Value > BestValue)
        {
            BestValue = Value;
            if (depth == CurrentDepth)
            {
                BestPosMark = MarkPos;
            }
        }
    }
    return BestValue;
}
void ComPlay()
{
    MaxMinSearch(CurrentDepth);
    printf("\n电脑落子的位置为：(%d,%d)\n", BestPosMark.x + 1, BestPosMark.y + 1);
    chess[BestPosMark.x][BestPosMark.y] = COMPUTER;
}
void ManPlay()
{
    POS man;
    printf("\n请输入您的落子位置:\n");
    scanf("%d %d", &man.x, &man.y);
    man.x--;
    man.y--;
    if (chess[man.x][man.y] || man.x<0 || man.x >= N || man.y<0 || man.y >= N) {
        printf("输入位置有误，请重新输入！");
        ManPlay();
        return;
    }
    chess[man.x][man.y] = MANAGER;
}
void InitBoard()
{
    int i, j;
    for (i = 0;i < N;i++)
        for (j = 0;j < N;j++)
            TempChess[i][j] = chess[i][j] = 0;
}
void WhoPlayFirst()
{
    char ch;
    printf("欢迎试玩AI井字棋，请选择您的落子先后：1---先手 2---后手\n");
    ch = getchar();
    player = (ch == '1') ? MANAGER : COMPUTER;
}
摩霄志在潜修羽
关注
专栏目录
算法设计——极大极小搜索
如果这是你所爱的，要坚持，并踏实。
08-13 9614
极大极小搜索策略一般都是使用在一些博弈类的游戏之中：这样策略本质上使用的是深度搜索策略，所以一般可以使用递归的方法来实现。在搜索过程中，对本方有利的搜索点上应该取极大值，而对本方不利的搜索点上应该取极小值。极小值和极大值都是相对而言的。在搜索过程中需要合理的控制搜索深度，搜索的深度越深，效率越低，但是一般来说，走法越好。极大极小搜索可以分开写，也可以放在一起写。主要的算法步骤如下：1、根据side确定如何初始化best值。2、如果当前深度为0，则调用局面评估函数，返回评估值。（评估函数是根据具体问题设计的）
中国象棋人机对弈搜索算法学习-极大极小值，负极大值，alpha-beta算法
master-dragon的专栏
04-07 1万+
先参考学习如下博文： http://blog.csdn.net/kingkong1024/article/details/7639401 http://hk.gamfe.com/news/201502/2170.html 参考图书《PC游戏编程（人机博弈）》极大极小值法深度搜索（dfs）伪代码/** 1。 p 为棋盘 2。 d 为规定的搜素最大深度，比如d层红方，d-1层为黑方，d-2层为红方
负极大值搜索
V的博客
05-21 1689
Alpha-Beta搜索需要遍历的节点远远少于极大极小算法所遍历的节点: 在任何一层都只进行beta剪枝，它会同负极大值算法一样简洁：   int  alphabeta(int nPlay,int alpha,int beta)   {       if(Game over)               return eval();   //胜负已分，返回估值       if(nPl
负极大值搜索引擎
V的博客
05-21 464
//alphabeta的过程 //depth是当前搜索距离叶子点的层数 //alpha是搜索的上边界 //beta是搜索的下边界 int  CAlphaBetaEngine::alphabeta(int depth,int alpha,int beta){      int score;      int Count,i;      BYTE  type;      i=IsGam
博弈基础——极大极小搜索
热门推荐
大田二十
03-05 2万+
博弈基础
QT五子棋详解之八：min-max优化的负极大值算法兼谈qt内存泄露
weixin_39788534的博客
03-12 1947
负极大值搜索作为min-max博弈算法的优化，其本质上没有任何区别。负极大值搜索它的效率也不会快多少，只是它的代码更加优雅简洁。更好进行代码的移植。我们将min-max博弈算法与负极大值算法的伪代码发出来比较一下。不加那个剪枝的int MinMax(int depth) { if (SideToMove() == WHITE) {　// 白方是“最大”者 return Max(depth); }...
极大极小搜索
whhhzs的博客
11-21 475
 Problem A Problem A 极大极小搜索 时限：1000ms 内存限制：10000K 总时限：3000ms 描述： 搜索n层，第一层取最大值，先输入两个整数n、randseed，用randseed设置随机数种子。 搜索时每层4个分支，能不能想这个分支走用函数canmoveto()判断，内容如下： int canmoveto(int m, int d
基于负极大值搜索的五子棋（C#版）
03-19
人工智能课上的实验，采用负极大值搜索方法，能向前预测2步，基于VS2008的项目。
Gobang-ai:极大极小搜索和α-β剪枝的无禁手ai
05-11
Gobang-ai 极大极小搜索和α-β剪枝的无禁手ai，深度可达8层。 添加了简单的算杀模块。 我写了较为详细的教程。算杀的思想我可能理解有点问题，还有一些小bug，后续应该还会修改。
gobang（极小极大搜索算法）
07-26
NULL 博文链接：https://sjl599.iteye.com/blog/673452
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法）
06-23
人工智能下五子棋（基于博弈树极大极小值alpha-beta剪枝搜索算法），代码解析链接参见网址：https://blog.csdn.net/m0_38106923/article/details/93347117
poj1568 极大极小搜索
浅空之下
12-20 3010
问题：给出一个4x4 tic-tac-toe 的棋局的局面，问先手 "x" 是不是能找在接下来的一步中 找到一个必胜局面，如果有，输出第一个落子位置（按顺序）。 极大极小搜索策略一般都是使用在一些博弈类的游戏之中：  这样策略本质上使用的是深度搜索策略，所以一般可以使用递归的方法来实现。在搜索过程中，对本方有利的搜索点上应该取极大值，而对本方不利的搜索点上应该取极小值。  极小值和
极大极小搜索和α-β剪枝
weixin_30824599的博客
09-18 200
极小极大算法常用于二人博弈游戏，目的是寻找最优的方案使得自己能够利益最大化。基本思想就是假设自己（A）足够聪明，总是能选择最有利于自己的方案，而对手（B）同样足够聪明，总会选择最不利A的方案。 CS 161 Recitation Notes - The Minimax Algorithm Alpha-Beta剪枝用于裁剪搜索树中没有意义的不需要搜索的树枝，以提高运算速度。 转载于:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值