博弈算法实现三子棋

最新推荐文章于 2021-03-16 19:50:10 发布
最新推荐文章于 2021-03-16 19:50:10 发布
阅读量3k 收藏 26
点赞数 8
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmwwxx123/article/details/80808694
版权

用博弈树算法实现井字棋游戏。 井字棋游戏是一种简单的棋类游戏，在3*3的棋盘上，两人轮流下子，谁的棋子先连成3颗一条直线，谁就赢了，可以横着、竖着、斜着。博弈树算法是用搜索来解决这类问题的算法，井字棋游戏步数较少，很容易用博弈树算法实现

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;

int num = 0;
int p, q;
int tmpQP[3][3]; //表示棋盘数据的临时数组，其中的元素0表示该格为空，
int cur[3][3];

const int depth = 3;  //搜索树的最大深度


void Init()
{

    for (int i = 0; i<3; i++)
    for (int j = 0; j<3; j++)
    {
        cur[i][j] = 0;
    }
}
void PrintQP()  //打印当棋盘格局的函数
{
    for (int i = 0; i<3; i++)
    {
        for (int j = 0; j<3; j++)
            cout << cur[i][j] << '\t';
        cout << endl;//换行
    }
}

int CheckWin() //有人赢了吗？返回0表示没有人赢，返回-1表示人赢了，返回1表示计算机赢了
{
    for (int i = 0; i<3; i++)
    {
        if (cur[i][0] == 1 && cur[i][1] == 1 && cur[i][2] == 1)
            return 1;
        if (cur[i][0] == -1 && cur[i][1] == -1 && cur[i][2] == -1)
            return -1;
    }
    for (int i = 0; i<3; i++)
    {
        if (cur[0][i] == 1 && cur[1][i] == 1 && cur[2][i] == 1)
            return 1;
        if (cur[0][i] == -1 && cur[1][i] == -1 && cur[2][i] == -1)
            return -1;
    }
    if ((cur[0][0] == 1 && cur[1][1] == 1 && cur[2][2] == 1) || (cur[2][0] == 1 && cur[1][1] == 1 && cur[0][2] == 1))
        return 1;
    if ((cur[0][0] == -1 && cur[1][1] == -1 && cur[2][2] == -1) || (cur[2][0] == -1 && cur[1][1] == -1 && cur[0][2] == -1))
        return -1;

    return 0;
}


int value()//评估函数
{
    p = 0;
    q = 0;
    //将棋盘中的空格填满自己的棋子，既将棋盘数组中的0变为1
    for (int i = 0; i<3; i++)
    for (int j = 0; j<3; j++)
    if (cur[i][j] == 0)
        tmpQP[i][j] = 1;
    else
        tmpQP[i][j] = cur[i][j];

    //电脑一方
    //计算每一行中有多少行的棋子连成3个的
    for (int i = 0; i<3; i++)
        p += (tmpQP[i][0] + tmpQP[i][1] + tmpQP[i][2]) / 3;
    //计算每一列中有多少列的棋子连成3个的
    for (int i = 0; i<3; i++)
        p += (tmpQP[0][i] + tmpQP[1][i] + tmpQP[2][i]) / 3;
    //斜行有没有连成3个的？
    p += (tmpQP[0][0] + tmpQP[1][1] + tmpQP[2][2]) / 3;
    p += (tmpQP[2][0] + tmpQP[1][1] + tmpQP[0][2]) / 3;

    //将棋盘中的空格填满对方的棋子，既将棋盘数组中的0变为-1
    for (int i = 0; i<3; i++)
    for (int j = 0; j<3; j++)
    if (cur[i][j] == 0)tmpQP[i][j] = -1;
    else tmpQP[i][j] = cur[i][j];

    //对方
    //计算每一行中有多少行的棋子连成3个的
    for (int i = 0; i<3; i++)
        q += (tmpQP[i][0] + tmpQP[i][1] + tmpQP[i][2]) / 3;
    //计算每一列中有多少列的棋子连成3个的
    for (int i = 0; i<3; i++)
        q += (tmpQP[0][i] + tmpQP[1][i] + tmpQP[2][i]) / 3;
    //斜行有没有连成3个的？
    q += (tmpQP[0][0] + tmpQP[1][1] + tmpQP[2][2]) / 3;
    q += (tmpQP[2][0] + tmpQP[1][1] + tmpQP[0][2]) / 3;

    return p + q;
}

