五子棋 算法-- 只考虑当前利益

最新推荐文章于 2024-07-25 12:55:52 发布
最新推荐文章于 2024-07-25 12:55:52 发布
阅读量646 收藏
点赞数
分类专栏： VC++、Window编程 文章标签： 算法 c struct 数据结构 class null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kervinwu/article/details/3195003
版权
#ifndef FIVECHESS_H
#define FIVECHESS_H
#define Board_LEN 15
#define Board_WID 15

// 定义 点的数据结构
typedef struct point {
   int x;
   int y;
   int mark;
}Point ;

//定义 走棋步骤链表  
typedef struct ChessStep
{
    Point             m_point;
    ChessStep     *PreStep;
ChessStep     *NextStep;
}StepList;



//棋盘类
class Board
{
public:
Board();
bool SetPoint( Point );     //落子
int getPoint( Point &);     //检查该点 
void  showBoard();
const StepList * getCurStep();

int    Revblacks();   // 返回当前棋盘 黑棋数
int    Revwhites();   // 返回当前棋盘 白棋数

bool GameOver(int );  //游戏结束 ？
bool GmOver;
private:
int m_Board[Board_LEN][Board_WID];   //棋盘的大小
    StepList    h_steps;   //走棋的顺序表 表头
StepList   *cur ;          //当前点的
    int                 iblacks;
    int                 iwhites;
};


//
class Player
{
public:
const enum Mark{ black = 1 , white = 2};
Player();
bool chkSide(Board  &, Point  ,int ,int,int (&board)[Board_LEN][Board_WID][4] ); // 从两个方向 判断一个点的权值
bool chkWeight( Board & , int (&board)[Board_LEN][Board_WID][4]);   //判断当前玩家的棋型，为棋型表 赋值
bool clearWeight();   // 将权值表 清0 便于下次判断
//bool chkCmpterWgt( Board &);  
Point MaxWeight(int (&board)[Board_LEN][Board_WID][4],Point & ,Board &);
    bool chkMode( Board &);   //判断先后手 ；
Point  Analyse(Board &);       //分析并 返回 下棋点；
void showCptWght();               // 打印 电脑棋型的 权值表
    void showGmrWght();             // 打印 选手棋型的权值表
private:
int  gamerBoardWgt[Board_LEN][Board_WID][4];     // 保存选手棋盘上各点4个方向棋型的权值
int  computerBoardWgt[Board_LEN][Board_WID][4];  //保存电脑棋盘上各点4个方向棋型的权值
int  mark ;    //标记 先手还是后手即 执 黑或白
int  mode;    //标记 当前是进攻还是防守

};

class Control
{
public:
  const enum Mode {Gamer =1 ,Computer};
  Control();
  //~Control();
  bool ModeSwitch();  //转换 走子方
 
  bool Control::inputPoint(Point & ,Board &);
  bool MainCtrl(Board &,Player &);  //控制 游戏主体 流程
  //Point goChess(Point);  // 走子
  int getPlayer();           //判断当前走棋方
private:
  Mode  player;
};

#endif

############################################################################################
#include <iostream>
#include "FiveChess.h"
using namespace std;


//初始化棋盘
Board::Board()
{
    for(int i = 0 ; i < Board_LEN;  i++)
{   
for(int j = 0 ; j < Board_WID; j ++)
   m_Board[i][j] = 0;
}
    h_steps.PreStep = NULL;
h_steps.m_point.mark = NULL;
h_steps.NextStep = NULL;
iblacks = iwhites = 0;
cur = &(h_steps);
this->GmOver = false;
};

