头歌平台-人工智能导论实验（博弈中的搜索）

最新推荐文章于 2024-05-01 12:15:08 发布
最新推荐文章于 2024-05-01 12:15:08 发布
阅读量1.4k 收藏 21
点赞数 2
文章标签： 大数据 python 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52119136/article/details/125457874
版权

极大极小法

 

# -*- coding:utf-8 -*-
import copy  # 注意对象的深拷贝和浅拷贝的使用！！！


class GameNode:
    '''博弈树结点数据结构
    成员变量：
    map - list[[]] 二维列表，三子棋盘状态
    val - int  该棋盘状态对执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
    deepID - int 博弈树的层次深度，根节点deepID=0
    parent - GameNode，父结点
    children - list[GameNode] 子结点列表
    '''

    def __init__(self, map, val=0, deepID=0, parent=None, children=[],child=[]):
        self.map = map
        self.val = val
        self.deepID = deepID
        self.parent = parent
        self.children = children
        self.child = child


class GameTree:
    '''博弈树结点数据结构
    成员变量：
    root - GameNode 博弈树根结点
    成员函数：
    buildTree - 创建博弈树
    '''

    def __init__(self, root):
        self.root = root  # GameNode 博弈树根结点

    def buildTree(self, root):
        '''递归法创建博弈树
        参数：
        root - GameNode 初始为博弈树根结点
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        if root.deepID > 5:
            return
        # 精华
        map = copy.deepcopy(root.map)
        for i in range(0,3):
            for j in range(0,3):
                if(map[i][j] == '_' or map[i][j] == ' '):
                    if root.deepID % 2 == 0:
                        map[i][j] = 'x'
                        node = GameNode(copy.deepcopy(map),deepID=root.deepID+1,parent=root,children=[],val=0,child=[])
                        root.children.append(node)
                        self.buildTree(node)
                        if len(node.children) == 0:
                            node.val = self.get_value(node)
                        map[i][j] = '_'
                    else:
                        map[i][j] = 'o'
                        node = GameNode(copy.deepcopy(map),deepID=root.deepID+1,parent=root,children=[],val=0,child=[])
                        root.children.append(node)
                        self.buildTree(node)
                        if len(node.children) == 0:
                            node.val = self.get_value(node)
                        map[i][j] = '_'
        # ********** End **********#

    def get_value(self, node):
        '''计算某棋盘状态中：执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - int 执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        for i in range(0, 3):
            if node.map[i][0] == node.map[i][1] == node.map[i][2]:
                if node.map[i][0] == 'x':
                    return 1
                else:
                    return -1
        for i in range(0, 3):
            if node.map[0][i] == node.map[0][i] == node.map[0][i] == 'x':
                if node.map[0][i] == 'x':
                    return 1
                else:
                    return -1

        if node.map[0][0] == node.map[1][1] == node.map[2][2]:
            if node.map[0][0] == 'x':
                return 1
            else:
                return -1
        if node.map[2][0] == node.map[1][1] == node.map[0][2]:
            if node.map[2][0] == 'x':
                return 1
            else:
                return -1

        return 0