//极大结点下界为A,极小结点上界为B
int cut(int &val, int dep, bool max)  //主算法部分，实现A－B剪枝的算法，val为上一层的评价值，dep为搜索深度，max记录上一层是否为极大层
{
    if (dep == depth || dep + num == 9)     //如果搜索深度达到最大深度，或者深度加上当前棋子数已经达到9，就直接调用评价函数
    {
        return value();
    }
    int i, j, flag, temp;

    bool out = false;                //out记录是否剪枝，初始为false

    if (CheckWin() == 1)            //如果用户玩家输了，就置上一层的评价值为无穷（用很大的值代表无穷）
    {
        val = 10000;
        return 0;
    }

    if (max)                    //如果上一层是极大层，本层则需要是极小层，记录flag为无穷大；反之，则为记录为负无穷大
        flag = 10000;            //flag记录本层节点的极值
    else
        flag = -10000;
    for (i = 0; i<3 && !out; i++)      //两重循环，遍历棋盘所有位置
    {
        for (j = 0; j<3 && !out; j++)
        {
            if (cur[i][j] == 0)     //如果该位置上没有棋子
            {
                if (max)                //并且为上一层为极大层，即本层为极小层,轮到用户玩家走了。
                {
                    cur[i][j] = -1;     //该位置填上用户玩家棋子

                    if (CheckWin() == -1)    //如果用户玩家赢了
                        temp = -10000;    //置棋盘评价值为负无穷
                    else
                        temp = cut(flag, dep + 1, !max);  //否则继续调用ab剪枝函数
                    if (temp<flag)              //如果下一步棋盘的评价值小于本层节点的极值，则置本层极值为更小者，即后辈结点极小值<=祖先节点极大值
                        flag = temp;
                    if (flag <= val)           //如果本层的极值已经小于上一层的评价值，则不需要搜索下去，剪枝   A剪枝
                        out = true;
                }
                else                //如果上一层为极小层，算法与上面刚好相反
                {
                    cur[i][j] = 1;//该位置填上电脑玩家棋子

                    if (CheckWin() == 1)//如果电脑玩家赢了，置棋盘评价值为正无穷
                        temp = 10000;
                    else
                        temp = cut(flag, dep + 1, !max); // 否则继续调用ab剪枝函数
                    if (temp>flag)     //如果下一步棋盘的评价值大于本层节点的极值，则置本层极值为更小者，即后辈结点极大值>=祖先节点极小值
                        flag = temp;
                    if (flag >= val)     //如果本层的极值已经大于上一层的评价值，则不需要搜索下去，剪枝 B剪枝
                        out = true;
                }
                cur[i][j] = 0;   //把模拟下的一步棋还原，回溯
            }
        }
    }
    if (max)      //根据上一层是否为极大层，用本层的极值修改上一层的评价值
    {
        if (flag>val)
            val = flag;
    }
    else
    {
        if (flag<val)
            val = flag;
    }


    return flag;   //函数返回的是本层的极值
}


//用户通过此函数来输入落子的位置，
//比如，用户输入31，则表示用户在第3行第1列落子。
void UserInput()
{
    int pos, x, y;
L1: cout << "Please input your qizi (xy):\n ";
    cin >> pos;
    x = pos / 10, y = pos % 10;
    if (x>0 && x<4 && y>0 && y<4 && cur[x - 1][y - 1] == 0)
    {
        cur[x - 1][y - 1] = -1;
    }
    else
    {
        cout << "Input Error!\n";
        goto L1;
    }
}