int Board::ChkChess(int side,int dir ,int color,int x,int y)
{
   int c = 0 ;
   switch(dir)
  {
  case 0 :
  for( c = 0 ; c < 6 ; ++c)
  {
    if( y+c*side > 0 && y+c*side <Board_WID )
{
  if( color == m_Board[x][y+c*side] )
  {
    continue;
  }
  else 
    return c;
}
else 
return c;    
  }
  case 1:
  for( c = 0; c < 6 ; ++c)
  {
    if( x+c*side >0 && x+c*side < Board_WID)
{
  if(color == m_Board[x+c*side][y])
  continue;
  else
  return c;
}
else
return c;
  }
  case 2:
  for( c =0 ; c < 6 ; ++c)
  {
    if(x-side*c >= 0 && x-side*c < Board_LEN 
  && y-side*c >=0 && y-side*c< Board_WID)
{
  if(color == m_Board[x-side*c][y-c*side])
   continue;
  else
  return c;
}
else
return c;
  }
  case 3:
   for(c = 0; c < 6 ; ++c)
   {
     if(x+side*c >= 0 && x+side*c < Board_LEN 
    && y-side*c >=0 && y-side*c< Board_WID)
 {
   if(color == m_Board[x+side*c][y-c*side])
continue;
else
return c;
 }
  else
   return c;
   }
  default :
  return c;
   }

}
bool Board::GameOver()
{
// this->SetPoint(p);
int count = 0;
for(int x = 0 ; x < Board_LEN ; ++x)
    for( int y = 0 ; y < Board_WID ; ++y)
{
if(black == m_Board[x][y])
{ 
for(int direct = 0 ; direct < 4; ++direct)
 {
   count = 0;
   //一个方向 判断 棋型
count +=  ChkChess( 1,direct,black,x,y);
           // count +=  ChkChess(-1,direct,black,x,y);
if(count >= 5)
{
cout << "black win" << endl;
return GmOver=true;
}
 }
 
}
else if(white == m_Board[x][y])
{
 for(int direct = 0 ; direct < 4; ++direct)
 {
   //一个方向 判断 棋型
   count = 0;
count +=  ChkChess( 1,direct,white,x,y);
            //count +=  ChkChess(-1,direct,white,x,y);
  if(count >= 5)
  {
    cout << "white win " <<endl;
    return GmOver=true;
    }
 }

} 


}
return false;
};

int Board::Revblacks()
{
  return iblacks;
};

int Board::Revwhites()
{
  return iwhites;
};
//填写当前棋盘
bool Board::SetPoint(Point p)          
{
m_Board[p.x][p.y] = p.mark;
if(p.mark == 1)
++iblacks;
else
++iwhites;
 
cur ->m_point.mark = p.mark;
cur ->m_point.x = p.x ;
cur ->m_point.y = p.y ;
     
//新增加点的记录 
cur ->NextStep= new StepList;
cur ->NextStep->PreStep = cur;
cur = cur ->NextStep;
cur->NextStep = NULL;
 


return true;
};
const StepList * Board::getCurStep()
{
  return  cur;
};
//打印 当前棋盘
void Board::showBoard()
{
   for(int i = 0 ;  i < Board_LEN ; i ++)
   {    
  for (int j = 0 ; j < Board_WID ; j ++)
    cout <<m_Board[i][j] <<' ';
      cout << endl;   
   }
   cout << endl;
};

//返回当前点的 状态
int Board::getPoint(Point &p)
{
return   m_Board[p.x][p.y];
};

//初始 电脑 和 选手的棋型 权值表

Player::Player(  )
{
     for(int i = 0 ; i < Board_LEN;  i++)
{ 
for(int j = 0 ; j < Board_WID; j ++)
{
for ( int d= 0 ; d < 4 ; d ++)
{
gamerBoardWgt[i][j][d] = 0;
computerBoardWgt[i][j][d]  = 0 ;
}
}
}
//mark = m;  // 指定 先后手 
};

