程序博客网 > 帝国文明源码下载

五子棋人机

来源：互联网 发布：帝国文明源码下载 编辑：程序博客网 时间：2024/05/07 18:22

 

权值法是个什么玩意呢？其实他是基于枚举的暴力的方法。之前说过五子棋的棋盘是15*15的。并且赢得情况是5个相同的棋子连成一块，那么大家就可以想到，我们能枚举出所有赢得情况，大约几千种，在我们看来这个数字比较大，但是对于一秒就可以处理数量级到8的计算机来说，小case是不是？那么有了这个理解我们就可以实现两个表，分别是机器和人的胜利表，也就是储存赢得情况的表，那么有了这个表，最终机器决定下棋是要通过权值判断的，至于权值怎么来，先不用管，我们也要用两个表分别储存机器和人的权值的表，贴出代码：

[java] view plain copy print?
  1.        private GoBangPanel panel; 
  2. private Graphics2D g; 
  3. private int num; 
  4. private Judge j; 
  5. public class struct 
  6. { 
  7.     int last; 
  8.     //计算x，y坐标 
  9.     int[] x = newint[5]; 
  10.     int[] y = newint[5]; 
  11.     //记录每个取胜表的棋子相连的情况 
  12.     int[] wn = newint[5]; 
  13. } 
  14. struct[] winlistp = new struct[800]; 
  15. struct[] winlistc = new struct[800]; 
  16. int[][] scorep = newint[Row][Coloum]; 
  17. int[][] scorec = new int[Row][Coloum]; 
说一下这几个东西的意思，scorep就是储存人的权值的表，scorec就是储存机器的权值的表。winlist同理是储存赢的情况的表。它是一个结构体数组，其中的x，y分别储存的是五个棋子相连的坐标，last表示这个情况是不是有效，说明一下，比如这是储存白棋赢的一种情况，五个棋子的坐标都已经储存了，但是在下棋的过程中，有一个黑色的棋子下在了这个五个坐标的其中一个，那么白棋就不可能通过这个情况赢了，那么就是无效的。那么大家就可以发现，随着下棋越来越多，无论是计算机还是人的winlist，无效的就会越来越多。

理解了winlist的作用，我们就来说一下score的作用，他就是储存权值的表，每次遍历查找出黑棋和白棋的权值的最大值，我们领白棋是计算机，黑棋是人，那么如果权值最大的就是白棋那么就体现了进攻，如果是黑棋就体现的防守，因为我们现在所说的是针对计算机的，因为我们编这套程序是为了让计算机知道怎么下棋。

怎么计算权值呢？我们先不跳着讲，先看看winlist怎么初始化和更新，初始化就是把所有赢的情况全部储存嘛，贴出代码：

