井字棋AI算法

已于 2024-03-18 15:41:07 修改
阅读量1.8k 收藏 11
点赞数
分类专栏： Aigorithm 文章标签： 机器学习
于 2021-03-17 23:23:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41405524/article/details/114955347
版权

介绍

井字棋，英文名叫Tic-Tac-Toe，是一种在3*3格子上进行的连珠游戏，和五子棋类似，由于棋盘一般不画边框，格线排成井字故得名。游戏需要的工具仅为纸和笔，然后由分别代表O和X的两个游戏者轮流在格子里留下标记（一般来说先手者为X），任意三个标记形成一条直线，则为获胜。

在这里插入图片描述

训练AI

主要思路是保存每次失败的局，下次不在走类似的局，这样经过长期训练，AI会越来越聪明

import java.util.Random;
import java.util.Scanner;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * TicTacToe
 *
 * @author your name
 */
public class TicTacToe {

    // member variables
    private static final String[][] table = new String[3][3];
    private static final CopyOnWriteArrayList<String> success = new CopyOnWriteArrayList<String>();
    private static final CopyOnWriteArrayList<String> pStrings = new CopyOnWriteArrayList<String>();
    private static final CopyOnWriteArrayList<String> cStrings = new CopyOnWriteArrayList<String>();
    private static final CopyOnWriteArrayList<String> losingStrings = new CopyOnWriteArrayList<String>();

    // main
    public static void main(String[] args) {
        // initial
        initSuccess();
        // loop
        do {
            System.out.println("start game!");
            test();
        } while (true);
    }

    @SuppressWarnings("resource")
    // test
    public static void test() {
        Scanner sc = new Scanner(System.in);
        CopyOnWriteArrayList<String> losingList = new CopyOnWriteArrayList<String>();
        int index = 0;
        do {
            System.out.println("input anything");
            sc.next();
            System.out.println("your input position 1: (range 0 from 2)");
            int p1 = sc.nextInt();
            System.out.println("your input position 2: (range 0 from 2)");
            int p2 = sc.nextInt();
            table[p1][p2] = "p";
            pStrings.add(p1 + "" + p2);
            index++;
            int a1 = 0;
            int a2 = 0;
            if (index == 5) ;
            else {
                do {
                    // call computer
                    int[] cs = computerTurn();
                    table[cs[0]][cs[1]] = "c";
                    boolean fs = false;
                    String temp = print();
                    for (int i = 0; i < losingStrings.size(); i++) {
                        if (temp.equals(losingStrings.get(i))) {
                            fs = true;
                        }
                    }
                    if (fs) {
                        table[cs[0]][cs[1]] = null;
                        continue;
                    } else {
                        a1 = cs[0];
                        a2 = cs[1];
                        break;
                    }
                } while (true);
                cStrings.add(a1 + "" + a2);
            }

            // print
            System.err.println(print());

            // record
            losingList.add(print());

            // judge
            boolean[] flag = judge();

            if (flag[0] | flag[1]) {
                // clear table
                for (int i = 0; i < 3; i++) {
                    for (int j = 0; j < 3; j++) {
                        table[i][j] = null;
                    }
                }
                // print result
                if (flag[1]) {
                    System.err.println("person wins!");
                    losingStrings.add(losingList.get(losingList.size() - 2));
                    System.err.println(printLosing());
                    pStrings.clear();
                    cStrings.clear();
                    break;
                } else {
                    System.err.println("computer wins!");
                    cStrings.clear();
                    pStrings.clear();
                    break;
                }
            }
            // is tie
            if (isTie()) {
                break;
            }
        } while (true);
    }

    // printLosing
    public static String printLosing() {
        String outString = "";
        for (int i = 0; i < losingStrings.size(); i++) {
            outString += "losing:\n" + losingStrings.get(i) + "\n";
        }
        return outString;
    }

