五子棋简易AI算法

最新推荐文章于 2024-05-13 16:07:00 发布
最新推荐文章于 2024-05-13 16:07:00 发布
阅读量6.8k 收藏 36
点赞数 7
文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quarkx/article/details/127256882
版权

一、基本思想：五子棋存在多种连接方式，这也就决定了每一个空位的权值有所不同，我们对五子棋的不同连接方式设置权值，然后遍历棋盘，算出每一个空位上的权值，选择权值最大的空位下棋，所以这个算法的关键就在于：1.设置并且存储不同连接方式及其对应的权值 2.计算棋盘空位上的权值。

二、设置不同连接方式的权值并进行存储

棋子的连接分为活连与死连，假设0代表空位，1代表黑棋，2代表白旗，如010为活连，01（遇到边界）为死连为不同连接方式设置对应权值：

假设0代表空位，1代表黑棋，2代表白旗

权值表（还可以细分）

连接方式 权值 010 50 0110 150 01110 500 011110 3000 020 50 0220 150 02220 500 022220 3000 01 30 011 90 0111 300 01111 3000 02 30 022 90 0222 300 02222 3000

 

设置好权值表后，就要考虑如何存储权值表，因为权值表中的数据是用来后续计算空位总权值所需的。这里我们考虑用哈希表进行存储“连接方式——权值”这样子的键值对

Key-Value ： 键值对 

HashMap：

  • 将键值对一起存入 ，可以通过键来查询对应的值

  • 将连子情况作为Key ，权值分作为Value

  • 1: 键不能重复，值可以重复

  • 2： HashMap 存储优势是 查询时是O1的时间复杂度

  • 3： HashMap 存储原理：

    • 1： 用key来计算一个hash值 (当作唯一标识)，hash值然后作为下标 ，然后将k-v存储在数组中对应下标位置

  • 操作：

    • 实例化： HashMap<String,Integer> codeMap = new HashMap();
    • 方法： code.put(key,value);/ value = code.get(key);
 static HashMap<String, Integer> codeMap = new HashMap<> ();
    static int[][] codeArrray = new int[16][16];    //创建用来存储权值的二维数组

    // 静态代码块
    static{
        codeMap.put ("010", 50);
        codeMap.put ("0110", 150);
        codeMap.put ("01110", 500);
        codeMap.put ("011110", 3000);

        codeMap.put ("020", 50);
        codeMap.put ("0220", 150);
        codeMap.put ("02220", 500);
        codeMap.put ("022220", 3000);

        codeMap.put ("01", 30);
        codeMap.put ("011", 90);
        codeMap.put ("0111", 300);
        codeMap.put ("01111", 3000);

        codeMap.put ("02", 30);
        codeMap.put ("022", 90);
        codeMap.put ("0222", 300);
        codeMap.put ("02222", 3000);

        Integer integer = codeMap.get ("010");
        System.out.println (integer);
    }

三、遍历表格计算权值

如图一个五子棋盘：

 

尝试计算a、b两个空位处的权值大小，我们可以发现空位处的连接可以往上、下、左、右、左上、右上、左下、右下一共8个方向进行搜索，同时我们再规定一个空位的权值由八个方向的连接带来的权值简单相加得到（规则不唯一）。

对于a，往左的连接为01，权值30；往下的连接为01，权值30；往右下的连接010，权值50，故a处的权值为30+30+50=110

对于b，往左的连接为022，权值90；往上的连接为01，权值30；往左上的连接为011，权值90，故b处的权值为90+30+90=210

有了上面的举例，下面通过遍历计算每一个空位的权值

    private static void getCodeArray(int[][] arr){

        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j++){
                int chessNum = arr[i][j];
                // 遍历所有的空格
                if(chessNum == 0){
                    toRight (i, j, arr);    //往右走的权值
                    toLeft(i,j,arr);
                    toUp(i,j,arr);
                    toDown(i,j,arr);
                    toLeftUp(i,j,arr);  //往左上走的权值
                    toRightup(i,j,arr);
                    toLeftDown(i,j,arr);
                    toRightDown(i,j,arr);
                }
            }
        }

    }

上面的代码中往8个方向计算权值，但是方法还未定义，下面以往右和往左上为例