[java] view plain copy print?
  1. public GoBangAn(GoBangPanel panel)  
  2. { 
  3.     //初始化黑棋和白棋各自的评分 
  4.     for(int i =0; i < Row; i++) 
  5.     { 
  6.         for(int j =0; j < Coloum; j++) 
  7.         { 
  8.             scorep[i][j] = 0; 
  9.             scorec[i][j] = 0; 
  10.         } 
  11.     } 
  12.     //初始化黑棋和白棋数组的各个元素 
  13.     for(int i =0; i < 800; i++) 
  14.     { 
  15.         winlistp[i] = new struct(); 
  16.         winlistc[i] = new struct(); 
  17.     } 
  18.     this.panel = panel; 
  19.     g = (Graphics2D)this.panel.getGraphics(); 
  20.     num = 0; 
  21.     //枚举各种情况（有4个大方向） 
  22.     //分别计算人和计算机行的赢的情况 
  23.     for(int i =0; i < Row; i++) 
  24.     { 
  25.         for(int j =0; j < 11; j++) 
  26.         { 
  27.             for(int k = j; k < j+5; k++) 
  28.             { 
  29.                 winlistp[num].x[k-j] = i; 
  30.                 winlistp[num].y[k-j] = k; 
  31.                 winlistc[num].x[k-j] = i; 
  32.                 winlistc[num].y[k-j] = k; 
  33.                 winlistp[num].last = 0; 
  34.                 winlistp[num].wn[k-j] = 0; 
  35.                 winlistc[num].last = 0; 
  36.                 winlistc[num].wn[k-j] = 0; 
  37.             } 
  38.             num++; 
  39.         } 
  40.     } 
  41.     //分别计算人和计算机列的赢的情况 
  42.     for(int i =0; i < Coloum; i++) 
  43.     { 
  44.         for(int j =0; j < 11; j++) 
  45.         { 
  46.             for(int k = j; k < j+5; k++) 
  47.             { 
  48.                 winlistp[num].x[k-j] = k; 
  49.                 winlistp[num].y[k-j] = i; 
  50.                 winlistc[num].x[k-j] = k; 
  51.                 winlistc[num].y[k-j] = i; 
  52.                 winlistp[num].last = 0; 
  53.                 winlistp[num].wn[k-j] = 0; 
  54.                 winlistc[num].last = 0; 
  55.                 winlistc[num].wn[k-j] = 0; 
  56.             } 
  57.             num++; 
  58.         } 
  59.     } 
  60.  
  61.     //分别计算人和计算机右上对角线赢的情况 
  62.     for(int i =1; i < 11; i++) 
  63.     { 
  64.         for(int x = i,y =0; x < 11; x++,y++) 
  65.         { 
  66.             for(int kx = x,ky = y; kx < x+5; kx++,ky++) 
  67.             { 
  68.                 winlistp[num].x[kx-x] = ky; 
  69.                 winlistp[num].y[kx-x] = kx; 
  70.                 winlistc[num].x[kx-x] = ky; 
  71.                 winlistc[num].y[kx-x] = kx; 
  72.                 winlistp[num].last = 0; 
  73.                 winlistp[num].wn[kx-x] = 0; 
  74.                 winlistc[num].last = 0; 
  75.                 winlistc[num].wn[kx-x] = 0; 
  76.             } 
  77.             num++;; 
  78.         } 
  79.     }  
  80.     //分别计算人和计算机左下对角线的情况 
  81.     for(int i =1; i < 11; i++) 
  82.     { 
  83.         for(int y = i,x =0; y < 11; y++,x++) 
  84.         { 
  85.             for(int kx = x,ky =y; ky < y+5; kx++,ky++) 
  86.             { 
  87.                 winlistp[num].x[kx-x] = ky; 
  88.                 winlistp[num].y[kx-x] = kx; 
  89.                 winlistc[num].x[kx-x] = ky; 
  90.                 winlistc[num].y[kx-x] = kx; 
  91.                 winlistp[num].last = 0; 
  92.                 winlistp[num].wn[kx-x] = 0; 
  93.                 winlistc[num].last = 0; 
  94.                 winlistc[num].wn[kx-x] = 0; 
  95.             } 
  96.             num++; 
  97.         } 
  98.     } 

因为代码很长但是不难，所以就贴出一部分，大家懂了之后剩下的代码自己补上绝对不是问题。看一下代码应该清楚，枚举所有赢的情况。分别是横着的方向和竖着的方向以及两个斜着的方向，这样就可以通过for循环直接全部初始化。score数组的初始化当然是0啦。

那么怎么更新winlist数组呢，很简单，假如更新白棋，那么就遍历棋盘找黑棋的位置，然后遍历winlist表，看看这个黑棋的坐标被哪些情况包含了，那么这个情况就无效了，贴出代码：

[java] view plain copy print?
  1. //分别更新人和计算机的取胜表的情况 
  2.    public void update(int sitx,int sity) 
  3.    { 
  4.     if(array[sitx][sity]%2 ==0) 
  5.     { 
  6.         for(int i =0; i < num; i++) 
  7.         { 
  8.             if(winlistp[i].last == 0) 
  9.             { 
  10.                 for(int j =0; j < 5; j++) 
  11.                 { 
  12.                     if((winlistp[i].x[j] == sitx) && (winlistp[i].y[j] == sity)) 
  13.                     { 
  14.                         winlistp[i].last = 1; 
  15.                         break; 
  16.                     }                            
  17.                      
  18.                 } 
  19.             } 
  20.             if(winlistc[i].last == 0) 
  21.             { 
  22.                 for(int j =0; j < 5; j++) 
  23.                 { 
  24.                     if((winlistc[i].x[j] == sitx) && (winlistc[i].y[j] == sity)) 
  25.                     { 
  26.                         winlistc[i].wn[j] = 1; 
  27.                         break; 
  28.                     } 
  29.                 } 
  30.             } 
  31.         } 
  32.     }else  
  33.     { 
  34.         for(int i =0; i < num; i++) 
  35.         { 
  36.             if(winlistc[i].last == 0) 
  37.             { 
  38.                 for(int j =0; j < 5; j++) 
  39.                 { 
  40.                     if((winlistc[i].x[j] == sitx) && (winlistc[i].y[j] == sity)) 
  41.                     { 
  42.                         winlistc[i].last = 1; 
  43.                     } 
  44.                 } 
  45.             } 
  46.             if(winlistp[i].last == 0) 
  47.             { 
  48.                 for(int j =0; j < 5; j++) 
  49.                 { 
  50.                     if((winlistp[i].x[j] == sitx) && (winlistp[i].y[j] == sity)) 
  51.                     { 
  52.                         winlistp[i].wn[j] = 1; 
  53.                     } 
  54.                 } 
  55.             } 
  56.         } 
  57.     } 

根据我说的再去看看代码就很简单了是不是？

那么接下来说一下怎么更新score数组，一个很显然的情况就是如果这个坐标被winlist里面的情况包含的越多那么下棋在这个位置的用处就越大。这是一个方面，为什么winlist还有一个wn数组呢，那就是判断是不是3个棋子连在一起了？4个棋子连在一起了？？等等。因为是权值，每种情况都要有一定的数值，比如活三就给的大一点，活四直接认输就好了等等，权值怎么给确实很大的影响结果，自己到现在也没有找到很好的分配方式。这个怎么给大家自己决定吧，剩下的我就不多说了，每次更行权值列表，挑出最大的位置下棋就好了，不过因为把所有的情况都考虑了，之前有一个人说过，如果计算机先手不能保证赢但是能保证不输。哈哈哈不过我没有实现的这个程度，还是要加强的。那五子棋就讲到这里了。

阅读全文
0 0
帝国文明源码下载 帝国文明源码下载
原创粉丝点击
热门IT博客
java机房管理系统java机房管理系统
手机微信炸群软件手机微信炸群软件
知乎不能邀请回答
java enum string
如何进入DOS linux
大鱼大肉知乎
中韩关系回暖知乎
淘宝客服骂人在哪投诉
java生成log日志文件
sql设置默认值
java基础知识
局域网网络结构
linux 小数比较大小
monaco 字体 linux
讨鬼传2 噬神者2 知乎
linux 修改字符集
做网络系统集成的公司
魅族手机mac地址修改
qq旋风下线 知乎
gcc windows 64 下载
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 蜡的拼音 蜡嘴鹦鹉 蜡的成语 蜡美人 水果硬糖绿蜡 蜡怎么组词 蜡的词语 蜡是什么 蠟 蜡怎么读 蜡拼音怎么拼 聚乙烯蜡多少钱一吨 聚乙烯蜡厂家 植物蜡 家禽脱毛蜡 汽车打一次蜡多少钱 划痕修复蜡有用吗 汽车蜡多少钱一盒 黄蜂蜡 汽车修复蜡 费托蜡 汽车开蜡 表板蜡价格 新车划痕蜡 褐煤蜡 防护蜡 颗粒蜡 蜡乳液厂家 酒精蜡 洗车蜡水 香蜡 汽车蜡品牌 聚酰胺蜡 划痕蜡哪个品牌好 汽车划痕蜡 防水蜡 水果保鲜蜡 仪表蜡 棕榈蜡价格 蜂蜜蜡 矿物蜡

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里