bool Player::chkSide(Board  &board, Point p , int  s,int d,int (&myChessWeight)[Board_LEN][Board_WID][4])
{
  int weight ;
  int x = p.x ;
  int y = p.y;
  Point p1;
  p1.mark = mark;  //当前的走子方
  switch(d)
  {
  case 0 :   // 垂直方向上的棋型
          // 对一 个方向上的棋子个数 记录
for( int c = 0 ; c < Board_LEN - y ; ++c)  
{
//越界 检查
if( y + s*(c+1) >= 0 && y +s*(c+1) < Board_WID)
{
p1.x = x ;
p1.y = y +s*(c+1);
//if( c > 5 )  //胜利条件 判断
//{
// board.GameOver(p1);
// return 0;
//}
  if( board.getPoint(p1) == 0 )
{
if( c != 0) //对于棋型是否是 冲 还是活的判断
      myChessWeight[x][y][d] += 1;  
 return 0 ; 
}
else if( board.getPoint(p1) == mark)
{
weight = 1; //个数 赋权值
myChessWeight[x][y][d] += weight*10 ; 
}
else 
return 0;
}
else 
return 0 ;
}
return 0 ;
  case 1:
 for( int c = 0 ; c < Board_LEN - x; ++c)
{
if( x+s*(c+1) >= 0 && x+s*(c+1) < Board_LEN )
{
p1.x = x +s*(c+1);
p1.y = y;
  // if( c > 5)
//{
// board.GameOver(p1);
// return 0;
//}
if( board.getPoint(p1) == 0 )
{
if( c != 0)
      myChessWeight[x][y][d] += 1;  
 return 0 ; 
}
else if(board.getPoint(p1) == mark)
{
weight = 1; 
myChessWeight[x][y][d] += weight*10; 
}
      else 
return 0;
}
else 
return 0 ;
}
   return 0 ;
  case 2 :
for( int c = 0 ; c <Board_LEN - x; ++c)
{
if(x+s*(c+1) >= 0 && x+s*(c+1)<Board_LEN && y-s*(c+1)>= 0 && y-s*(c+1)<Board_WID)
 
{
p1.x = x+s*(c+1);
p1.y = y-s*(c+1);
//if( c > 5)
//{
// board.GameOver(p1);
// return 0;
//}
if( board.getPoint(p1) == 0 )
{
if( c != 0)
       myChessWeight[x][y][d] += 1;  
 return 0 ; 
}
else if(board.getPoint(p1) == mark)
{
weight = 1; 
myChessWeight[x][y][d] += weight*10; 
}
else 
return 0;
}
else 
return 0 ;
}
   return 0 ;
  case 3:
 for( int c = 0 ; c < Board_LEN - x; ++c)
{
if(x+s*(c+1)>= 0 && x+s*(c+1) < Board_LEN && y+s*(c+1)>=0 && y+s*(c+1)< Board_WID)
{
p1.x = x+s*(c+1);
p1.y = y+s*(c+1);
//if( c > 5)
//{
// board.GameOver(p1);
// return 0;
//}
if( board.getPoint(p1) == 0 )
{
if( c != 0)
 myChessWeight[x][y][d] += 1;    return 0 ; 
}
else if(board.getPoint(p1) == mark)
{
weight = 1; 
myChessWeight[x][y][d] += weight*10; 
}
else 
return 0 ;
}
else 
return 0 ;
}
   return 0 ;
  default :
 cout << "error direct " << endl;
 return 0 ;

  }
};

// 权值表 清零 便于 重新判断 
bool Player::clearWeight()
{
   for(int x = 0 ; x < Board_LEN ; ++x)
  for(int y = 0 ;  y <Board_WID; ++y)
  {
  for (int d= 0 ; d< 4; ++d)
  {
  this->gamerBoardWgt[x][y][d] = 0;
  this->computerBoardWgt[x][y][d] = 0;
  }
  }
  return 0;
};
// 扫描己方棋盘的棋型，4个方向进行赋权值 
bool Player::chkWeight( Board &cBoard, int (&b)[Board_LEN][Board_WID][4])
{
     Point  p ;
int  s = 1;

for( int i = 0 ;  i < Board_LEN ; ++i)
{
for ( int j = 0 ; j <Board_WID ; ++j)
{
p.x = i ;  p.y = j;
   //判断是否是空白点
   if( 0 == cBoard.getPoint(p) )  
 {  
 for( int direct = 0; direct < 4 ;  ++direct)
 { 
      chkSide(cBoard, p,s,direct,b);   // 对一个点的在一个方向上两面 棋型判断
  chkSide(cBoard, p,-s,direct,b);
 }
 }
}
}
return 0 ;
};
// 打印电脑棋型的 权重值表
void Player:: showCptWght()
{
   for(int i = 0 ; i < Board_LEN ; i ++)
   {
  for (int j = 0 ; j < Board_WID ; j++)
  {
 for(int d= 0 ; d <4 ; d++)
  cout  << computerBoardWgt[i][j][d] << ' ' ;
 cout << endl ;
  }
  cout << endl;
   }
};
//打印选手棋型的 权值表
void Player::showGmrWght()
{
   for(int i = 0 ; i < Board_LEN ; i ++)
   {
  for (int j = 0 ; j < Board_WID ; j++)
  {
 for(int d= 0 ; d <4 ; d++)
  cout  << gamerBoardWgt[i][j][d] << ' ' ;
 cout << endl ;
  }
  cout << endl;
   }
};

