Minimax 与 Alpha-beta 剪枝,得到结果

发布于 2024-12-12 03:22:02 字数 1575 浏览 0 评论 0原文

我已经遵循了维基百科文章上的 pseducode,我想我已经成功了。然而,它会返回分数,当我想知道我想要采取什么行动时,这并没有多大帮助。

我尝试了我认为是获得最佳走法的方法,但我认为它不起作用,因为当我实际尝试与它对战(国际象棋)时,AI 会做出一些深度为 3 的迟缓走法。

这是我的功能:

public static function alphaBeta(node, depth, alph, beta, team, tellTheMove:Boolean = false):* {
        var pointer:ChessMove;
        if (depth == 0) {
            return scoreOf(node);
        }
        var childrenOf:Vector.<ChessMove >  = returnPossibleMoves(node,team);
        if (childrenOf.length == 0) {
            return scoreOf(node);
        }
        if (team == 0) {
            for (var i in childrenOf) {
                var that:Number = alphaBeta(childrenOf[i],depth - 1,alph,beta,1);
                if(tellTheMove){
                }
                if (that > alph) {
                    alph = that;
                    if(tellTheMove){
                        pointer = childrenOf[i];
                    }
                }
                if (beta <= alph) {
                    break;
                }
            }
            if(tellTheMove){
                return pointer; //Returns the move that's score last exceeded alpha.
            }
            return alph;
        } else {
            for (var j in childrenOf) {
                var that2:Number = alphaBeta(childrenOf[j],depth - 1,alph,beta,0);
                if (that2 < beta) {
                    beta = that2;
                }
                if (beta <= alph) {
                    break;
                }
            }
            return beta;
        }
    }

I have followed the pseducode on the wikipedia article, and I think I got it working. However, it returns the score, and that doesn't exactly help when I want to know what move I want to make.

I tried what I think would be a way to get the best move, but I don't think it is working as when I actually try to play against it (chess), the AI makes somewhat retarded moves with a depth level of 3.

Here is my function:

public static function alphaBeta(node, depth, alph, beta, team, tellTheMove:Boolean = false):* {
        var pointer:ChessMove;
        if (depth == 0) {
            return scoreOf(node);
        }
        var childrenOf:Vector.<ChessMove >  = returnPossibleMoves(node,team);
        if (childrenOf.length == 0) {
            return scoreOf(node);
        }
        if (team == 0) {
            for (var i in childrenOf) {
                var that:Number = alphaBeta(childrenOf[i],depth - 1,alph,beta,1);
                if(tellTheMove){
                }
                if (that > alph) {
                    alph = that;
                    if(tellTheMove){
                        pointer = childrenOf[i];
                    }
                }
                if (beta <= alph) {
                    break;
                }
            }
            if(tellTheMove){
                return pointer; //Returns the move that's score last exceeded alpha.
            }
            return alph;
        } else {
            for (var j in childrenOf) {
                var that2:Number = alphaBeta(childrenOf[j],depth - 1,alph,beta,0);
                if (that2 < beta) {
                    beta = that2;
                }
                if (beta <= alph) {
                    break;
                }
            }
            return beta;
        }
    }

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

维持三分热 2024-12-19 03:22:02

对于像国际象棋这样的问题,深度 3 很小。在这个深度,大部分能力取决于您的最终评估函数。这种评估功能很难有效地预测董事会的价值。

尝试一些更简单的事情,可以在较低的深度下有效地解决。 Tic-Tac-Toe 是一款非常适合初次尝试最小最大游戏的游戏。因为最终的结果是众所周知的。如果你的算法正确,你根本就无法击败它。如果你玩井字棋并且算法输了,你就知道你犯了一个错误。

另请注意,在某些情况下,最小-最大发挥最佳效果,但对于人类对手来说仍然显得迟钝。例如,如果没有获胜的机会,最小-最大将开始随机玩并做出非常愚蠢的动作。情况确实如此,因为 Min-Max 期望对手也能发挥完美,而人类通常不会出现这种情况。可以对算法进行一些简单的更改来改变这种行为,并在这种情况下让最小-最大播放“不那么迟缓”。

Depth 3 is very little for a problem like chess. At this depth most of the power depends on your final evaluation function. This evaluation function is very hard to do in way that it can predict the value of the board efficiently.

Try something simpler, which can be solved efficiently at a lower depth. Tic-Tac-Toe is a very good game for a first attempt at Min-Max. This is because the final outcome is well known. If you get your algorithm correctly you should not be able to beat it at all. If you do Tic-Tac-Toe and the algorithm is loosing, you know that you have a mistake.

Also note that in some cases Min-Max plays optimal, but still will look retarded to a human opponent. For example if there is no chance at winning, Min-Max will start to play randomly and do very dumb moves. This is the case , because Min-Max expects the opponent to also play perfect, which is usually not the case with humans. There are some simple changes that can be done to the algorithm to change this behavior and have min-max play "less retarded" in such cases.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文