    // isTie
    public static boolean isTie() {
        int idxs = 0;
        // valid of table
        for (int i = 0; i < table.length; i++) {
            for (int j = 0; j < 3; j++) {
                if (table[i][j] != null) idxs++;
            }
        }
        if (idxs == 9) {
            System.err.println("equal or tie");
            cStrings.clear();
            pStrings.clear();
            // clear table
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    table[i][j] = null;
                }
            }
            return true;
        }
        return false;
    }

    public static boolean[] judge() {
        // judge success
        boolean fc = false;
        boolean fp = false;

        for (int i = 0; i < success.size(); i++) {
            int b = 0;
            for (int j = 0; j < pStrings.size(); j++) {
                int f = 0;
                if (success.get(i).substring(0, 2).equals(pStrings.get(j))) {
                    f = 1;
                }
                if (success.get(i).substring(2, 4).equals(pStrings.get(j))) {
                    f = 1;
                }
                if (success.get(i).substring(4, 6).equals(pStrings.get(j))) {
                    f = 1;
                }
                if (f == 1) {
                    b++;
                }
            }
            if (b == 3) {
                fp = true;
                break;
            }
        }
        for (int i = 0; i < success.size(); i++) {
            int a = 0;
            for (int j = 0; j < cStrings.size(); j++) {
                int f = 0;
                if (success.get(i).substring(0, 2).equals(cStrings.get(j))) {
                    f = 1;
                }
                if (success.get(i).substring(2, 4).equals(cStrings.get(j))) {
                    f = 1;
                }
                if (success.get(i).substring(4, 6).equals(cStrings.get(j))) {
                    f = 1;
                }
                if (f == 1) {
                    a++;
                }
            }
            if (a == 3) {
                fc = true;
                break;
            }
        }

        System.out.println("cs=" + cStrings.toString());
        System.out.println("ps=" + pStrings.toString());
        return new boolean[]{fc, fp};
    }

    public static String print() {
        // print
        String tableString = "";
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (table[i][j] == null) {
                    tableString += " \t";
                } else if (table[i][j].equals("c")) {
                    tableString += "c\t";
                } else {
                    tableString += "p\t";
                }
            }
            tableString += "\n";
        }
        return tableString;
    }

    // computer turn
    public static int[] computerTurn() {
        int[] res = new int[2];
        int c1 = 0;
        int c2 = 0;
        do {
            c1 = new Random().nextInt(3);
            c2 = new Random().nextInt(3);
            if (table[c1][c2] == null) {
                break;
            }
        } while (true);
        res[0] = c1;
        res[1] = c2;
        return res;
    }

    // initSuccess
    public static void initSuccess() {
        final String[] items = {
                "00", "01", "02",
                "10", "11", "12",
                "20", "21", "22"
        };
        final int[][] combination = {
                {0, 4, 8},
                {2, 4, 6},
                {0, 1, 2},
                {3, 4, 5},
                {6, 7, 8},
                {0, 3, 6},
                {1, 4, 7},
                {2, 5, 8}
        };
        for (int i = 0; i < combination.length; i++) {
            int[] temp = combination[i];
            String t1 = items[temp[0]] + items[temp[1]] + items[temp[2]];
            success.add(t1);
            String t4 = items[temp[2]] + items[temp[1]] + items[temp[0]];
            success.add(t4);
            String t2 = items[temp[1]] + items[temp[0]] + items[temp[2]];
            success.add(t2);
            String t5 = items[temp[2]] + items[temp[0]] + items[temp[1]];
            success.add(t5);
            String t3 = items[temp[0]] + items[temp[2]] + items[temp[1]];
            success.add(t3);
            String t6 = items[temp[1]] + items[temp[2]] + items[temp[0]];
            success.add(t6);
        }

    }

}

效果

启动后和AI进行对局，AI每次会将失败的路数记录下来，下次不再走重复的路径，训练久了AI就会越来越聪明

在这里插入图片描述

