回溯算法--三连游戏（人机对战）

最新推荐文章于 2022-07-12 17:45:33 发布
最新推荐文章于 2022-07-12 17:45:33 发布
阅读量529 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blubluhao/article/details/77532170
版权

　　程序的核心部分在于计算机如何选择下棋的位置。采用的策略叫作极小极大策略。通过一个赋值函数来给一个位置的“好坏”定值。能使计算机获胜的位置得到值+1；平局得到0；使计算机输棋的位置得到值-1。通过考察盘面就能够确定输赢的位置叫作终端位置。

　　如果一个位置不是终端位置，那么该位置的值通过递归假设双方最优棋步而确定。这叫做极小极大策略，因为下棋的一方（人）试图极小化这个位置的值，而另一方（计算机）却要使它的值达到极大。

　　采用数组下标1-9代表九个格子，随机生成一个数来确定先手。如果计算机先手，因为此时盘面处于平局，计算机总会选择第一个位置，所以随机生成一个位置给计算机。

头文件

#include <vector>
using namespace std;
class TicTacToe
{
public:

    static const int COMP=1;
    static const int HUMAN=-1;

    TicTacToe():board(10){}

    bool fullBoard()
    {
        for(int i=1;i<=9;++i)
        {
            if(board[i]==0)
                return false;
        }
        return true;
    }
    bool isEmpty(int i)
    {
        if(board[i]==0)
            return true;
        else
            return false;
    }

    void place(int i,int player)
    {
        board[i]=player;
    }

    void unplace(int i)
    {
        board[i]=0;
    }

    bool immediateWin(int & bestMove,int player);


    int findCompMove(int & bestMove);
    int findHumanMove(int & bestMove);

    void setChessPiece(int location,int player);

    void showBoard();

    bool check(int i);

private:

    static const int DRAW=0;
    static const int COMP_WIN=1;
    static const int COMP_LOSS=-1;


    vector<int> board;



};

cpp文件

#include "TicTacToe.hpp"

#include <iostream>
bool TicTacToe::immediateWin(int & bestMove,int player)
{
    for(int i=1;i<=9;++i)
    {
        if(isEmpty(i))
        {
            bool flag=false;
            place(i, player);
            if(i==1)
            {
                if(
                   (board[i]==board[i+1]&&board[i]==board[i+2])
                   ||(board[i]==board[i+3]&&board[i]==board[i+6])
                   ||(board[i]==board[i+4]&&board[i]==board[i+8])
                   )
                {
                    flag=true;
                }

            }
            if(i==2)
            {
                if(
                   (board[i]==board[i+1]&&board[i]==board[i-1])
                   ||(board[i]==board[i+3]&&board[i]==board[i+6])
                   )
                {
                    flag=true;
                }
            }
            if(i==3)
            {
                if(
                   (board[i]==board[i-1]&&board[i]==board[i-2])
                   ||(board[i]==board[i+3]&&board[i]==board[i+6])
                    ||(board[i]==board[i+2]&&board[i]==board[i+4])
                   )
                {
                    flag=true;
                }

            }
            if(i==4)
            {
                if(
                   (board[i]==board[i+3]&&board[i]==board[i-3])
                   ||(board[i]==board[i+2]&&board[i]==board[i+1])
                   )
                {
                    flag=true;
                }

            }
            if(i==5)
            {
                if(
                   (board[i]==board[i+3]&&board[i]==board[i-3])
                   ||(board[i]==board[i-1]&&board[i]==board[i+1])
                   ||(board[i]==board[i-4]&&board[i]==board[i+4])
                   ||(board[i]==board[i-2]&&board[i]==board[i+2])
                   )
                {
                    flag=true;
                }

            }
            if(i==6)
            {
                if(
                   (board[i]==board[i-1]&&board[i]==board[i-2])
                   ||(board[i]==board[i+3]&&board[i]==board[i-3])
                   )
                {
                    flag=true;
                }

            }
            if(i==7)
            {
                if(
                   (board[i]==board[i+1]&&board[i]==board[i+2])
                   ||(board[i]==board[i-6]&&board[i]==board[i-3])
                   ||(board[i]==board[i-2]&&board[i]==board[i-4])
                   )
                {
                    flag=true;                }

            }
            if(i==8)
            {
                if(
                   (board[i]==board[i+1]&&board[i]==board[i-1])
                   ||(board[i]==board[i-6]&&board[i]==board[i-3])
                   )
                {
                    flag=true;
                }

            }
            if(i==9)
            {
                if(
                   (board[i]==board[i-1]&&board[i]==board[i-2])
                   ||(board[i]==board[i-6]&&board[i]==board[i-3])
                   ||(board[i]==board[i-8]&&board[i]==board[i-4])
                   )
                {
                    flag=true;                }

            }

            unplace(i);
            if(flag)
            {
                bestMove=i;
                return true;
            }

        }
    }

    return false;
}