class MinMax:
    '''博弈树结点数据结构
    成员变量：
    game_tree - GameTree 博弈树
    成员函数：
    minmax - 极大极小值算法，计算最优行动
    max_val - 计算最大值
    min_val - 计算最小值
    get_val - 计算某棋盘状态中：执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
    isTerminal - 判断某状态是否为最终状态：无空闲棋可走
    '''

    def __init__(self, game_tree):
        self.game_tree = game_tree  # GameTree 博弈树

    def minmax(self, node):
        '''极大极小值算法，计算最优行动
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - list[map] 最优行动，即x棋子的下一个棋盘状态GameNode.map
              其中，map - list[[]] 二维列表，三子棋盘状态
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        if len(node.children) != 0:
            for n in node.children:
                self.minmax(n)
        if node.deepID % 2 == 0:
            node.child,node.val = self.max_value(node)
            # if child != None:
            #     node.child.append(child.map)
            # else:
            #     node.child = []
        else:
            node.child,node.val = self.min_value(node)
            # if child != None:
            #     print(child.map)
            #     node.child.append(child.map)
            # else:
            #     node.child = []

        if node.deepID == 0:
            # print(child.map)
            ans_list = []
            for n in self.game_tree.root.child:
                ans_list.append(n.map)
            return ans_list
        # ********** End **********#

    def max_value(self, node):
        '''计算最大值
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - int 子结点中的最大的评估值
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        max = -2
        max_list = []
        for n in node.children:
            if self.get_value(n) >= max:
                max = self.get_value(n)
        for n in node.children:
            if n.val == max:
                max_list.append(n)
        return max_list,max
        # ********** End **********#

    def min_value(self, node):
        '''计算最小值
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - int 子结点中的最小的评估值
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        min_list = []
        min = 100000
        for n in node.children:
            if self.get_value(n) <= min:
                min = self.get_value(n)

        for n in node.children:
            if n.val == min:
                min_list.append(n)
        return min_list,min
        # ********** End **********#

    def get_value(self, node):
        '''计算某棋盘状态中：执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - int 执x棋子的评估值，1表示胜利，-1表示失败，0表示平局
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        for i in range(0,3):
            if node.map[i][0] == node.map[i][1] == node.map[i][2]:
                if node.map[i][0] == 'x':
                    return 1
                else:
                    return -1
        for i in range(0, 3):
            if node.map[0][i] == node.map[0][i] == node.map[0][i] == 'x':
                if node.map[0][i] == 'x':
                    return 1
                else:
                    return -1

        if node.map[0][0] == node.map[1][1] == node.map[2][2]:
            if node.map[0][0] == 'x':
                return 1
            else:
                return -1
        if node.map[2][0] == node.map[1][1] == node.map[0][2]:
            if node.map[2][0] == 'x':
                return 1
            else:
                return -1

        return 0
        # ********** End **********#

    def isTerminal(self, node):
        '''判断某状态是否为最终状态：无空闲棋可走（无子结点）
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - bool 是最终状态，返回True，否则返回False
        '''
        # 请在这里补充代码，完成本关任务
        # ********** Begin **********#
        for i in range(0,3):
            for j in range(0,3):
                if map[i][j] == '_':
                    return True
        return False
        # ********** End **********#

# -*- coding:utf-8 -*-
def printtree(list_,root, closed):

    if len(list_) == 0:
        return
    print("----这是第{}层------".format(root.deepID))
    for i in range(0,3):
        for j in range(0,3):
            print(root.map[i][j],end="")
        print("\n")
    print("\n")

    list_.remove(root)
    closed.append(root)
    for node in root.children:
        if node not in closed:
            list_.append(node)

    if(len(list_) != 0):
        printtree(list_,list_[0],closed)

阿尔法-白塔剪枝法

import copy     # 注意对象的深拷贝和浅拷贝的使用！！！

class GameNode:
    '''博弈树结点数据结构
    成员变量：
    name - string 结点名字
    val - int  结点值
    children - list[GameNode] 子结点列表
    '''
    def __init__(self, name='', val=0):
        self.name = name        # char
        self.val = val          # int
        self.children = []      # list of nodes