//判断  棋盘走棋的 先后手 
bool Player::chkMode(Board &b)
{
if( b.getCurStep()->PreStep->m_point.mark == NULL)
this ->mark = black;
else if( b.getCurStep()->PreStep->m_point.mark == black)
mark = white;
else if(b.getCurStep()->PreStep->m_point.mark == white)
mark = black;
return 0;

};
//
// 找寻 棋型表中的 最大值 点
bool Player::MaxWeight(int (&b)[Board_LEN][Board_WID][4],Point &p,Board &board)
{
p.mark = 1;
//Point pt;
int cptWgt1=0, gmrWgt1=0,cptWgt2=0,gmrWgt2=0;
int p1Wgt,p2Wgt; 

//寻找当前一方棋型权值最大的点
    for(int x = 0 ; x < Board_WID ; ++x)
 {
 for (int y = 0 ;  y < Board_LEN ; ++y)
 {
 for(int d = 0 ; d < 4; ++d)
 {  
 if( b[x][y][d] > p.mark)
 {
 p.x = x ; p.y = y ;  
 p .mark = b[x][y][d];
 }
 else if( p.mark ==b[x][y][d]) //当 当前一方 棋型权值相同的时候 ，比较相同点双方棋型的权值
 {
                            cptWgt1=0, gmrWgt1=0,cptWgt2=0,gmrWgt2=0;
for( int direct= 0; direct <4 ; ++direct)
{
cptWgt1 += this->computerBoardWgt[x][y][direct];
gmrWgt1 +=this->gamerBoardWgt[x][y][direct];

cptWgt2 += this->computerBoardWgt[p.x][p.y][direct];
gmrWgt2 += this->gamerBoardWgt[p.x][p.y][direct];

}
p1Wgt = cptWgt1 + gmrWgt1;
p2Wgt = cptWgt2 + gmrWgt2;
if( p1Wgt > p2Wgt) 
{
p.x = x; p.y = y;
}
 }
 }
 }
 }
  return 0;
};
Point Player::Analyse(Board &board)
{
  Point point,temp1,temp2;
  point .x = 0;  
  point .y = 0;
  chkMode(board);  
  point.mark = mark; // 为将要落的子， 赋值

  if( mark == black)  //执黑先行的话，落子到棋盘中央
  {
 point.x = Board_LEN/2; point.y = Board_WID/2;
 point.mark = black;
      return point;
  }
  else
  {
 clearWeight();
 mark = black;
 chkWeight(board,gamerBoardWgt);
   // showGmrWght();
 cout << "**********************************" << endl;
 mark = white;
 chkWeight(board,computerBoardWgt);

   // showCptWght();


//棋盘 下第一个子的时候
 if( board.Revblacks() == 1)
 {
 int x =  board.getCurStep()->PreStep->m_point.x;
 int y =  board.getCurStep()->PreStep->m_point.y;

if( Board_LEN - x -1> x)
point.x = x+1;
else
point.x = x-1;
if( Board_WID -y - 1>y)
point.y = y +1;
else
point.y = y -1;
 
return  point;
 }
 
 
     MaxWeight(computerBoardWgt,temp1,board);
MaxWeight(gamerBoardWgt,temp2,board);
 //判断电脑的 棋型是否 冲三 以上
 //进攻 优先
 if( temp2.mark < 21)
 {
   point.x = temp1.x;
   point.y = temp1.y;    
 }

 // #**#  #*#*#  o***#   三种棋型   *黑棋  #空位  o白棋
 else if(temp2.mark > 20 && temp2.mark < 31)
 {
 if(temp1.mark >20 && temp1.mark != 30)
 {
   point.x = temp1.x;
   point.y = temp1.y;
 }
 else
 {
   point.x = temp2.x;
   point.y = temp2.y;
 }
 
 }
 // #***#  #*#**#  
 else if( temp2.mark > 30 && temp2.mark < 40)
 {
 if(temp1.mark> 30)
 {
 point.x=temp1.x;
 point.y=temp1.y;
 }
 else
 {
 point.x=temp2.x;
 point.y=temp2.y;
 }
 }
 else if( temp2.mark > 39)
 {
 if(temp1.mark > 39)
 {
   point.x = temp1.x;
   point.y = temp1.y;
 }
 else
 {
   point.x=temp2.x;
    point.y=temp2.y;
 }
 }
 else 
 {
 
 point.x = temp2.x ;
 point.y = temp2.y ;
 }
  
  }

return point;
};