int TicTacToe::findCompMove(int & bestMove)
{
    int i,responseValue;
    int dc;                 //do not care
    int value;

    if(fullBoard())
        value=DRAW;

    else
    {
        if(immediateWin(bestMove, COMP))
            return COMP_WIN;
        else
        {
            value=COMP_LOSS;bestMove=1;

            for(i=1;i<=9;++i)
            {
                if(isEmpty(i))
                {
                    place(i, COMP);
                    responseValue=findHumanMove(dc);
                    unplace(i);
                    if(responseValue>value)
                    {
                        value=responseValue;
                        bestMove=i;
                    }
                }
            }
        }
    }
    return value;

}
int TicTacToe::findHumanMove(int & bestMove)
{
    int i,responseValue;
    int dc;
    int value;

    if(fullBoard())
        value=DRAW;

    else
    {
        if(immediateWin(bestMove, HUMAN))
            return COMP_LOSS;
        else
        {
            value=COMP_WIN;bestMove=1;

            for(i=1;i<=9;++i)
            {
                if(isEmpty(i))
                {
                    place(i, HUMAN);
                    responseValue=findCompMove(dc);
                    unplace(i);
                    if(responseValue<value)
                    {
                        value=responseValue;
                        bestMove=i;
                    }
                }
            }
        }
    }
    return value;

}


void TicTacToe::showBoard()
{
    for(int i=0;i<20;++i)
        cout<<"\n";
    vector<string> out(10);
    for(int i=1;i<=9;++i)
    {
        if(board[i]==0)
            out[i]=' ';
        else if(board[i]==-1)
        {
            out[i]="Ο";
        }
        else
        {
            out[i]="Χ";
        }
    }

    cout<<"________________"<<endl;
    cout<<"| "<<out[1]<<"  | "<<out[2]<<"  | "<<out[3]<<"  |"<<endl;
    cout<<"|    |    |    |"<<endl;
    cout<<"|—-——|—-——|—-——|"<<endl;
    cout<<"| "<<out[4]<<"  | "<<out[5]<<"  | "<<out[6]<<"  |"<<endl;
    cout<<"|    |    |    |"<<endl;
    cout<<"|——-—|—-——|—-——|"<<endl;
    cout<<"|    |    |    |"<<endl;
    cout<<"| "<<out[7]<<"  | "<<out[8]<<"  | "<<out[9]<<"  |"<<endl;
    cout<<"|____|____|____|"<<endl;

}