往右：

    private static void toRight(int i, int j, int[][] chessArray){
        // 等于0
        int chessNum = chessArray[i][j];
        // 右边是0/墙 return
        if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
            return;
        }
        // 右边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i][j + 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 右边第二颗 0/与第一颗相同的/不同的/墙
        for(int m = j + 2; m < chessArray[i].length; m++){
            int chessNumRn = chessArray[i][m];
            if(chessNumRn != 0){
                if(chessNumR1 == chessNumRn){
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if(chessNumR1 != chessNumRn){
                    // 找到不相同的就结束循环
                    break;
                }
            } else{
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;

    }

往左上：

 private static void toLeftUp(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 左上边是0/墙 return
        if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
            return;
        }
        // 左上边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i - 1][j - 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 左上边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i - 2; k > -1; k--) {
            for (int m = j - 2; m > -1; m--) {
                int chessNumRn = chessArray[k][m];
                if (chessNumRn != 0) {
                    if (chessNumR1 == chessNumRn) {
                        // 找到相同的就拼接一个棋子标识
                        codeStr += chessNumR1;
                    } else if (chessNumR1 != chessNumRn) {
                        // 找到不相同的就结束循环
                        break;
                    }
                } else {
                    // 活连的结尾 就结束循环
                    codeStr += "0";
                    break;
                }

            }
        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

这里无论是往哪个方向，计算出来的权值都需要累加到codeArray对应位置，codeArray是已经定义的存储权值的二维数组

完整代码：

package com.zsj0929;
import java.util.HashMap;

public class AI {// 会在类使用的时候初始化
    static HashMap<String, Integer> codeMap = new HashMap<> ();
    static int[][] codeArrray = new int[16][16];

    // 静态代码块
    static{
        codeMap.put ("010", 50);
        codeMap.put ("0110", 150);
        codeMap.put ("01110", 500);
        codeMap.put ("011110", 3000);

        codeMap.put ("020", 50);
        codeMap.put ("0220", 150);
        codeMap.put ("02220", 500);
        codeMap.put ("022220", 3000);

        codeMap.put ("01", 30);
        codeMap.put ("011", 90);
        codeMap.put ("0111", 300);
        codeMap.put ("01111", 3000);

        codeMap.put ("02", 30);
        codeMap.put ("022", 90);
        codeMap.put ("0222", 300);
        codeMap.put ("02222", 3000);

        Integer integer = codeMap.get ("010");
        System.out.println (integer);
    }

    public static void main(String[] args){
        int[][] arr = {
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
        };
        // 遍历计算所有可以下棋的地方的权值
        getCodeArray (arr);
        // 获取矩阵中权值最大的位置

        for(int i = 0; i < codeArrray.length; i++){
            for(int j = 0; j < codeArrray[i].length; j++){
                System.out.print (codeArrray[i][j] + "     ");
            }
            System.out.println ();
        }
    }

    private static void getCodeArray(int[][] arr){

        for(int i = 0; i < arr.length; i++){
            for(int j = 0; j < arr[i].length; j++){
                int chessNum = arr[i][j];
                // 遍历所有的空格
                if(chessNum == 0){
                    toRight (i, j, arr);    //往右走的权值
                    toLeft(i,j,arr);
                    toUp(i,j,arr);
                    toDown(i,j,arr);
                    toLeftUp(i,j,arr);  //往左上走的权值
                    toRightup(i,j,arr);
                    toLeftDown(i,j,arr);
                    toRightDown(i,j,arr);
                }
            }
        }

    }

    private static void toRightDown(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 右下边是0/墙 return
        if(i + 1 >= chessArray.length||j + 1>=chessArray.length || chessArray[i + 1][j + 1] == 0){
            return;
        }
        // 右下边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i + 1][j + 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 右下边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i + 2; k < chessArray.length; k++) {
            for (int m = j + 2; m < chessArray[i].length; m++) {
                int chessNumRn = chessArray[k][m];
                if (chessNumRn != 0) {
                    if (chessNumR1 == chessNumRn) {
                        // 找到相同的就拼接一个棋子标识
                        codeStr += chessNumR1;
                    } else if (chessNumR1 != chessNumRn) {
                        // 找到不相同的就结束循环
                        break;
                    }
                } else {
                    // 活连的结尾 就结束循环
                    codeStr += "0";
                    break;
                }

            }
        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toLeftDown(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 左下边是0/墙 return
        if(i + 1 >= chessArray.length||j - 1 <= -1 || chessArray[i + 1][j - 1] == 0){
            return;
        }
        // 左下边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i + 1][j - 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 左下边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i + 2; k < chessArray.length; k++) {
            for (int m = j - 2; m >= -1; m--) {
                int chessNumRn = chessArray[k][m];
                if (chessNumRn != 0) {
                    if (chessNumR1 == chessNumRn) {
                        // 找到相同的就拼接一个棋子标识
                        codeStr += chessNumR1;
                    } else if (chessNumR1 != chessNumRn) {
                        // 找到不相同的就结束循环
                        break;
                    }
                } else {
                    // 活连的结尾 就结束循环
                    codeStr += "0";
                    break;
                }

            }
        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toRightup(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 右上边是0/墙 return
        if(i - 1 <= -1||j + 1>=chessArray.length || chessArray[i - 1][j + 1] == 0){
            return;
        }
        // 右上边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i - 1][j + 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 右上边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i - 2; k > -1; k--) {
            for (int m = j + 2; m < chessArray[i].length; m++) {
                int chessNumRn = chessArray[k][m];
                if (chessNumRn != 0) {
                    if (chessNumR1 == chessNumRn) {
                        // 找到相同的就拼接一个棋子标识
                        codeStr += chessNumR1;
                    } else if (chessNumR1 != chessNumRn) {
                        // 找到不相同的就结束循环
                        break;
                    }
                } else {
                    // 活连的结尾 就结束循环
                    codeStr += "0";
                    break;
                }

            }
        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toLeftUp(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 左上边是0/墙 return
        if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
            return;
        }
        // 左上边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i - 1][j - 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 左上边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i - 2; k > -1; k--) {
            for (int m = j - 2; m > -1; m--) {
                int chessNumRn = chessArray[k][m];
                if (chessNumRn != 0) {
                    if (chessNumR1 == chessNumRn) {
                        // 找到相同的就拼接一个棋子标识
                        codeStr += chessNumR1;
                    } else if (chessNumR1 != chessNumRn) {
                        // 找到不相同的就结束循环
                        break;
                    }
                } else {
                    // 活连的结尾 就结束循环
                    codeStr += "0";
                    break;
                }

            }
        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toDown(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 下边是0/墙 return
        if(i + 1 >= chessArray.length || chessArray[i + 1][j] == 0){
            return;
        }
        // 下边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i + 1][j];
        String codeStr = "" + chessNum + chessNumR1;
        // 下边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i + 2; k < chessArray.length; k++){
            int chessNumRn = chessArray[k][j];
            if(chessNumRn != 0){
                if(chessNumR1 == chessNumRn){
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if(chessNumR1 != chessNumRn){
                    // 找到不相同的就结束循环
                    break;
                }
            } else{
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;

    }

    private static void toUp(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 上边是0/墙 return
        if(i - 1 <= -1 || chessArray[i - 1][j] == 0){
            return;
        }
        // 上边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i - 1][j];
        String codeStr = "" + chessNum + chessNumR1;
        // 上边第二颗 0/与第一颗相同的/不同的/墙
        for(int k = i - 2; k > -1; k--){
            int chessNumRn = chessArray[k][j];
            if(chessNumRn != 0){
                if(chessNumR1 == chessNumRn){
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if(chessNumR1 != chessNumRn){
                    // 找到不相同的就结束循环
                    break;
                }
            } else{
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toLeft(int i, int j, int[][] chessArray) {
        // 等于0
        int chessNum = chessArray[i][j];
        // 左边是0/墙 return
        if(j - 1 <= -1 || chessArray[i][j - 1] == 0){
            return;
        }
        // 左边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i][j - 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 左边第二颗 0/与第一颗相同的/不同的/墙
        for(int m = j - 2; m > -1; m--){
            int chessNumRn = chessArray[i][m];
            if(chessNumRn != 0){
                if(chessNumR1 == chessNumRn){
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if(chessNumR1 != chessNumRn){
                    // 找到不相同的就结束循环
                    break;
                }
            } else{
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;
    }

    private static void toRight(int i, int j, int[][] chessArray){
        // 等于0
        int chessNum = chessArray[i][j];
        // 右边是0/墙 return
        if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
            return;
        }
        // 右边第一个颗是1/2 记录下来
        int chessNumR1 = chessArray[i][j + 1];
        String codeStr = "" + chessNum + chessNumR1;
        // 右边第二颗 0/与第一颗相同的/不同的/墙
        for(int m = j + 2; m < chessArray[i].length; m++){
            int chessNumRn = chessArray[i][m];
            if(chessNumRn != 0){
                if(chessNumR1 == chessNumRn){
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if(chessNumR1 != chessNumRn){
                    // 找到不相同的就结束循环
                    break;
                }
            } else{
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
        Integer codeValue = codeMap.get (codeStr);
        if(codeValue == null){
            return;
        }
        // 将权值分存入 一个 新的权值二维数组
        codeArrray[i][j] += codeValue;

    }

}

山本二郎
关注
  • 7
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python版本五子棋的实现代码
09-19
五子棋是常见的一款小游戏，五子棋问题是人工智能中的一个经典问题。这篇文章主要介绍了python版本五子棋的实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【Unity】五子棋AI博弈算法实讲
Leibnezz的博客
02-21 1997
系统的，分层次的讲解了五子棋AI博弈算法。
五子棋对战（网页版）
最新发布
weixin_44985964的博客
05-13 962
首先需要在数据库中创建一个新的表, 用来表示每个玩家的游戏房间编号，服务器把每一局对局, 玩家轮流落子的位置都记录下来(比如保存到一个文本文件中)，然后玩家可以选定某个曾经的比赛, 在页面上回放出对局的过程.在游戏大厅除了显示匹配按钮之外, 还能显示当前所有的对局房间，玩家可以选中某个房间, 以观众的形式加入到房间中. 同时能实时的看到选手的对局情况.在处理落子响应中要处理胜负手.在 Matcher 的构造方法中, 创建一个线程, 使用该线程扫描每个队列, 把每个队列的头两个元素取出来, 匹配到一组中.
【c语言五子棋】简单ai算法（理论）
dancehole的博客
01-14 2005
博弈树 | | 极大极小值搜索 | | α ─ β 剪枝（Alpha-Beta剪枝）
攻城狮成长日志(五):远古人工智能,用博弈树实现的五子棋博弈系统(附原码)
Laugh_xiaoao的博客
12-30 1525
远古人工智能,用博弈树实现的五子棋博弈系统博弈树之我见估值函数如何择点下棋决策树使用Alpha-Beta剪枝总结 博弈树之我见 想必各位都听说过人工智能,但未必听说过博弈树.其实博弈树属于比较传统的一种人工智能算法,其一般被运用到对弈的游戏中.通过对棋局作估值,采用极大极小搜索的办法,近似的搜索出最佳的棋局方式,进而模仿人类的下棋方式. 碰巧课设需要设计一个棋类的对弈系统,就刚好将这个算法稍稍了解...
五子棋 AI（一）
大田二十
03-26 4328
五子棋 AI（一）
五子棋AI算法和开局定式（斜指13式）破解
baidu_41801770的博客
10-01 6844
五子棋AI算法和开局定式（ 斜指13式 ）破解 先前发了几篇五子棋游戏程序设计的博文，设计了游戏程序，也设计了AI智能奕棋的算法，运行程序检测算法的可行性，完成人机模式游戏功能的设置。这还不够，还要提高算法的实战水平。 对于人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。我感到白棋的后手防御算法很难取胜，棋界有黑棋高手先手必胜一说。算法么想了很多，既然是人工智能下棋就得按人的思路来算计。棋书阐述有许多思路和棋局解说。如活四冲四，嵌五，活三嵌四，活二嵌三。这些是高级棋手的总结。我
五子棋游戏AI智能算法设计
baidu_41801770的博客
12-04 7588
五子棋游戏C语言AI智能算法设计 近来发现编制五子棋游戏很有趣，尤其是AI智能算法很烧脑。网上介绍有什么贪心算法，剪枝算法，博弈树算法等等，不一而足。 对于人机对战的电脑智能应子算法，参阅很多五子棋书籍棋谱和五子棋竞赛的对抗棋谱。我感到白棋的后手防御算法很难取胜，棋界有黑棋高手先手必胜一说。算法么想了很多，既然是人工智能下棋就得按人的思路来算计。棋书阐述有许多思路和棋局解说。如活四冲四，嵌五，活三嵌四，活二嵌二。这些是高级棋手的总结。我就按此思路用加权计权方法来表现此类各种情况。 下面程序代码写出了
AI人机对战五子棋游戏【Python(pygame)+AI】并实现软件输出
weixin_60182338的博客
07-29 7910
AI人机对战五子棋游戏【Python+AI】并实现软件输出，一篇文章展示五子棋游戏，从Python编程，到实现AI技术，再到最后的可执行程序的封装，详细且具体，代码可运行
Java 五子棋AI 算法及实现 详细解析
weixin_71872462的博客
01-07 3801
连五，活四，冲四，活三，眠三，活二，眠二。①连五：顾名思义，五颗同色棋子连在一起，不需要多讲。②活四：有两个连五点（即有两个点可以形成五），图中白点即为连五点。稍微思考一下就能发现活四出现的时候，如果对方单纯过来防守的话，是已经无法阻止自己连五了。③冲四：有一个连五点，如下面三图，均为冲四棋型。图中白点为连五点。相对比活四来说，冲四的威胁性就小了很多，因为这个时候，对方只要跟着防守在那个唯一的连五点上，冲四就没法形成连五。④活三：可以形成活四的三，如下图，代表两种最基本的活三棋型。
五子棋简单AI算法（C#版）
Error的博客
06-28 4007
本文只提供AI算法，不提供棋盘，因为棋盘不是我写的，不好拿出来分享，望谅解。当前AI只能计算当前局面下最优的一步，没有深度，水平一般的普通人很轻易就会被其击败，但是有很大的升级空间，可以以此为基础再行添加算法添加深度，以及剪枝等算法。当前AI为黑色时水平较高，为白色时需要修改得分表，得分表会影响AI的决策，得分可以自行修改，此得分表并非最佳得分表，但是经过我的测试貌似还可以。ps：这是AI的核心非常重要得分表如下： AI算法思路讲解： 首先我们需要知道输入和输出，给输入当前棋盘的二维数组，从而让他返
五子棋(简易AI)
10-23
《五子棋(简易AI)》是一款融合了人工智能技术的五子棋小游戏，它通过采用极大极小搜索算法和估值函数，为玩家提供了一种既娱乐又富有挑战性的游戏体验。下面将详细介绍这款游戏的设计原理和相关知识点。 首先，我们...
java五子棋简易人机对战
05-13
【标题】"java五子棋简易人机对战"是一个基于Java编程语言实现的五子棋游戏，它包含了基本的人工智能对战功能，让用户可以与计算机进行对弈。这样的项目通常涉及到图形用户界面（GUI）的设计、算法的实现以及多线程...
简易人工智能五子棋java代码
07-12
这个项目的核心是利用Java语言编写的游戏逻辑和一个初级的人工智能算法。以下是对这个项目的详细解读： 1. **Java语言基础**：Java是一种广泛使用的面向对象的编程语言，具有跨平台、安全性高和可移植性好等特点。...
C++Builder 简易五子棋
02-21
【C++Builder简易五子棋】是一款基于C++Builder编程环境开发的桌面游戏，它实现了基本的五子棋对弈功能，让玩家可以与计算机或另一名玩家进行对战。这款程序展示了C++Builder在图形用户界面（GUI）设计和算法实现上...
五子棋简易人工智能的VB实现
08-12
标题“五子棋简易人工智能的VB实现”表明这是一个使用Visual Basic（VB）编程语言开发的项目，目的是创建一个五子棋游戏，其中包含了人工智能（AI）的简单实现。五子棋是一种双人策略游戏，目标是在棋盘上先连成五子...
五子棋AI（C++、QT）
HuanBianCheng27的博客
08-20 2068
学习视频链接五子棋-3_bilibili_哔哩哔哩_bilibili。
如何编写一个五子棋AI（附AI源码）
wangyuhan2010的博客
10-04 2068
三子棋的总局面数约为$549,946$，因此我们先以它为基础开始编写。
五子棋AI智能算法设计和测试方法
baidu_41801770的博客
06-26 1875
我对算法的思路是：黑棋的进攻点就是白棋的防守点，反之，白棋的进攻点就是黑棋的防守点。我的算法思路就这样。必杀局有双活三，双冲四，冲四加活三，嵌五加活三，嵌五加冲四，这些必杀局就是必胜法宝。if(pn[k-2]==0&&pn[k-1]==0&&pn[k]==1&&pn[k+1]==1&&pn[k+2]==1&&pn[k+3]==0&&pn[k+4]==0){ //左右。先前发了几篇五子棋游戏程序设计的博文，设计了游戏程序，也设计了AI智能奕棋的算法，运行程序检测算法的可行性，完成人机模式游戏功能的设置。
C语言五子棋高级ai算法
05-31
五子棋是一种比较复杂的游戏，需要设计高效的AI算法来实现自动下棋。以下是一些常用的C语言五子棋AI算法： 1. 极大极小值算法：这是一种基于博弈论的算法，通过递归搜索所有可能的棋局，评估每种情况的得分，然后选择得分最高或最低的落子位置。 2. Alpha-Beta剪枝算法：这是一种优化极大极小值算法的算法，通过剪枝减少搜索的次数，提高算法效率。 3. Monte Carlo树搜索算法：这是一种基于模拟的算法，通过随机模拟落子情况，评估每种情况的胜率，然后选择胜率最高的落子位置。 4. 深度学习算法：这是一种基于神经网络的算法，通过大量的训练数据来学习落子策略和评估函数，从而实现自动下棋。 以上是一些常用的C语言五子棋AI算法，开发者可以根据自己的需求选择合适的算法来实现自动下棋功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值