BirdMan98
关注
专栏目录
关于井字棋/三子棋的伪人工智能算法的实现
DanteKing的博客
04-24 2700
井字棋/三子棋的伪人工智能算法的实现 一、Abstract 本算法用于实现井字棋游戏电脑先手情况下的智能落子 二、Introduction 关于井字棋的模块的搭建，分为棋盘的初始化、棋盘的展示、电脑落子、玩家落子、判断输/赢/平局/继续游戏这5个模块。 其中，我们着重介绍一下电脑落子的具体算法。本算法可以使得玩家永远赢不了棋局。（输/平局） 本算法的核心思想为 暴力枚举 和 迫使玩家进行指定位置的落子 注： 本棋盘为3*3的大小 电脑先手 以下用形如(2,1)的形式表示落子的坐标 用“#”表示电脑的棋子，
【简单AI井字棋】
m0_52882232的博客
03-01 7186
井字棋AI开发1.井字棋的原理二级目录三级目录 1.井字棋的原理 二级目录 三级目录
井字棋 AI-Python
最新发布
2401_86075647的博客
07-07 1420
具体来说，如果当前是MAX节点（即玩家希望最大化收益的节点），它会评估所有可能的走法，并选择能带来最大价值的走法。通过这种递归方式，Minimax算法能够找到一条最优路径，使得在对方采取最佳反应的情况下，自己的损失最小。这种技术通过维护两个值——Alpha（当前找到的最大下界）和Beta（当前找到的最小上界），在搜索过程中剪枝那些不可能优于已有选择的子树，从而显著减少搜索量。总的来说，Minimax算法通过构建博弈树并递归评估每个可能的游戏状态，寻找在对手采取最优反应的情况下能够保证的最佳结果。
基于qt实现的三连棋（井字棋）游戏（含AI算法）
07-23
基于qt实现的三连棋，包括初始界面，有人机对战和双人对战，人机对战采用min-max搜索来实现，代码量较小，适合新手学习。
极小极大算法实现井字棋AI
01-14
井子棋是棋类中最简单的一种，通常作为算法的练手项目，该资源使用极小极大算法实现了一个井字棋的人机对弈，只需运行资源里的play_to_bot就可以在命令行里与AI对弈了，可以肯定的是你绝对不可能战胜它。虽然实现它比较容易，但是麻雀虽小，五脏俱全，棋类的基本框架类似，你可以在学习这个之后迁移到其他棋类
井字棋（三连棋）的AI实现，C/C++
10-10
井字棋的AI实现（完整包）无界面 创建TicTacToe类，使你可以编写一个完整的三连棋游戏程序。这个类包含一个作为private数据的3*3的二维整数数组。构造函数应将空棋盘初始化为0。允许两个人玩游戏。无论第一个人移动到哪里，都在指定的棋格中放置1，无论第二个人移动到哪里，都在指定的棋格中放置2。每次移动都必须到达一个空格。在每次移动后，确定是否已分胜负，还是出现了平局。此外，必须让玩家决定谁先走说后走。开发一个人机大战游戏。
井字棋.rar_MaxMin五子棋_井字棋 ai_井字棋ai算法_井字棋算法ai_六子棋
07-15
在本压缩包中，包含了一个使用MaxMin算法实现的井字棋AI，该算法同样适用于五子棋和六子棋。MaxMin算法是人工智能领域中一种经典的决策树搜索方法，主要用于解决两个玩家之间的零和博弈问题，比如井字棋、国际象棋和...
Alphaαβ剪枝算法 实现井字棋人工智能作业
11-24
总之，阿尔法贝塔剪枝算法在井字棋AI中的应用，展示了如何利用高效的搜索策略来模拟人类的决策过程。通过这个项目，无论是理论学习还是实践经验，都能让我们对人工智能和游戏开发有更深入的理解。
人工智能课程设计，基于α-β剪枝算法的井字棋
03-01
由于其简单的规则和有限的决策空间，井字棋常被用作教学人工智能算法的基础案例。 α-β剪枝算法是优化搜索树的策略，广泛应用于棋类游戏的决策过程中。它是一种基于最小化-最大化搜索的优化版本，用于减少在评估...
C#实现AlphaBelta剪枝算法井字棋人工智能
11-24
AlphaBetta剪枝算法是人工智能领域中用于优化搜索树策略的一种高效方法，尤其适用于解决有限游戏树的问题，如井字棋。在这个C#项目中，开发者利用AlphaBetta剪枝算法实现了一个人工智能，能够在井字棋游戏中与人类...
『HTML5实现人工智能』小游戏《井字棋》发布，据说IQ上200才能赢【算法&代码讲解+资源打包下载】
热门推荐
Yorhom's Game Box
03-14 3万+
一，什么是TicTacToe（井字棋） 本游戏为在下用lufylegend开发的第二款小游戏。此游戏是大家想必大家小时候都玩过，因为玩它很简单，只需要一张草稿纸和一只笔就能开始游戏，所以广受儿童欢迎。可能我说了半天，对它名字不熟悉的朋友也不懂我在说神马。那没关系，我就引用Wiki（维基百科）的介绍作为大家对它名字的认识，顺便也勾起我们儿时的回忆： 井字棋，大陆、台湾又称为井字游戏、圈圈叉叉；另
创新学井字棋AI
10-27
极小极大算法，估值，博弈树 Alpha-Beta搜索 井字棋算法详细分析
人工智能井字棋原理+代码
12-14
本文档讲解了井字游戏的算法原理，并有C语言代码。如果想了解一下井字游戏的原理可以看一下
井字棋算法
12-06
关于井字棋的算法，为大家提供，可以在其他地方找找
井字棋AI对战小游戏（前端开发）
03-16
这是一个拥有智能AI对手的井字棋小游戏，使用JavaScript语音进行开发，是一个前端小游戏，打开之后运行井字棋.html即可在网页上与AI进行井字棋游戏对战。也可以参考https://blog.csdn.net/qq_36171287/article/details/104887248这篇博客，主要代码博客中也都有。
基于java 的人工智能井字棋小游戏
04-07
基于java语言实现的人工只能小游戏井字棋，里面包含源码和简单的程序介绍。
python井字棋ai_[Python100行系列]-井字棋游戏
weixin_32589387的博客
01-29 544
博客：Hzy的博客 | Hzy Blog​hzeyuan.cn一些学习python的小项目，小游戏。python小项目​github.com话不多说，今天尝试用turtle库来写一个井字棋游戏。1.首先需要画一个井字的棋盘2.需要圈圈和叉叉两名玩家，通过点击棋盘来O和×3.判断条件，当满足获胜条件后，游戏结束。1.我们先来定义棋盘的大小，600*600这样分成9宫格，每一个格子就是200*200我...
Tic-Tac-Toe游戏简介（AI井字棋游戏）
weixin_45936129的博客
05-05 2920
本章游戏项目将介绍如何使用AI(Artificial Intelligence，人工智能)来创建计算机对手。在该游戏中，玩家和计算机进行一场高赌注的人机Tic-Tac-Toe决战。计算机的棋艺令人生畏（尽管不是很完美），并且通过使其人格化来让比赛变得更有趣 文章目录一、游戏规划1.编写伪代码2.数据的表示3.创建函数列表二、程序源码 一、游戏规划 1.编写伪代码 伪代码的每一行就像是一个函数的调用。之后，所有要做的事情就是编写伪代码所暗示的函数 Create an empty Tic-Tac-Toe .
AI赋能python: 井字棋
a_pjx_z的博客
05-17 405
python井字棋
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BirdMan98

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值