//主程序
int main()
{
    int m = -10000, val = -10000, dep = 1;                //m 用来存放最大的val
    int x_pos, y_pos;                                 //记录最佳走步的坐标
    Init();
    cout << "Qipan: " << endl;
    PrintQP();
    char IsFirst;
    cout << "Do you want do first?(y/n)";
    cin >> IsFirst;
    while (IsFirst != 'y'&&IsFirst != 'n')
    {
        cout << "ERROR!" << "Do you want do first?(y/n)";
        cin >> IsFirst;
    }

    if (IsFirst == 'y')
    {

    L4:                                                      // 人先走
        UserInput();
        PrintQP();
        cout << endl;
        num++;
        value();
        if (q == 0)
        {
            cout << "DOWN GAME!" << endl;
            system("pause");
            return 0;
        }
        if (CheckWin() == -1)
        {
            cout << "You Win! GAME OVER." << endl;
            system("pause");
            return 0;
        }

        for (int x = 0; x<3; x++)
        for (int y = 0; y<3; y++){
            if (cur[x][y] == 0){
                cur[x][y] = 1;
                cut(val, dep, 1);
                if (CheckWin() == 1)  {
                    cout << "The computer put the qizi at:" << x + 1 << y + 1 << endl;
                    PrintQP();
                    cout << "The computer WIN! GAME OVER." << endl;
                    system("pause");
                    return 0;
                }

                if (val>m) {
                    m = val;
                    x_pos = x; y_pos = y;
                }
                val = -10000;
                cur[x][y] = 0;
            }
        }
        cur[x_pos][y_pos] = 1;

        val = -10000; m = -10000; dep = 1;
        cout << "The computer put the qizi at:" << x_pos + 1 << y_pos + 1 << endl;
        PrintQP();
        cout << endl;
        num++;
        value();
        if (q == 0)
        {
            cout << "DOWN GAME!" << endl;
            system("pause");
            return 0;
        }

        goto L4;
    }


    else

    {                                                    // 计算机先走
    L5:
        for (int x = 0; x<3; x++)
        for (int y = 0; y<3; y++){
            if (cur[x][y] == 0){
                cur[x][y] = 1;
                cut(val, dep, 1);
                if (CheckWin() == 1)  {
                    cout << "The computer put the qizi at:" << x + 1 << y + 1 << endl;
                    PrintQP();
                    cout << "The computer WIN! GAME OVER." << endl;
                    system("pause");
                    return 0;
                }
                if (val>m) {
                    m = val;
                    x_pos = x; y_pos = y;
                }
                val = -10000;
                cur[x][y] = 0;
            }
        }
        cur[x_pos][y_pos] = 1;

        val = -10000; m = -10000; dep = 1;
        cout << "The computer put the qizi at:" << x_pos + 1 << y_pos + 1 << endl;
        PrintQP();
        cout << endl;
        num++;
        value();
        if (p == 0)
        {
            cout << "DOWN GAME!" << endl;
            system("pause");
            return 0;
        }


        UserInput();
        PrintQP();
        cout << endl;
        num++;
        value();
        if (p == 0)
        {
            cout << "DOWN GAME!" << endl;
            system("pause");
            return 0;
        }
        if (CheckWin() == -1)
        {
            cout << "Conguatulations! You Win! GAME OVER." << endl;
            system("pause");
            return 0;
        }

        goto L5;

    }

    system("pause");
    return 0;
}