bool TicTacToe::check(int i)
{
    if(i==1)
    {
        if(
           (board[i]==board[i+1]&&board[i]==board[i+2])
           ||(board[i]==board[i+3]&&board[i]==board[i+6])
           ||(board[i]==board[i+4]&&board[i]==board[i+8])
           )
        {

            return true;
        }

    }
    if(i==2)
    {
        if(
           (board[i]==board[i+1]&&board[i]==board[i-1])
           ||(board[i]==board[i+3]&&board[i]==board[i+6])
           )
        {

            return true;
        }

    }
    if(i==3)
    {
        if(
           (board[i]==board[i-1]&&board[i]==board[i-2])
           ||(board[i]==board[i+3]&&board[i]==board[i+6])
           ||(board[i]==board[i+2]&&board[i]==board[i+4])
           )
        {

            return true;
        }

    }
    if(i==4)
    {
        if(
           (board[i]==board[i+3]&&board[i]==board[i-3])
           ||(board[i]==board[i+2]&&board[i]==board[i+1])
           )
        {

            return true;
        }

    }
    if(i==5)
    {
        if(
           (board[i]==board[i+3]&&board[i]==board[i-3])
           ||(board[i]==board[i-1]&&board[i]==board[i+1])
           ||(board[i]==board[i-4]&&board[i]==board[i+4])
           ||(board[i]==board[i-2]&&board[i]==board[i+2])
           )
        {

            return true;
        }

    }
    if(i==6)
    {
        if(
           (board[i]==board[i-1]&&board[i]==board[i-2])
           ||(board[i]==board[i+3]&&board[i]==board[i-3])
           )
        {

            return true;
        }

    }
    if(i==7)
    {
        if(
           (board[i]==board[i+1]&&board[i]==board[i+2])
           ||(board[i]==board[i-6]&&board[i]==board[i-3])
           ||(board[i]==board[i-2]&&board[i]==board[i-4])
           )
        {

            return true;
        }

    }
    if(i==8)
    {
        if(
           (board[i]==board[i+1]&&board[i]==board[i-1])
           ||(board[i]==board[i-6]&&board[i]==board[i-3])
           )
        {

            return true;
        }

    }
    if(i==9)
    {
        if(
           (board[i]==board[i-1]&&board[i]==board[i-2])
           ||(board[i]==board[i-6]&&board[i]==board[i-3])
           ||(board[i]==board[i-8]&&board[i]==board[i-4])
           )
        {

            return true;
        }

    }
    return false;
}

void TicTacToe::setChessPiece(int location,int player)
{
    if(location>0&&location<10&&isEmpty(location))
    {
        board[location]=player;
    }
    else
    {
        cout<<"try again";
        cin>>location;
        setChessPiece(location, player);
    }
}

main.cpp

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include "TicTacToe.hpp"
using namespace std;
int main()
{
    TicTacToe board;
    board.showBoard();
    int move;

    srand((unsigned)time(NULL));
    bool turn=rand()%2;             //决定先手

    if(turn==0)
    {
        sleep(1.5);
        move=rand()%9+1;            //随机选择一个位置
        board.setChessPiece(move, board.COMP);
        board.showBoard();
        turn=1;
    }
    else
    {
       cout<<"Human First";
    }
    while (1)
    {
        if(turn)
        {
            cin>>move;

            board.setChessPiece(move, board.HUMAN);
            turn=0;
        }
        else
        {
            sleep(1.5);
            board.findCompMove(move);
            board.setChessPiece(move, board.COMP);
            turn=1;
        }

        board.showBoard();

        if(board.check(move))
        {
            if(!turn)
                cout<<"human win"<<endl<<endl;
            else
                cout<<"computer win"<<endl<<endl;
            return 0;
        }
        if(board.fullBoard())
        {
            cout<<"draw"<<endl<<endl;
            return 0;

        }

    }
    return 0;
}

结果


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述


这里写图片描述