// 初始化 
Control::Control()
{
player = Gamer;
};

// 输入走棋的坐标
bool Control::inputPoint(Point &p,Board &b)
{
p.mark = Gamer;
cout << "输入 你想走棋的坐标" << endl;
cin >> p.x  >> p.y ;
//输入合法性 检查

if(b.getPoint(p) == 0)
{
return 0;
}
else 
while( b.getPoint(p) !=0)
{
cout << "你输入的点不合法,重新输入" << endl;
cin >> p.x  >> p.y ;
     }
return 0;
};
bool Control::MainCtrl(Board & board,Player &cpter)
{
Point p;
    while(!board.GameOver() )
{
board.showBoard();
inputPoint(p,board);
board.SetPoint(p);
board.SetPoint(cpter.Analyse(board) );
}
board.showBoard();
getchar();
getchar();
return 0; 
};
####################################################################################
#include<iostream>
#include "FiveChess.h"

using namespace std;

int main()
{
Board board;
Player computer;
Control ctrl;
ctrl.MainCtrl(board,computer);
return 0;
};
kloze11
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
五子棋计算思路
weixin_30588729的博客
03-18 280
五子棋分为有禁手和无禁手，有禁手就是在无禁手的规则的基础上加上禁手规则，具体的规则不讲了。所以就人机对战来讲，从无禁手来做，比较好做。这里只讲无禁手的情况。无禁手就是只要能连成5个子，或者5个子以上，就算赢。 而计算机博弈要解决的问题，抽象地讲只有一个问题“下一步怎么走”，对五子棋来讲，就是下一步在哪个点落子。一般的思路在 棋类人机对战的一般原理 - BillySir - 博客园 ...
计算累计收益
weixin_30824277的博客
04-16 446
计算累计收益，fund_account, init_date, total_income drop table if exists data_stock; create table data_stock (account varchar(10),amount int,init_date varchar(20)); INSERT INTO `data_stock` VALUES...
经典五子棋游戏项目需求文档【软件工程课程作业】
鸽子的博客
06-28 4299
若本文对你有帮助，请点赞、关注我呦！ 本课程主要是小组选题并讨论需求，再按目标完成一个可执行的网页端或手机端的demo，派出一位代表演说。 我们小组做得中规中矩，大家可以参考但不要照抄。 第一部分 用户需求调查 1.1 项目选题 选题来源：易识队给出的题目 选题题目：经典五子棋游戏。 选题原因： （1）组员有过制作游戏的经验，如坦克大战、飞机大战，五子棋游戏开发起来难度系数较小； （2）可扩展性强，组员思维活...
五子棋AI算法简易实现（六）
ZTao-z的博客
03-07 5760
电脑AI篇 （3）Minimax算法（极小极大值搜索算法） 这是五子棋AI进行下子位置判断的基本方法，是整个AI最核心的算法。 A minimax algorithm is a recursive algorithm for choosing the next move in an n-player game, usually a two-player game. A valu...
基于ALPHA-BETA算法的五子棋程序
11-24
在五子棋这种零和博弈（双方利益总和为零）中，一方的赢就是另一方的输，因此我们可以用MAX节点代表玩家的决策，用MIN节点代表对手的决策。ALPHA表示当前已知的最佳可能结果，而BETA则表示最坏的结果。在搜索过程中...
C++使用MFC基于Minimax算法和α-β剪枝的五子棋AI（带图形界面）
02-19
该算法假设每个玩家都试图最大化自己的利益（对于五子棋，即尽快连成五子），并假定对手也做同样的选择。通过递归地构建一个博弈树，Minimax算法可以预测游戏的可能结果。在每层节点，AI模拟当前玩家（Max）和对手...
安卓五子棋人机对战采用贪心算法
04-23
然而，贪心算法在五子棋中并非总是能找到全局最优解，因为它只考虑当前步的最优决策，而忽略了长远的策略规划。在某些情况下，过于依赖当前最优可能导致未来陷入不利局面。因此，为了提高机器的对战水平，开发者可能...
Java-Gobang-master_gobang五子棋Java_java智能算法_极大值_基于剪枝算法的五子棋_javaGob
09-11
在本项目"Java-Gobang-master"中，我们主要探讨的是如何使用Java编程语言实现一个五子棋（Gobang）游戏，并结合人工智能技术，特别是极小极大值算法与剪枝策略，来创建一个智能化的五子棋AI。五子棋是一种双人对弈的...
安卓机器对战五子棋贪心算法VS极大极小搜索算法
04-23
首先，贪心算法是一种局部最优解策略，它在每一步决策时都选择当前看起来最好的选项，不考虑长远的影响。在五子棋游戏中，贪心算法可能表现为每次选择能形成最多连续棋子或最接近对手棋子的位置下棋。这种方法简单...
简单五子棋算法——初级篇
jjwwwww的博客
12-26 2万+
五子棋博弈算法探究（1）前言 前言 最近对五子棋产生了一点兴趣，想来研究研究，我原本觉得简简单单的五子棋，其实还是有很多学问的。 五子是中国古老的棋类之一，是老少咸宜的娱乐项目， ...
下五子棋的bot----五子棋算法
但行好事，莫问前程
07-06 2665
使用的是北大信科开发的AI平台，百度搜素botzone,或者直接输入https://www.botzone.org.cn/ 代码已经在平台上参与排行，成绩还行，现分享给大家。 #include<math.h> #include<stdlib.h> #include<time.h> #include<iostream> #include<...
五子棋AI算法第一篇-我对谷歌Alphago的看法
热门推荐
言川的博客
02-02 2万+
最近Google宣布他们的围棋AI以5:0的战绩打败欧洲围棋三冠王。我一直对人工智能比较感兴趣，正好趁年前空闲的几天用JS写了一个五子棋的AI。其实很久以前就用自创的算法写过一个JAVA版的五子棋AI，不过棋力很不理想。这次用的是JS写的，所以无论任何平台上只要能打开网页的都可以玩。google爆出这个新闻之后，很多人觉得这是不是意味着电脑智商已经在人类之上了，围棋已经没有意义了之类的。甚至觉得这是
博弈基础——极大极小搜索
大田二十
03-05 2万+
博弈基础
算法力扣刷题记录 五十九【450.删除二叉搜索树中的节点】
最新发布
danaaaa的博客
07-25 1257
删除节点，在左右子树不为空的情况，处理稍微复杂。
α-β剪枝算法五子棋
10-12
α-β剪枝算法是一种用于优化搜索树的算法，常用于博弈游戏中，如五子棋。该算法通过减少不必要的搜索来提高搜索效率。 具体来说，α-β剪枝算法通过对搜索树的节点进行评估和剪枝来减少搜索的分支。在搜索过程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值