膜拜一下大佬(http://www.51hei.com/bbs/dpj-30442-1.html)

Niya-m
关注
  • 8
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
第6-3课：博弈树与井字棋（Tic-Tac-Toe）
oRbIt 的专栏
09-22 4188
上一课简单介绍了博弈树，从编程实现算法的角度看，博弈树是三种树中最简单的一种，无论是原理还是实现都不复杂。这一课，我们就以简单的井字棋（Tic-Tac-Toe）游戏为例，介绍一下如何用博弈树实现一个简单的井字棋 AI，最后的结果并不复杂，我希望大家把关注点放在如何设计数据模型、如何确定落子，以及将博弈树的理论应用到具体的问题等这样的过程上，而不是最后的结果。 Tic-Tac-Toe——规则...
基于博弈树的井字棋的实现
08-27
基于博弈树的井字棋的实现
51node 1995 三子棋(博弈 规律题）
passer__的博客
02-05 611
1995 三子棋  题目来源： syu校赛 基准时间限制：1 秒 空间限制：131072 KB 分值: 0 难度：基础题  收藏  关注 小的时候大家一定玩过“井”字棋吧。也就是在九宫格中，只要任意行、列，或者任意连续对角线上面出现三个相同的，就能获胜。现在小明和小花也在玩三子棋，但是他们不是在九宫格里，而是在3×4的格子里面。现在小明先下
三子棋小游戏~（人机）
Z_JUAN1的博客
04-19 376
说明：1.在本次程序中使用了头文件和源文件的方式。2.此次程序是实现人机对战的模式。         game.h  main.cgame.c程序结果图：
三子棋
Gerald的博客
10-19 1694
描述     用C语言完成一个三子棋小游戏。 步骤     1、首先创建一个二维数组 board ，用 board 数组来储存三子棋的棋盘和元素。     2、写一个函数 Init() 对 board 数组初始化 void InitBoard(char board[ROW][COL], int row, int col) { memset(&amp;board[0][0], ' ',...
博弈树 一字棋
05-24
人工智能 可曾作业 非常牛逼的作业 欢迎大家参考
六子棋计算机博弈系统的研究与实现.doc
11-30
六子棋作为最近两年才兴起的棋类游戏，其计算机博弈技术和算法的研究相对较少。六子棋计算机博弈的研究意义在于它可以提供一个新的研究平台，通过研究六子棋计算机博弈，研究者可以获得新的方法和理论，并对人工智能...
博弈六子棋安徽省三各版本源码.rar
11-22
博弈六子棋安徽省三各版本源码.rar博弈六子棋安徽省2020省三源码 python版本的六子棋。框架完整，算法还有进步空间，大家可以参考。
MinMax算法实现
12-16
minmax算法实现 比较有意思的一种算法
六子棋博弈系统设计与实现.doc
11-24
本文主要从棋盘表示、走法生成器、估值函数设计、搜索算法实现以及开局库几个方面介绍六子棋博弈系统的设计与实现。 1. 棋盘表示 棋盘的表示一般有数组表示法和比特表示法，比特表示法又称为位棋盘。六子棋棋盘...
博弈树（树的c实现）
12-22
下棋属于一种博弈游戏，博弈过程可以用树（博弈树）来表示。假设游戏由两个人（ A 和 B ）玩，开始由某个人从根结点开始走，两个人轮流走棋，每次只能走一步， 下一步棋只能选择当前结点的孩子结点，谁先走到叶子结点为胜。例如，对于下图所示的博弈树，若 A 先走，可以选 f ， B 若选 h ，则 A 选 j 胜。 编写一程序，让计算机和人下棋。当计算机走下一步时，可以根据以下情况决定下一步： （1） 若存在可以确保取胜的一个孩子结点，则选择该结点作为下一步； （2） 若存在多个可以确保取胜的孩子结点，则选择其中高度最小的结点作为下一步（若有多个选择，则选最左边的结点）； （3） 若不存在可以确保取胜的一个孩子结点，则选择高度最大的孩子结点作为下一步（若有多个选择，则选最左边的结点）； 例： （下面的黑体为输入） (a,(b,(x)),(c,(d),(e,(g),(h)),(f))) a b x c d e g h f Who play first(0: computer; 1: player )? 1 player: c computer: d Sorry, you lost. Continue(y/n)? y Who play first(0: computer; 1: player )? 1 player: x illegal move. player: b computer: x Sorry, you lost. Continue(y/n)? y Who play first(0: computer; 1: player )? 0 computer: c player: f Congratulate, you win. Continue(y/n)? n
基于qt实现的三连棋（井字棋）游戏（含AI算法）
07-23
基于qt实现的三连棋，包括初始界面，有人机对战和双人对战，人机对战采用min-max搜索来实现，代码量较小，适合新手学习。
论文研究-实现苏拉卡尔塔棋网络博弈平台的吃子算法.pdf
09-13
针对苏拉卡尔塔棋“机-机”博弈需要人工参与的弊端，提出了构建苏拉卡尔塔棋计算机网络博弈平台的必要性，通过博弈平台实现自动对弈，而构建计算机博弈平台的核心技术之一就是吃子算法的实现。介绍了苏拉卡尔塔棋的...
利用α-β搜索的博弈树算法编写一字棋游戏 python
监心司的博客
03-16 4549
游戏规则 “一字棋"游戏（又叫"三子棋"或"井字棋”），是一款十分经典的益智小游戏。“井字棋"的棋盘很简单，是一个 3×3 的格子，很像中国文字中的"井"字，所以得名"井字棋”。"井字棋"游戏的规则与"五子棋"十分类似，"五子棋"的规则是一方首先五子连成一线就胜利；“井字棋"是一方首先三子连成一线就胜利。 极小极大分析法 设有九个空格，由 MAX，MIN 二人对弈，轮到谁走棋谁就往空格上放一只自己的棋子，谁先使自己的棋子构成"三子成一线”(同一行或列或对角线全是某人的棋子)，谁就取得了胜利。 估价函数定义如
三子棋算法可优化算法
quchen528的博客
10-12 721
  1.判断胜负时的优化算法 新改优化算法在原有基础代码的基础上，优点在于可以进一步升级更替为五子棋等等 char IsWin(char board[ROW][COL], int row, int col) { int i = 0; int j = 0; int t = 0; int d = 0; char set = '0'; for(i=0; i&lt;row; i++) ...
C语言 三子棋的实现详解
weixin_44899940的博客
10-20 365
三子棋游戏的代码实现 //头文件 //定义棋盘横列大小 #define ROW 3 #define COL 3 #include "game.h" #include <stdlib.h> #include <time.h>//在随机数的用到时间 //初始化棋盘函数声明 void InitBoard(char board[ROW][COL],int row,int col); //打印棋盘函数声明 void displayd(char board[ROW][COL],int row,i
浅谈实现三子棋
Z00_J的博客
01-26 101
做一个简单小游戏 小游戏也要有游戏的样子，比如菜单，游戏内容，输赢判断等等 那我们就来做一个简单的游戏菜单： 给予玩家俩个选项，玩游戏或是退出。 那么游戏玩了一把还想玩怎么办？我们主函数这样来写： 这样写的好处是我们在玩完一把后还可以继续选择玩或者不玩，不玩的话我们输入零，那么while函数的条件为假，程序不再循环，游戏也就不再继续。 然乎我们就要写游戏内容了，内容大概分为一个空棋盘，玩家下棋，电脑下棋，判断输赢。 我们先把我们要用到的函数声明一下： 空棋盘得有格子，这里打印格子
博弈树
lydcsdn
11-10 3736
博弈树
后序线索树怎样画图_博弈树（game tree）简介
weixin_39870132的博客
11-24 2857
博弈树（game tree）是一种特殊的根树，它是人工智能领域一个重要的研究课题。博弈树可以表示两名游戏参与者之间的一场博弈（游戏），他们交替行棋，试图获胜。例如，考虑在 的九宫格棋盘上进行的“井字棋”游戏（tic-tac-toe）。最初，所有9个小方格都是空的（如下图(a)所示）两名游戏者A和B交替行棋——A选择一个空的小方格并写下符号×，而B则选择空的小方格写下符号〇首先使得己方符号中的3个...
基于c语言的六子棋博弈树
最新发布
03-31
很抱歉，作为AI语言模型，我无法提供代码实现。但是，我可以为您解释一下六子棋博弈树的基本思路和算法。 六子棋是一种类似于五子棋的棋类游戏，玩家通过在棋盘上放置棋子来获得胜利。博弈树是一种用于解决博弈问题的数据结构，用于模拟所有可能的游戏状态和玩家行动。通过搜索博弈树，计算机可以找到最佳的下一步棋子位置，从而战胜人类玩家。 在构建六子棋博弈树时，需要考虑以下几个方面： 1.棋盘状态的表示：可以使用二维数组来表示棋盘状态，将空白位置设置为0，黑子设置为1，白子设置为2。 2.游戏结束的判断：当一个玩家在棋盘上形成六个连续的棋子时，游戏结束，该玩家获胜。 3.博弈树节点的表示：每个博弈树节点包含当前的棋盘状态和当前玩家的颜色。 4.搜索算法的选择：可以使用深度优先搜索、广度优先搜索或者Alpha-Beta剪枝算法来搜索博弈树。 5.评价函数的设计：评价函数用于评估当前棋盘状态的价值，可以考虑棋子的数量、棋子的连成情况、棋子的位置等因素。 总的来说，构建六子棋博弈树需要考虑多个因素，需要综合考虑算法的效率和评价函数的准确性。如果您想要实现六子棋博弈树，建议先了解以上几个方面的知识，再结合具体的代码实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值