EmberWn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
五子棋人机对战 图解 算法举例
07-26
完整代码没有，不过文档里带有人机对战算法分析，附有图解及关键算法有举例分析，这片文章对一些为五子棋人机对战算法无头绪的人来说，绝对是个好东西
第十章回溯算法(三连棋，极大极小值，α-β剪枝)
保持热爱，持续学习
05-02 444
博弈树：在进行游戏时，双方轮流选择，每次执行一个步骤。所有可能的步骤就构成了一棵博弈树。 终端位置：通过考察盘面能够确定这局棋输赢的位置。如果一个位置不是终端位置那么该位置的值通过递归地假设双方最优棋步而确定的。 极小极大策略：极小极大策略常用于二人博弈游戏，目的是寻找最优的方案使得自己能够利益最大化。 基本思想就是假设博弈的双方都足够聪明，一方总是能选择最有利于自己的方案，使得自己胜率值极大，而另一方总会选择最不利对手的方案，使得对手的胜率值极小。 对于计算机下棋，一个最重要的因素看来是程序能够向前看的棋
人工智能-三连子游戏设计和实现
qq_32691667的博客
07-18 834
这算是我编写的第一个带点智能的程序了，虽然学编程这么久了。。。。。。 本篇文章就是记录一个三连子游戏的理论、设计、实现的全部过程和思路，（五子棋 四连子 井字棋都差不多，三连子更简单一点，方便理解） 理论 我是最开始是通过人工智能 一种现代的方法第三版 这本书接触到这方面的知识的，然而书上讲解的不甚详细，还参考了网络上其他讲解这部分理论的文章 其他写的比较好的文章汇总：五子棋入门级AI的设计与实现 博弈游戏的AI设计（一）：极大极小树 五子棋AI算法第四篇-启发式搜索函数 我总结下来就是极大极小值算法通过
基于qt实现的三连棋（井字棋）游戏（含AI算法）
07-23
基于qt实现的三连棋，包括初始界面，有人机对战和双人对战，人机对战采用min-max搜索来实现，代码量较小，适合新手学习。
五子棋（人机）-极大极小值搜索算法
热门推荐
脚踏实地，仰望星空
09-20 1万+
从人落子开始到出现胜负或者和局，之间所落的子，构成了一个解。而解空间就是一个树，解就是这解空间中的一条路径。只不过这个解空间是电脑的选择和人的选择共同构成的（奇数层是电脑（因为轮到电脑落子么），偶数层是人）。 极大极小值搜索算法，来搜索（回溯）这个解空间：它假设人和电脑都是极其聪明的，他们都会选择出最优的一步。 但是搜索整棵树是不现实的，16*16！指数级，所以只回溯n步，即这个AI考虑的是N
基于α-β剪枝python实现五子棋人机对战pygame
02-22
制作一个五子棋小游戏，实现人机对战，其中电脑在进行极大值极小值搜索时需要运用α-β剪枝算法。五子棋小游戏的核心是电脑端走步的选取，使用的方法是极大极小值搜索，并且题目要求使用α-β剪枝来提高搜索效率；除...
alpha-beta剪枝算法实现中国象棋人机对战
11-05
使用alpha-beta剪枝算法实现中国象棋人机对战，AI具有中级的智能，可以应对一般的象棋爱好者。
Cocos2d-x人机对战五子棋游戏
06-11
Cocos2d-x 人机对战五子棋游戏 跨平台 支持 iOS 安卓 Win32
五子棋-智能算法-C#源码-人机对弈-原创
04-20
个人原创，五子棋智能算法，C#源码，基于.netframework4.6，支持人机对弈，实力强劲
五子棋（人机对战版+禁手算法-2019-04-011）.zip
12-24
这是一个简单的五子棋游戏,可以实现人机对战,选择谁先下,谁后下.代码有不错的界面,可以实现基本的功能
五子棋人机对战算法分析
06-11
五子棋人机对战算法分析，主要分析下人机对战时怎么让电脑更加智能化
Python基于回溯法子集树模板解决马踏棋盘问题示例
01-21
本文实例讲述了Python基于回溯法子集树模板解决马踏棋盘问题。分享给大家供大家参考，具体如下： 问题 将马放到国际象棋的8*8棋盘board上的某个方格中，马按走棋规则进行移动，走遍棋盘上的64个方格，要求每个方格进入且只进入一次，找出一种可行的方案。 分析 说明：这个图是5*5的棋盘。 类似于迷宫问题，只不过此问题的解长度固定为64 每到一格，就有[(-2,1),(-1,2),(1,2),(2,1),(2,-1),(1,-2),(-1,-2),(-2,-1)]顺时针8个方向可以选择。 走到一格称为走了一步，把每一步看作元素，8个方向看作这一步的状态空间。 套用回溯法子集树模板。 代码
五子棋人机对战设计
weixin_33834679的博客
12-05 454
一、人机对战算法概述 人机对战属于一种弱人工智能算法，其核心是：当玩家落下一枚棋子后，计算出这枚棋子构成的所有棋型，找出威胁程度最大的棋型，并破解其产生的威胁。 五子棋中所能产生的棋型有很多，如果棋子至少有一边被封死，这种棋型被称为“死”棋型，反之被称为“活”棋型。根据棋子的数量，棋型又可以细化为“活三”、“死三”、“活四”等不同的棋型。棋型的不同，产生的威胁程度不同，破解的方式也不同。以四枚...
[原创]五子棋人机对弈算法设计
程序的江湖？！ 勿在浮砂筑高台！
08-19 7509
人机对弈算法属于策略型人工智能算法，本游戏中设置了人机对弈的游戏模式，其算法如下：1，  设置所有获胜组合，获胜表将可能出现的获胜组合存入计算机中，计算机根据此组合判断玩家或计算机是否胜利。例如：10×10的棋盘的获胜组合如下图：  得出棋局可能出现的获胜组合，此组合用于后期设计AI对弈。           最后，将所有的获胜组合存入一个数组中，即形成获胜表。例如：A[1][1][2]表明A的位
数据结构——人机对弈（minimax、negamax、alpaha-beta剪枝算法）
m0_66821676的博客
07-12 1518
自行学习和研究了人工智能入门的这三种算法，供自己日后复习
人机对战五子棋(权值法)
hnu_Cheng的博客
11-12 8828
前面介绍了监听机制，窗体使用，重绘机制，画笔使用，对象传递等等概念，接下来我们来谈一点算法的东西
生成迷宫并找出走出迷宫的路径
blubluhao的博客
08-06 1669
利用不相交集类生成迷宫，具体见 http://blog.csdn.net/blubluhao/article/details/76445377然后利用无权图的最短路径选择找出走出迷宫的路径，具体见 http://blog.csdn.net/blubluhao/article/details/76726887首先生成迷宫，然后利用已经生成的迷宫构建出一个图。迷宫的所有单元构成图的顶点，单元间没有墙
基于α-β剪枝python实现五子棋人机对战
最新发布
12-16
五子棋是一种古老的策略游戏，它是一种简单而又极具深度的游戏。基于α-β剪枝算法的五子棋人机对战是一种比较经典的实现方式。在Python中，我们可以使用对抗搜索和α-β剪枝算法来实现五子棋人机对战。 首先，我们需要创建一个五子棋的棋盘表示，可以使用二维数组来表示。接着，我们需要编写一个评估函数来评估当前棋盘局面的好坏。评估函数可以根据当前棋盘的情况来给出一个分数，用来评估当前局面的优劣。 接下来，我们可以使用递归的方式来实现对抗搜索和α-β剪枝算法。对抗搜索是一种搜索算法，它可以搜索当前局面下的所有可能着法，并根据评估函数来选择最优的着法。而α-β剪枝算法则可以帮助我们剪枝，减少搜索的时间复杂度，从而提高搜索的效率。 在实现对抗搜索和α-β剪枝算法的过程中，我们需要考虑一些细节问题，比如搜索的深度、搜索的时间、剪枝的条件等等。同时，我们还需要处理一些特殊情况，比如提前胜利、防守对方的提前胜利等等。 最后，我们可以将人机对战的整个过程进行封装，让玩家可以和计算机进行五子棋的对战。玩家可以选择先手或者后手，然后通过与计算机进行对战来提高自己的水平。 综上所述，基于α-β剪枝算法的五子棋人机对战的实现，包括棋盘表示、评估函数、对抗搜索和剪枝算法的实现，以及人机对战的封装。这样的实现方式既能提高计算机的对战水平，也能帮助玩家提高自己的棋艺水平。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值