class GameTree:
    '''博弈树结点数据结构
    成员变量：
    root - GameNode 博弈树根结点
    成员函数：
    buildTree - 创建博弈树
    '''
    def __init__(self):
        self.root = None                # GameNode 博弈树根结点

    def buildTree(self, data_list, root):
        '''递归法创建博弈树
        参数：
        data_list - list[] like this ['A', ['B', ('E', 3), ('F', 12)], ['C', ('H', 2)], ['D', ('K', 14)]]
        root - GameNode
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#
        for i in range(1,len(data_list)):
            if type(data_list[i])==list:
                root.children.append(GameNode(data_list[i][0]))
                self.buildTree(data_list[i],root.children[i-1])
            else:
                root.children.append(GameNode(data_list[i][0],data_list[i][1]))


        #********** End **********#


class AlphaBeta:
    '''博弈树结点数据结构
    成员变量：
    game_tree - GameTree 博弈树
    成员函数：
    minmax_with_alphabeta - 带AlphaBeta剪枝的极大极小值算法，计算最优行动
    max_value - 计算最大值
    min_value - 计算最小值
    get_value - 返回结点的值
    isTerminal - 判断某结点是否为最终结点
    '''
    def __init__(self, game_tree):
        self.game_tree = game_tree      # GameTree 博弈树

    def minmax_with_alphabeta(self, node):
        '''带AlphaBeta剪枝的极大极小值算法，计算最优行动
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - GameNode 最优行动的结点
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#
        clf=self.max_value(node,-10000,10000)
        for child in node.children:
            if child.val==clf:
                return child;

        #********** End **********#


    def max_value(self, node, alpha, beta):
        '''计算最大值
        参数：
        node - GameNode 博弈树结点
        alpha - int 剪枝区间下限值
        beta - int 剪枝区间上限值
        返回值：
        clf - int 子结点中的最大的评估值
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#
        
        if self.isTerminal(node):
            return self.get_value(node)
        clf=-10000
        for child in node.children:
            clf=max(clf,self.min_value(child,alpha,beta))
            if clf>=beta:
                return clf
            alpha=max(alpha,clf)
        node.val=clf
        return clf


        #********** End **********#


    def min_value(self, node, alpha, beta):
        '''计算最小值
        参数：
        node - GameNode 博弈树结点
        alpha - int 剪枝区间下限值
        beta - int 剪枝区间上限值
        返回值：
        clf - int 子结点中的最小的评估值
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#
        if self.isTerminal(node):
            return self.get_value(node)
        clf=10000
        for child in node.children:
            clf=min(clf,self.max_value(child,alpha,beta))
            if clf<=alpha:
                return clf
            beta=min(clf,beta)
        node.val=clf
        return clf

        #********** End **********#


    def get_value(self, node):
        '''返回结点的值
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - int 结点的值，即 node.val
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#
        return node.val

        #********** End **********#


    def isTerminal(self, node):
        '''判断某结点是否为最终结点（无子结点）
        参数：
        node - GameNode 博弈树结点
        返回值：
        clf - bool 是最终状态，返回True，否则返回False
        '''
        #请在这里补充代码，完成本关任务
        #********** Begin **********#

        if node.val==0:
            return False
        else:
            return True
        #********** End **********#

白衣纵码
关注
实验一：人工智能之启发式搜索算法(含源码+实验报告）
Martin-share的博客
11-11 804
首先建立一个open表，一个close表，分别用于待存放的状态和已经使用过的状态。每次从open表中取出一个权值最小的状态，对其进行邻接点的扩展，在扩展时要考虑是否超出边界。扩展时的权值为f(n)=h(n)+g(n)，h(n)在本题中是欧式距离，g(n)在本题中是步长，走过的步数。若新的点在close表中，则舍去，若在open表中，则比较二者的权值，取最小的权值作为新的点。若都不存在，则把此状态添加到open表中，直到当前状态为目标状态。程序结束。
python博弈树_GitHub - xxttmmk/gobang_AI: 基于博弈树α-β剪枝搜索的五子棋AI
weixin_28733637的博客
12-24 761
最近机器学习很火， 乘着这把火，我也学习了一把，但是没有直接学习深度学习，而是遵从一位老前辈，一定要把人工智能的所有方法都了解掌握了，才能真正的掌握人工智能。。。 我只能说， 路漫漫。。对于博弈类人工智能，其中一个方法就是：博弈树极大极小值alpha-beta剪枝搜索。是不是觉得这个名字很牛逼， 但经过我的详细解读， 你马上就会发现，原来不过如此。对于要实现一个会智能下五子棋的AI，要怎么去实现呢...
【头歌答案】博弈中的搜索
weixin_44505587的博客
03-02 348
- [答案查询的**网页版入口**](https://edaser.github.io/) 并不是所有的关卡都有答案，有些只有部分关卡有 一定**不要直接复制答案哦**，实在不会做，在参考学习后要独立完成
头歌：博弈中的搜索（Python实现）
weixin_51539394的博客
03-31 2618
头歌平台：minmax算法的Python实现
头歌平台-人工智能实验（启发式搜索）
m0_51919640的博客
09-21 3712
人工智能，头歌，启发式搜索
人工智能（3）博弈中的搜索
artherlex的博客
06-20 620
博弈引入了对手来阻碍你达到目标。 1.博弈树 即全部的情况 2.启发式评估 给一个公式计算博弈结果的好坏 3.博弈树的极小化极大评估 4.α-β剪枝 与分支定界法类似 通过确定α和β值来剪枝 评估博弈树的重要工具 5.负极大值算法 对3的改进 6.渐进深化法 根据剩余搜索时间来选择搜索的深度 ...
南开大学-人工智能导论作业-深度学习练习.zip
03-09
《人工智能导论作业-深度学习练习》是南开大学针对人工智能专业学生提供的一份实践性学习资料，旨在帮助学生深入理解和应用深度学习技术。这份压缩包涵盖了与人工智能大作业、课程设计、毕业设计相关的学习资源，是...
人工智能实验二 利用α-β搜索的博弈树算法编写一字棋游戏
最新发布
2401_84769813的博客
05-01 993
当然还用一个评估函数，即getvalue()函数，用以对后续状态进行考虑，计算评估值，赢的评估值设为100，输的评估值设为-100，其他情况为 e(P)=e(那些仍为 MAX 空着的完全的行、列或对角线的总数)-e(那些仍为 MIN 空着的完全的行、列或对角线的总数)，通过评估值来表示赢面，数值最大时，为当前局面的最佳落棋位置。MAX节点的评估下限α设为第一个MIN子节点的值，若后续的子节点高于α，则取为新的α，而对于后续评估值小于等于α的节点的搜索可以停止，即进行了α剪枝。这一过程称为 α 剪枝。
哈尔滨工业大学计算机科学与技术专业人工智能导论课程实验源码和实验报告
06-21
在本资源中，我们主要关注的是哈尔滨工业大学计算机科学与技术专业的人工智能导论课程，该课程涵盖了几个关键的实验项目，包括NIM游戏、合一算法以及移动将牌问题。这些实验是理解人工智能基础概念和算法的重要实践...
AlphaBeta剪枝算法求解博弈树最优选择 头歌实验平台
qq_53437626的博客
10-04 2214
产生本文的缘由人工智能原理课程 可选实验 “AlphaBeta剪枝算法求解博弈树最优选择”,以及去年在数据结构导论没有看明白的博弈论.记录自己的学习过程. 注:本文适合有一定基础的读者阅读.以下是本篇文章正文内容。
基于Python进行博弈树搜索（人工智能实验）【100011562】
04-04
博弈树针对的是二人零和博弈的问题，二人轮流行动，行动时令自己的优势最大。二人零和博弈有如下特点： 确定性：二人的行动有多种选择，但最终的行动是确定的 信息完备性：博弈双方知道当前局势（即空间状态）的全部信息 零和性：一方的损失等于另一方的收益，二者得分相加恒为零 由以上特点，我们可以构造博弈树。因为信息完备性和确定性，可以用博弈树的每个节点表示一个确定的状态，在动作后得到的新状态作为子节点。对于每个状态都有同一个评价函数来评估双方的得分。因为零和性，一方通过决策使得自身的评价函数尽可能的大，另一方让队手的评价函数尽可能的小。因为二者是轮流行动的，在树的每一层让一方的评价函数取最大和最小交替进行。
头歌启发式搜索算法参考答案
06-06
代码答案
博弈树（树的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
人工智能导论_实验二.doc
01-14
实验报告——人工智能导论 本实验旨在理解和应用人工智能的基本原理，特别是状态空间搜索法，解决实际问题。状态空间是描述问题所有可能状态的集合，它包括初始状态、操作（算符）以及状态间的转换。在状态空间搜索...
人工智能第2版学习——博弈中的搜索1
weixin_45034895的博客
08-21 1180
博弈树、极小化极大化评估、α-β剪枝
利用α-β搜索的博弈树算法编写一字棋游戏 python
监心司的博客
03-16 4701
游戏规则 “一字棋"游戏（又叫"三子棋"或"井字棋”），是一款十分经典的益智小游戏。“井字棋"的棋盘很简单，是一个 3×3 的格子，很像中国文字中的"井"字，所以得名"井字棋”。"井字棋"游戏的规则与"五子棋"十分类似，"五子棋"的规则是一方首先五子连成一线就胜利；“井字棋"是一方首先三子连成一线就胜利。 极小极大分析法 设有九个空格，由 MAX，MIN 二人对弈，轮到谁走棋谁就往空格上放一只自己的棋子，谁先使自己的棋子构成"三子成一线”(同一行或列或对角线全是某人的棋子)，谁就取得了胜利。 估价函数定义如
使用 Python3 实现博弈树分析器 找最优得益及对应策略
m0_61227501的博客
12-09 724
抱歉刚刚没有出手，但现在我不禁又出手了，如果我们人类总是想出手，那我们的未来该如何出手？在这里我不禁想问，出手的奥秘是什么呢？无法出手的意义又是什么呢？是什么促使我们不想出手？
人工智能第2版学习——博弈中的搜索2
weixin_45034895的博客
08-22 928
负极大值算法、渐进深化法、地平线效应、概率游戏和预期极小化极大值算法、囚徒困境
人工智能导论-王万良测试题及答案解析
"人工智能导论王万良-测试答案" 这篇资源主要涵盖了人工智能的基础知识，包括人工智能的定义、特征、衡量...以上内容详细解释了人工智能导论中涉及的一些基本概念、理论和算法，这些都是理解和研究人工智能的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值