精华内容
下载资源
问答
  • 井字棋决策的Cpp描述

    2019-09-14 22:51:30
    井字棋决策的Cpp描述 本文在vs17环境下对井字棋的决策算法做出了部分解释 博弈双方的棋权,运用了布尔型变量 通过对布尔型变量的次序互换实现双方函数的交替运行 char ww, X, O; int qz; bool h; static ...

    井字棋决策的Cpp描述

    本文在vs17环境下对井字棋的决策算法做出了部分解释

    博弈双方的棋权,运用了布尔型变量

    通过对布尔型变量的次序互换实现双方函数的交替运行

    	char ww, X, O;
    	int qz;
    	bool h;
    	static int number=0;
    
    	//先手的初始化
    	cout << "开始"<<endl;
    	//cout << "请选择X或O作为棋子:";
    	while(number==0)
    	{
    		cin >> ww;
    		if (ww == 'X')
    		{
    			input_player_x(number+1);
    			number++;
    			h = true;
    		}
    		else if (ww == 'O')
    		{
    			input_player_o(number+1);
    			number++;
    			h = false;
    		}
    	}
    	//棋权的互换和胜利算法
    	while (number < 9&&number>0)
    	{
    		cin >> qz;
    		output_vector(qz);
    		if (h == true)
    		{
    
    			input_player_x(qz, number + 1);
    			number++;
    			h = false;
    		}
    		if (h == false)
    		{
    			input_player_o(qz,number + 1);
    			number++;
    			h = true;
    		}
    	}

    棋盘中棋子位置的叙述采对用二维数组赋值,也可以采用vector容器

    	vector<int> number;
    	for (int i = 0; i < n; i++)
    	{
    		number.push_back(qz);    //向这个vector中添加元素
    	}

    胜利决策只需要判断棋盘上的总棋子数以及在下一个棋子落下的上一个函数进行x,o字符的逐行逐列、对角线进行胜利决策

    采用二维数组对字符串进行操作

     

        我的GitHubhttps://github.com/TYduoduo

    展开全文
  • 返回true当且仅当在一个合法的井字棋游戏当中可能到达当前这种棋盘情况。 board是一个 3 x 3 的数组, 包含字符' ', 'X', 和'O'。字符 ’ '意味着这一格是空的。 以下是井字棋的游戏规则: 玩家需要轮流在空格上...

    描述

    一个井字棋盘以字符串数组 board的形式给出。返回true当且仅当在一个合法的井字棋游戏当中可能到达当前这种棋盘情况。

    board是一个 3 x 3 的数组, 包含字符' ', 'X', 和'O'。字符 ’ '意味着这一格是空的。

    以下是井字棋的游戏规则:

    • 玩家需要轮流在空格上放置字符。
    • 第一个玩家总是放置'X'字符,第二个玩家总是放置'O'字符。
    • 'X''O'总是被放置在空格上,不能放置在已有字符的格子上。
    • 当有3格相同的(非空)字符占据一行、一列或者一个对角线的时候,游戏结束。
    • 当所有格子都非空的时候游戏也结束。
    • 游戏结束后不允许多余操作。

    说明

    • board 是一个长度为3的字符串数组,其中每一个字符串 board[i]的长度为3.
    • 每一个 board[i][j]是一个在集合{' ', 'X', 'O'}当中的字符.

    样例

    - 样例1:
    
    输入:board = ["O  ", "   ", "   "]
    输出:false
    解释:第一个玩家总是放置"X".
    
    - 样例2:
    
    输入: board = ["XOX", " X ", "   "]
    输出: false
    解释:玩家轮流操作.
    
    - 样例3:
    
    输入: board = ["XXX", "   ", "OOO"]
    输出: false
    
    - 样例4:
    
    输入: board = ["XOX", "O O", "XOX"]
    输出: true
    

    解析

    const validTicTacToe = function (board) {
        let oCount=0,xCount=0;
        for(let i=0;i<board.length;i++){
            for(let j=0;j<board[i].length;j++){
                board[i][j]==="X"&&xCount++
                board[i][j]==="O"&&oCount++
            }
        }
        //X和O的个数不相等且X的个数并没与比O多1,则没人获胜
        if(xCount!==oCount&&xCount!==oCount+1) return false;
        //假如X获胜,但是X的数量并没有比O多1
        if(win(board,"X")&&xCount!==oCount+1) return false;
        //假如O获胜,但是O的数量与X的数量不相等
        if(win(board,"O")&&xCount!==oCount) return false;
        return true;
    };
    function win(board,P){
        for(let i=0;i<board.length;i++){
            //同一行字符一样
            if(board[i][0]===P&&board[i][1]===P&&board[i][2]===P){
                return true
            }
            //同一列字符一样
            if(board[0][i]===P&&board[1][i]===P&&board[2][i]===P){
                return true
            }
          
        }
        //对角线的字符是否一样
          if(board[0][0]===P&&board[1][1]===P&&board[2][2]===P){
                return true
            }
            if(board[0][2]===P&&board[1][1]===P&&board[2][0]===P){
                return true
            }
        return false
    
    }
    

    运行结果

    在这里插入图片描述

    展开全文
  • 井字棋

    2020-05-04 14:36:36
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 思路: 题目很简单...

    井字棋

    题目描述:

    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。
    给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。

    思路:

    题目很简单,判断玩家赢:玩家用1表示,且是井字棋,3 * 3的,那么直接按照规则,判断横行相加是否为3,列相加是否为3,对角线相加是否为3即可。

    方法二:扩展到n行n列:看代码把,一看就懂。

    bool checkWon(vector<vector<int> > a) {
           if(a[0][0]+a[1][1]+a[2][2]==3) 
               return true;
           if(a[0][2]+a[1][1]+a[2][0]==3) 
               return true;
           for(int i=0;i<3;i++){
                if(a[i][0]+a[i][1]+a[i][2]==3) 
                   return true;
                if(a[0][i]+a[1][i]+a[2][i]==3) 
                   return true;
           }
           return false;
        }
    -----------------------------------------------------------
    class Board {
    public:
        bool checkWon(vector<vector<int> > board) {
            // write code here
            int size = board[0].size();
            for(int i = 0; i < board.size(); i++)
            {
                int sum = 0;
                for(int j = 0; j < size; j++)
                {
                    sum += board[i][j];
                }
                if(sum == size) // 检查行
                    return true;
            }
               for(int i = 0; i < board.size(); i++)
            {
                int sum = 0;
                for(int j = 0; j < size; j++)
                {
                    sum += board[j][i];
                }
                if(sum == size)//检查列
                    return true;
            }
            int tmp = 0;
            for(int i = 0; i < size; i++)
            {
                tmp += board[i][i];//主对角线
            }
            if(tmp == size)
                return true;
            tmp = 0;
            for(int i = 0; i < size; i++)
            {//副对角线
                tmp += board[i][size - i - 1];
            }
            if(tmp == size)
                return true;
            return false;
        }
    };
    
    展开全文
  • 比如在井字棋中,总利益为0,以玩家A的视角看,A取得胜利获得的利益是1,则B在A获得胜利的情况下获得的利益则为-1,反之亦然,双方的利益总和为0。 棋类游戏是双方交替下棋的游戏,每一次落子都代表落子的

    极小极大值搜索算法MinimaxSearch

    算法描述

    极小极大值搜索算法,MinimaxSearch算法,是一种零和算法,是用来最小化对手的利益,最大化自己的利益的算法。
    极小极大之搜索算法常用于棋类游戏等双方较量的游戏和程序,算是一种电脑AI算法。
    该算法是一种总零和算法,即双方的利益对立,利益的总和为0。比如在井字棋中,总利益为0,以玩家A的视角看,A取得胜利获得的利益是1,则B在A获得胜利的情况下获得的利益则为-1,反之亦然,双方的利益总和为0。

    棋类游戏是双方交替下棋的游戏,每一次落子都代表落子的一方在当前情况下要选择对自己利益最大化的一步棋,极小极大值搜索算法就是模拟利益选择的过程,来找到对自己利益最大化的那一步的算法。

    使用极小极大搜索算法,通常要建立一棵搜索树在这里插入图片描述
    如图是一个简单的搜索树,树的最低层是在搜索深度下可以评估到的各种情况产生的利益(对于某一方而言)。
    如图搜索深度为4,也就是这个搜索树可以看到之后4步的情况,根据4步之后的各种情况,来选择根节点这一层该走哪一步棋,最多可以取得多少的利益。
    从玩家A的视角来看,玩家A先落子,所以他希望这一步棋可以最大化他的利益,所以玩家A需要在下一层中找到利益最大的那一种情况。而在玩家A落子之后,玩家B落子的时候,希望这一步棋可以最小化玩家A的利益,所以在第二层中,玩家B需要找到第三层中玩家A利益最小化的一步。
    以此类推,直到达到搜索深度的最后,在这一步评估各种情况下的利益值,然后从下往上,根据每一层需要的是最大值还是最小值,来一步一步往上传递到最高层,让最高层知道自己应该走哪一步。

    在极小极大值算法中,最关键的就是评估函数,用来评估各种情况下产生的利益。

    井字棋

    在学习了极小极大搜索算法之后,我们来做一个简单的井字棋游戏来练习。
    代码有参考博客极小值极大值算法-井字棋
    (代码经过评论区指正已经改正)

    #include<iostream>
    #include<stdlib.h>
    #include<conio.h>
    #include<algorithm>
    using namespace std;
    
    #define N 3
    #define STEP 9
    #define MAN 1
    #define COM -1
    #define SEARCHDEPTH 9
    
    int isEnd();
    int Evaluate();
    int MinimaxSearch(int depth);
    void Init();
    
    
    
    struct pos
    {
    	int x;
    	int y;
    };
    
    
    int board[3][3] = { {0,0,0},{0,0,0} ,{0,0,0}};
    
    int player = 0;
    
    pos BestPos;
    
    int curDepth = 0;
    
    bool isGameover=false;
    
    
    
    void Init()
    {
    	for (int i = 0;i < N;i++)
    	{
    		for (int j = 0;j < N;j++)
    		{
    			board[i][j] = 0;
    		}
    	}
    	player = MAN;
    	isGameover = false;
    	curDepth = 0;
    }
    
    void DrawBoard()
    {
    	system("cls");
    	cout << "-------" << endl;
    	cout << "|" <<board[0][0]<< "|" << board[0][1] << "|" << board[0][2] << "|" << endl;
    	cout << "-------" << endl;
    	cout << "|" << board[1][0] << "|" << board[1][1] << "|" << board[1][2] << "|" << endl;
    	cout << "-------" << endl;
    	cout << "|" << board[2][0] << "|" << board[2][1] << "|" << board[2][2] <<"|"<<endl;
    	cout << "-------" << endl;
    }
    
    int Evaluate()
    {
    	int value = isEnd();
    	if (value == MAN)return INT_MAX;
    	if (value == COM)return INT_MIN;
    
    	return value;
    }
    
    int isEnd()
    {
    	int i, j;
    	int count = 0;
    	for (i = 0;i < N;i++)   //行
    	{
    		count = 0;
    		for (j = 0;j < N;j++)
    			count += board[i][j];
    		if (count == 3 || count == -3)
    			return count / 3;
    	}
    	for (j = 0;j < N;j++)   //列
    	{
    		count = 0;
    		for (i = 0;i < N;i++)
    			count += board[i][j];
    		if (count == 3 || count == -3)
    			return count / 3;
    	}
    	count = 0;
    	count = board[0][0] + board[1][1] + board[2][2];
    	if (count == 3 || count == -3)
    		return count / 3;
    	count = board[0][2] + board[1][1] + board[2][0];
    	if (count == 3 || count == -3)
    		return count / 3;
    	return 0;
    }
    
    
    int MinimaxSearch(int depth)
    {
    	int value=0;
    	if (player == MAN) value = INT_MIN;
    	if (player == COM) value = INT_MAX;
    	if (isEnd() != 0)
    	{
    		return Evaluate();
    	}
    	if (depth == SEARCHDEPTH)
    	{
    		value = Evaluate();
    		return value;
    	}
    
    	for (int i = 0;i < N;i++)
    	{
    		for (int j = 0;j < N;j++)
    		{
    			if (board[i][j] == 0)
    			{
    				if (player == MAN)
    				{
    					board[i][j] = MAN;
    					player = COM;
    					int nextvalue = MinimaxSearch(depth + 1);
    					player = MAN;
    					if (value < nextvalue)
    					{
    						value = nextvalue;
    						if (depth == curDepth)
    						{
    							BestPos.x = i;
    							BestPos.y = j;
    						}
    
    					}
    
    				}
    				else if (player == COM)
    				{
    					board[i][j] = COM;
    					player = MAN;
    					int nextvalue = MinimaxSearch(depth + 1);
    					player = COM;
    					if (value>nextvalue)
    					{
    						value = nextvalue;
    						if (depth == curDepth)
    						{
    							BestPos.x = i;
    							BestPos.y = j;
    						}
    
    					}
    				}
    				board[i][j] = 0;
    			}
    
    		}
    	}
    
    	return value;
    }
    
    void COMplay()
    {
    	MinimaxSearch(curDepth);
    	board[BestPos.x][BestPos.y] = COM;
    	curDepth++;
    	player = MAN;
    }
    
    void MANplay(int x, int y)
    {
    	board[x][y] = MAN;
    	curDepth++;
    	player = COM;
    	
    }
    
    void input()
    {
    	if (_kbhit())
    	{
    		char c = _getch();
    		if (!isGameover)
    		if (c >= '1' && c <= '9')
    		{
    			int posnum = c - '1';
    			int posx = posnum / 3;
    			int posy = posnum % 3;
    			MANplay(posx, posy);
    			if (isEnd() == 0&&curDepth<8)
    			{
    				COMplay();
    				if (isEnd() != 0)
    				{
    					isGameover = true;
    				}
    			}
    			else
    			{
    				isGameover = true;
    			}
    		}
    		if (isGameover)
    		{
    			if (c == 'r' || c == 'R')
    			{
    				Init();
    			}
    		}
    	}
    
    }
    
    void Logic()
    {
    	if (isGameover)
    	{
    		if (isEnd() == MAN)
    		{
    			cout << "游戏结束 玩家胜利" << endl;
    		}
    		else if (isEnd() == COM)
    		{
    			cout << "游戏结束 电脑胜利" << endl;
    		}
    		else
    		{
    			cout << "游戏结束 平局" << endl;
    		}
    
    		cout << "按R键重开" << endl;
    	}
    
    }
    
    int main()
    {
    	Init();
    	while (1)
    	{
    
    		input();
    		Logic();
    		DrawBoard();
    
    	}
    }
    

    拓展Alpha-Beta剪枝算法

    现在我们做的是简单的井字棋游戏,游戏一共最多只有9步,所以我们的搜索深度可以一直搜索到底,我们的搜索树也不会特别大。

    但是如果我们要做一个围棋,或者是五子棋的极大极小搜索,那所产生的搜索树将会呈指数级的增长,我们没有办法将整个棋局搜索到底。
    而减少搜索深度虽然可以减少搜索树的大小,但是也会降低人工智能的精度,治标不治本。
    为了让我们的算法在五子棋和围棋这样复杂的棋局中也可以使用,我们需要对我们的搜索树进行剪枝,来减除一些不必要的运算。
    而这一部分的算法就是Alpha-Beta算法
    Alpha-Beta算法,未完待续哈哈哈哈哈(下次再写【)

    展开全文
  • 编程题——井字棋

    千次阅读 2019-06-03 21:21:26
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 本代码适用于所有...
  • Java 井字棋

    2019-08-22 15:50:55
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 测试样例: [...
  • 题目描述 (1)图形化界面。 (2)随机选取先手后手。 (3)可以人-计算机或计算机-计算机 算法 α是MAX至今为止的路径上所有选择点中发现的最好选择的值,即是最大值。 如果v比α差,MAX会避免它,即发生剪枝。 ...
  • 题:井字棋

    2019-08-01 12:08:13
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 示例:输入:[[1...
  • 牛客网--关于井字棋

    2019-08-14 20:30:13
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 代码 import java....
  • 对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 ...
  • 【牛客网】井字棋

    2019-06-02 18:51:26
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代 表是对方玩家的棋子。 测试样例: [[1,...
  • [C++] 24992 -- 井字棋

    2019-08-11 20:27:10
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 示例1: 输入: ...
  • 牛客网:井字棋

    2019-05-30 16:58:50
    链接:...对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组boar...
  • 对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 测试样例: ...
  • [每日一题]58:井字棋

    2020-05-12 10:21:28
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 测试样例: [[1,0,...
  • 欢迎点击「算法与编程之美」↑关注我们!本文首发于微信公众号:"算法与编程之美",欢迎关注,及时了解更多此系列文章。问题描述A 和 B 在一个 3 x 3 的网格上玩井字棋...
  • C/C++_2019_7_11(井字棋)

    2019-07-30 00:37:34
    “人可以无知,但不可以无趣”. ...井字棋 | 时间限制:3秒 | 内存限制:32768K | 语言限制:[Python, C++, C#, Java] 对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二...
  • 但是环境类中的4个函数都是空的,本文将描述怎么实现那4个函数,实现一个完整的井字棋游戏的环境。 游戏规则:两个玩家在3x3的棋盘上,一方执X,一方执O。哪方先下的连续3个子(不管在对角,竖直还是水平方向)为胜...
  • 对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 测试样例: [[1,0,...
  • 子棋

    2020-03-06 23:09:54
    对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 测试样例: [[1,0,...
  • 一、问题描述 三连双方都是智力卓越的话,很容易完成平局;在人机对战情况下, 计算机的策略是保证自己不输,并等待玩家失误的机会,当玩家失误时候, 计算机抓住这个失误并取得胜利; ** 极大极小策略** 使用一个...
  • 问题描述: 附件中包含的数据是传统游戏过三关(tic-tac-toe)的900余种棋局, 目的是要通过统计学习的方法让机器自动判别出胜负。数据文件中, 玩家是'x',对手是'o',每行数据包含3*3九宫格的布局情况('x'代表玩家...
  • 问题描述设计一个算法,判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘,由字符" ","X"和"O"组成,其中字符" "代表一个空位。以下是井字游戏的规则:玩家轮流将字符放入空位(" ")中。第一个玩家总是放字符...
  • 设计一个算法,判断玩家是否赢了井字游戏。输入是一个 N x N 的数组棋盘,由字符" ",“X"和"O"组成,其中字符” "代表一个空位。 以下是井字游戏的规则: 玩家轮流将字符放入空位(" “)中。 第一个玩家总是放字符...
  • 问题描述:问题描述 Alice和Bob正在玩井字棋游戏。  井字棋游戏的规则很简单:两人轮流往3*3的棋盘中放棋子,Alice放的是“X”,Bob放的是“O”,Alice执先。当同一种棋子占据一行、一列或一条对角线的三个格...
  • 每日一题3.14

    2019-03-21 15:56:31
    题目描述井字棋 对于一个给定的井字棋棋盘,请设计一个高效算法判断当前玩家是否获胜。 给定一个二维数组board,代表当前棋盘,其中元素为1的代表是当前玩家的棋子,为0表示没有棋子,为-1代表是对方玩家的棋子。 ...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

井字棋算法描述