标题: 博弈树加上α-β剪枝算法做出来的五子棋AI往前推6步无压力 [打印本页]

---

作者: liuyy    时间: 2015-1-11 19:56
标题: 博弈树加上α-β剪枝算法做出来的五子棋AI往前推6步无压力

AI棋力已经非常叼了我反正是一次都赢不了它，所有棋类AI基本都是一个原理只需要根据游戏规则来改写自己的局面评分函数就欧了
以下代码是在博弈树加上α-β剪枝算法做出来的五子棋AI往前推6步无压力在DEV环境下编译的

1. #include <cstdlib>
   
2. #include <iostream.h>
   
3. #include<stdlib.h>
   
4. #include<string.h>
   
5. #include<time.h>
   
6. #define GRID_NUM    15 //每一行(列)的棋盘交点数
   
7. #define GRID_COUNT  225//棋盘上交点总数
   
8. #define BLACK        0 //黑棋用0表示
   
9. #define WHITE        1 //白棋用1表示
   
10. #define NOSTONE     '+'  //没有棋子
    
11. //这组宏定义了用以代表几种棋型的数字
    
12. #define STWO        1  //眠二
    
13. #define STHREE        2  //眠三
    
14. #define SFOUR        3  //冲四
    
15. #define TWO        4  //活二
    
16. #define THREE        5  //活三
    
17. #define FOUR        6  //活四
    
18. #define FIVE        7  //五连
    
19. #define NOTYPE        11 //未定义
    
20. #define ANALSISED   255//已分析过的
    
21. #define TOBEANALSIS 0  //已分析过的
    
22. //这个宏用以检查某一坐标是否是棋盘上的有效落子点
    
23. #define IsValidPos(x,y) ((x>=0 && x<GRID_NUM) && (y>=0 && y<GRID_NUM)
    
24. //定义了枚举型的数据类型，精确，下边界，上边界
    
25. enum ENTRY_TYPE{exact,lower_bound,upper_bound};
    
26. //哈希表中元素的结构定义
    
27. typedef struct HASHITEM
    
28. {
    
29. __int64 checksum;         //64位校验码
    
30. ENTRY_TYPE entry_type;//数据类型
    
31. short depth;         //取得此值时的层次
    
32. short eval;         //节点的值
    
33. }HashItem;
    
34. 
    
35. typedef struct Node
    
36. {
    
37. int x;
    
38. int y;
    
39. }POINT;
    
40. 
    
41. //用以表示棋子位置的结构
    
42. typedef struct _stoneposition
    
43. {
    
44. unsigned char x;
    
45. unsigned char y;
    
46. }STONEPOS;
    
47. 
    
48. typedef struct _movestone
    
49. {
    
50. unsigned char nRenjuID;
    
51. POINT ptMovePoint;
    
52. }MOVESTONE;
    
53. //这个结构用以表示走法
    
54. 
    
55. typedef struct _stonemove
    
56. {
    
57. STONEPOS StonePos;//棋子位置
    
58. int Score;         //走法的分数
    
59. }STONEMOVE;
    
60. //=================================================================//
    
61. int AnalysisLine(unsigned char* position,int GridNum,int StonePos);
    
62. int AnalysisRight(unsigned char position[][GRID_NUM],int i,int j);
    
63. int AnalysisLeft(unsigned char position[][GRID_NUM],int i,int j);
    
64. int AnalysisVertical(unsigned char position[][GRID_NUM],int i,int j);
    
65. int AnalysisHorizon(unsigned char position[][GRID_NUM],int i,int j);
    
66. int Eveluate(unsigned int position[][GRID_NUM],bool bIsWhiteTurn);
    
67. int AddMove(int nToX, int nToY, int nPly);
    
68. int CreatePossibleMove(unsigned char position[][GRID_NUM], int nPly, int nSide);
    
69. void MergeSort(STONEMOVE* source,int n,bool direction);
    
70. void MergePass(STONEMOVE* source,STONEMOVE* target,const int s,const int n,const bool direction);
    
71. void Merge_A(STONEMOVE* source,STONEMOVE* target,int l,int m,int r);
    
72. void Merge(STONEMOVE* source,STONEMOVE* target,int l,int m,int r);
    
73. void EnterHistoryScore(STONEMOVE* move,int depth);
    
74. int GetHistoryScore(STONEMOVE* move);
    
75. void ResetHistoryTable();
    
76. int NegaScout(int depth,int alpha,int beta);
    
77. void SearchAGoodMove(unsigned char position[][GRID_NUM],int Type);
    
78. int IsGameOver(unsigned char position[][GRID_NUM],int nDepth);
    
79. void UnMakeMove(STONEMOVE* move);
    
80. unsigned char MakeMove(STONEMOVE* move,int type);
    
81. void _CSearchEngine();
    
82. void InitializeHashKey();
    
83. void EnterHashTable(ENTRY_TYPE entry_type, short eval, short depth, int TableNo);
    
84. int LookUpHashTable(int alpha, int beta, int depth, int TableNo);
    
85. void Hash_UnMakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM]);
    
86. void Hash_MakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM]);
    
87. void CalculateInitHashKey(unsigned char CurPosition[][GRID_NUM]);
    
88. __int64 rand64();
    
89. long rand32();
    
90. void CTranspositionTable();
    
91. void _CTranspositionTable();
    
92. bool OnInitDialog();
    
93. //=================================================================//
    
94. int m_HistoryTable[GRID_NUM][GRID_NUM];//历史得分表
    
95. STONEMOVE m_TargetBuff[225];    //排序用的缓冲队列
    
96. unsigned int m_nHashKey32[15][10][9];          //32位随机树组，用以生成32位哈希值
    
97. unsigned __int64 m_ulHashKey64[15][10][9];//64位随机树组，用以生成64位哈希值
    
98. HashItem *m_pTT[10];          //置换表头指针
    
99. unsigned int m_HashKey32;          //32位哈希值
    
100. __int64 m_HashKey64;          //64 位哈希值
     
101. STONEMOVE m_MoveList[10][225];//用以记录走法的数组
     
102. unsigned char m_LineRecord[30];          //存放AnalysisLine分析结果的数组
     
103. int TypeRecord[GRID_NUM ][GRID_NUM][4];//存放全部分析结果的数组,有三个维度,用于存放水平、垂直、左斜、右斜 4 个方向上所有棋型分析结果
     
104. int TypeCount[2][20];          //存放统记过的分析结果的数组
     
105. int m_nMoveCount;//此变量用以记录走法的总数
     
106. unsigned char CurPosition[GRID_NUM][GRID_NUM];//搜索时用于当前节点棋盘状态的数组
     
107. STONEMOVE m_cmBestMove;        //记录最佳走法的变量       
     
108. //CMoveGenerator* m_pMG;        //走法产生器指针       
     
109. //CEveluation* m_pEval;        //估值核心指针       
     
110. int m_nSearchDepth;        //最大搜索深度
     
111. int m_nMaxDepth;        //当前搜索的最大搜索深度
     
112. unsigned char m_RenjuBoard[GRID_NUM][GRID_NUM];//棋盘数组，用于显示棋盘
     
113. int m_nUserStoneColor;         //用户棋子的颜色
     
114. //CSearchEngine* m_pSE;         //搜索引擎指针
     
115. int X,Y;                               //AI输出落子位置
     
116. int SL;                                  //胜利标记
     
117. //位置重要性价值表,此表从中间向外,越往外价值越低
     
118. int PosValue[GRID_NUM][GRID_NUM]=
     
119. {
     
120. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
     
121. {0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
     
122. {0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
     
123. {0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
     
124. {0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
     
125. {0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
     
126. {0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
     
127. {0,1,2,3,4,5,6,7,6,5,4,3,2,1,0},
     
128. {0,1,2,3,4,5,6,6,6,5,4,3,2,1,0},
     
129. {0,1,2,3,4,5,5,5,5,5,4,3,2,1,0},
     
130. {0,1,2,3,4,4,4,4,4,4,4,3,2,1,0},
     
131. {0,1,2,3,3,3,3,3,3,3,3,3,2,1,0},
     
132. {0,1,2,2,2,2,2,2,2,2,2,2,2,1,0},
     
133. {0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
     
134. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
     
135. };
     
136. 
     
137. //全局变量,用以统计估值函数的执行遍数
     
138. int count=0;
     
139. 
     
140. int Eveluate(unsigned char position[][GRID_NUM],bool bIsWhiteTurn)
     
141. {
     
142. int i,j,k;
     
143. unsigned char nStoneType;
     
144. count++;//计数器累加
     
145. 
     
146. //清空棋型分析结果
     
147. memset(TypeRecord,TOBEANALSIS,GRID_COUNT*4*4);
     
148. memset(TypeCount,0,40*4);
     
149. 
     
150. for(i=0;i<GRID_NUM;i++)
     
151. for(j=0;j<GRID_NUM;j++)
     
152. {
     
153. if(position[i][j]!=NOSTONE)
     
154. {
     
155. //如果水平方向上没有分析过
     
156. if(TypeRecord[i][j][0]==TOBEANALSIS)
     
157. AnalysisHorizon(position,i,j);
     
158. 
     
159. //如果垂直方向上没有分析过
     
160. if(TypeRecord[i][j][1]==TOBEANALSIS)
     
161. AnalysisVertical(position,i,j);
     
162. 
     
163. //如果左斜方向上没有分析过
     
164. if(TypeRecord[i][j][2]==TOBEANALSIS)
     
165. AnalysisLeft(position,i,j);
     
166. 
     
167. //如果右斜方向上没有分析过
     
168. if(TypeRecord[i][j][3]==TOBEANALSIS)
     
169. AnalysisRight(position,i,j);
     
170. }
     
171. }
     
172. 
     
173. //对分析结果进行统计,得到每种棋型的数量
     
174. for(i=0;i<GRID_NUM;i++)
     
175. for(j=0;j<GRID_NUM;j++)
     
176. for(k =0;k<4;k++)
     
177. {
     
178. nStoneType=position[i][j];
     
179. if(nStoneType!=NOSTONE)
     
180. {
     
181. switch(TypeRecord[i][j][k])
     
182. {
     
183. case FIVE://五连
     
184. TypeCount[nStoneType][FIVE]++;
     
185. break;
     
186. case FOUR://活四
     
187. TypeCount[nStoneType][FOUR]++;
     
188. break;
     
189. case SFOUR://冲四
     
190. TypeCount[nStoneType][SFOUR]++;
     
191. break;
     
192. case THREE://活三
     
193. TypeCount[nStoneType][THREE]++;
     
194. break;
     
195. case STHREE://眠三
     
196. TypeCount[nStoneType][STHREE]++;
     
197. break;
     
198. case TWO://活二
     
199. TypeCount[nStoneType][TWO]++;
     
200. break;
     
201. case STWO://眠二
     
202. TypeCount[nStoneType][STWO]++;
     
203. break;
     
204. default:
     
205. break;
     
206. }  
     
207. }
     
208. }
     
209. 
     
210. //如果已五连,返回极值
     
211. if(bIsWhiteTurn)
     
212. {
     
213. if(TypeCount[BLACK][FIVE])
     
214. {
     
215.             
     
216.          
     
217.                  
     
218. return -9999;
     
219.         }
     
220. if(TypeCount[WHITE][FIVE])
     
221. {
     
222.                
     
223.             
     
224.                         
     
225. return 9999;
     
226.         }
     
227. }
     
228. else
     
229. {
     
230. if(TypeCount[BLACK][FIVE])
     
231. {
     
232.               
     
233.          
     
234.                                 
     
235. return 9999;
     
236.         }
     
237. if(TypeCount[WHITE][FIVE])
     
238. {
     
239.             
     
240.      
     
241.                              
     
242. return -9999;
     
243.         }
     
244. }
     
245. //两个冲四等于一个活四
     
246. if(TypeCount[WHITE][SFOUR]>1)
     
247. TypeCount[WHITE][FOUR]++;
     
248. if(TypeCount[BLACK][SFOUR]>1)
     
249. TypeCount[BLACK][FOUR]++;
     
250. int WValue=0,BValue=0;
     
251. 
     
252. if(bIsWhiteTurn)//轮到白棋走
     
253. {       
     
254. if(TypeCount[WHITE][FOUR])       
     
255.         {       
     
256.             
     
257.          
     
258. return 9990;//活四,白胜返回极值
     
259.          }
     
260. if(TypeCount[WHITE][SFOUR])       
     
261.         {       
     
262.             
     
263.          
     
264. return 9980;//冲四,白胜返回极值
     
265.         }
     
266. if(TypeCount[BLACK][FOUR])       
     
267. {
     
268.            
     
269.             
     
270. return -9970;//白无冲四活四,而黑有活四,黑胜返回极值
     
271.         }
     
272. if(TypeCount[BLACK][SFOUR] && TypeCount[BLACK][THREE])
     
273. {
     
274.             
     
275.                      
     
276. return -9960;//而黑有冲四和活三,黑胜返回极值
     
277.         }
     
278. if(TypeCount[WHITE][THREE] && TypeCount[BLACK][SFOUR]== 0)       
     
279.         {       
     
280.            
     
281.             
     
282. return 9950;//白有活三而黑没有四,白胜返回极值
     
283.         }
     
284. if(TypeCount[BLACK][THREE]>1 && TypeCount[WHITE][SFOUR]==0 && TypeCount[WHITE][THREE]==0 && TypeCount[WHITE][STHREE]==0)
     
285.         {       
     
286.             
     
287.             
     
288. return -9940;//黑的活三多于一个,而白无四和三,黑胜返回极值
     
289.         }
     
290. if(TypeCount[WHITE][THREE]>1)
     
291. WValue+=2000;//白活三多于一个,白棋价值加2000
     
292. else
     
293. //否则白棋价值加200
     
294. if(TypeCount[WHITE][THREE])
     
295. WValue+=200;
     
296. if(TypeCount[BLACK][THREE]>1)
     
297. BValue+=500;//黑的活三多于一个,黑棋价值加500
     
298. else
     
299. //否则黑棋价值加100
     
300. if(TypeCount[BLACK][THREE])
     
301. BValue+=100;
     
302. //每个眠三加10
     
303. if(TypeCount[WHITE][STHREE])
     
304. WValue+=TypeCount[WHITE][STHREE]*10;
     
305. //每个眠三加10
     
306. if(TypeCount[BLACK][STHREE])
     
307. BValue+=TypeCount[BLACK][STHREE]*10;
     
308. //每个活二加4
     
309. if(TypeCount[WHITE][TWO])
     
310. WValue+=TypeCount[WHITE][TWO]*4;
     
311. //每个活二加4
     
312. if(TypeCount[BLACK][STWO])
     
313. BValue+=TypeCount[BLACK][TWO]*4;
     
314. //每个眠二加1
     
315. if(TypeCount[WHITE][STWO])
     
316. WValue+=TypeCount[WHITE][STWO];
     
317. //每个眠二加1
     
318. if(TypeCount[BLACK][STWO])
     
319. BValue+=TypeCount[BLACK][STWO];
     
320. }
     
321. else//轮到黑棋走
     
322. {       
     
323. if(TypeCount[BLACK][FOUR])       
     
324.         {       
     
325.    
     
326. return 9990;//活四,黑胜返回极值
     
327.           }
     
328. if(TypeCount[BLACK][SFOUR])       
     
329.         {       
     
330.            
     
331. return 9980;//冲四,黑胜返回极值
     
332.         }
     
333. if(TypeCount[WHITE][FOUR])
     
334. return -9970;//活四,白胜返回极值
     
335.       
     
336. if(TypeCount[WHITE][SFOUR] && TypeCount[WHITE][THREE])       
     
337. return -9960;//冲四并活三,白胜返回极值
     
338. 
     
339. if(TypeCount[BLACK][THREE] && TypeCount[WHITE][SFOUR]==0)
     
340. return 9950;//黑活三,白无四。黑胜返回极值
     
341. 
     
342. if(TypeCount[WHITE][THREE]>1 && TypeCount[BLACK][SFOUR]==0 && TypeCount[BLACK][THREE]==0 && TypeCount[BLACK][STHREE]==0)
     
343. return -9940;//白的活三多于一个,而黑无四和三,白胜返回极值
     
344. 
     
345. //黑的活三多于一个,黑棋价值加2000
     
346. if(TypeCount[BLACK][THREE]>1)
     
347. BValue+=2000;
     
348. else
     
349. //否则黑棋价值加200
     
350. if(TypeCount[BLACK][THREE])
     
351. BValue+=200;
     
352. 
     
353. //白的活三多于一个,白棋价值加 500
     
354. if(TypeCount[WHITE][THREE]>1)
     
355. WValue+=500;
     
356. else
     
357. //否则白棋价值加100
     
358. if(TypeCount[WHITE][THREE])
     
359. WValue+=100;
     
360. 
     
361. //每个眠三加10
     
362. if(TypeCount[WHITE][STHREE])
     
363. WValue+=TypeCount[WHITE][STHREE]*10;
     
364. //每个眠三加10
     
365. if(TypeCount[BLACK][STHREE])
     
366. BValue+=TypeCount[BLACK][STHREE]*10;
     
367. 
     
368. //每个活二加4
     
369. if(TypeCount[WHITE][TWO])
     
370. WValue+=TypeCount[WHITE][TWO]*4;
     
371. //每个活二加4
     
372. if(TypeCount[BLACK][STWO])
     
373. BValue+=TypeCount[BLACK][TWO]*4;
     
374. 
     
375. //每个眠二加1
     
376. if(TypeCount[WHITE][STWO])
     
377. WValue+=TypeCount[WHITE][STWO];
     
378. //每个眠二加1
     
379. if(TypeCount[BLACK][STWO])
     
380. BValue+=TypeCount[BLACK][STWO];
     
381. }
     
382. 
     
383. //加上所有棋子的位置价值
     
384. for(i=0;i<GRID_NUM;i++)
     
385. for(j=0;j<GRID_NUM;j++)
     
386. {
     
387. nStoneType=position[i][j];
     
388. if(nStoneType!=NOSTONE)
     
389. if(nStoneType==BLACK)
     
390. BValue+=PosValue[i][j];
     
391. else
     
392. WValue+=PosValue[i][j];
     
393. }
     
394. 
     
395. //返回估值
     
396. if(!bIsWhiteTurn)
     
397. return BValue-WValue;
     
398. else
     
399. return WValue-BValue;
     
400. }
     
401. 
     
402. //分析棋盘上某点在水平方向上的棋型
     
403. int AnalysisHorizon(unsigned char position[][GRID_NUM],int i,int j)
     
404. {
     
405. //调用直线分析函数分析
     
406. AnalysisLine(position[i],15,j);
     
407. //拾取分析结果
     
408. for(int s=0;s<15;s++)
     
409. if(m_LineRecord[s]!=TOBEANALSIS)
     
410. TypeRecord[i][s][0]= m_LineRecord[s];
     
411. 
     
412. return TypeRecord[i][j][0];
     
413. }
     
414. 
     
415. //分析棋盘上某点在垂直方向上的棋型
     
416. int AnalysisVertical(unsigned char position[][GRID_NUM],int i,int j)
     
417. {
     
418. unsigned char tempArray[GRID_NUM];
     
419. //将垂直方向上的棋子转入一维数组
     
420. for(int k=0;k<GRID_NUM;k++)
     
421. tempArray[k]=position[k][j];
     
422. //调用直线分析函数分析
     
423. AnalysisLine(tempArray,GRID_NUM,i);
     
424. //拾取分析结果
     
425. for(int s=0;s<GRID_NUM;s++)
     
426. if(m_LineRecord[s]!=TOBEANALSIS)
     
427. TypeRecord[s][j][1]=m_LineRecord[s];
     
428. 
     
429. return TypeRecord[i][j][1];
     
430. }
     
431. 
     
432. //分析棋盘上某点在左斜方向上的棋型
     
433. int AnalysisLeft(unsigned char position[][GRID_NUM],int i,int j)
     
434. {
     
435. unsigned char tempArray[GRID_NUM];
     
436. int x,y;
     
437. int k;
     
438. if(i<j)
     
439. {
     
440. y=0;
     
441. x=j-i;
     
442. }
     
443. else
     
444. {
     
445. x=0;
     
446. y=i-j;
     
447. }
     
448. //将斜方向上的棋子转入一维数组
     
449. for(k=0;k<GRID_NUM;k++)
     
450. {
     
451. if(x+k>14 || y+k>14)
     
452. break;
     
453. tempArray[k]=position[y+k][x+k];
     
454. }
     
455. //调用直线分析函数分析
     
456. AnalysisLine(tempArray,k,j-x);
     
457. //拾取分析结果
     
458. for(int s=0;s<k;s++)
     
459. if(m_LineRecord[s]!=TOBEANALSIS)
     
460. TypeRecord[y+s][x+s][2]=m_LineRecord[s];
     
461. 
     
462. return TypeRecord[i][j][2];
     
463. }
     
464. 
     
465. //分析棋盘上某点在右斜方向上的棋型
     
466. int AnalysisRight(unsigned char position[][GRID_NUM],int i,int j)
     
467. {
     
468. unsigned char tempArray[GRID_NUM];
     
469. int x,y,realnum;
     
470. int k;
     
471. if(14-i<j)
     
472. {
     
473. y=14;
     
474. x=j-14+i;
     
475. realnum=14-i;
     
476. }
     
477. else
     
478. {
     
479. x=0;
     
480. y=i+j;
     
481. realnum=j;
     
482. }
     
483. //将斜方向上的棋子转入一维数组
     
484. for(k=0;k<GRID_NUM;k++)
     
485. {
     
486. if(x+k>14 || y-k<0)
     
487. break;
     
488. tempArray[k]=position[y-k][x+k];
     
489. }
     
490. //调用直线分析函数分析
     
491. AnalysisLine(tempArray,k,j-x);
     
492. //拾取分析结果
     
493. for(int s=0;s<k;s++)
     
494. if(m_LineRecord[s]!=TOBEANALSIS)
     
495. TypeRecord[y-s][x+s][3]=m_LineRecord[s];
     
496. 
     
497. return TypeRecord[i][j][3];
     
498. }
     
499. 
     
500. int AnalysisLine(unsigned char* position,int GridNum,int StonePos)
     
501. {
     
502. unsigned char StoneType;
     
503. unsigned char AnalyLine[30];
     
504. int nAnalyPos;
     
505. int LeftEdge,RightEdge;
     
506. int LeftRange,RightRange;
     
507. 
     
508. if(GridNum<5)
     
509. {
     
510. //数组长度小于5没有意义
     
511. memset(m_LineRecord,ANALSISED,GridNum);
     
512. return 0;
     
513. }
     
514. nAnalyPos=StonePos;
     
515. memset(m_LineRecord,TOBEANALSIS,30);
     
516. memset(AnalyLine,0x0F,30);
     
517. //将传入数组装入AnalyLine;
     
518. memcpy(&AnalyLine,position,GridNum);
     
519. GridNum--;
     
520. StoneType=AnalyLine[nAnalyPos];
     
521. LeftEdge=nAnalyPos;
     
522. RightEdge=nAnalyPos;
     
523. //算连续棋子左边界
     
524. while(LeftEdge>0)
     
525. {
     
526. if(AnalyLine[LeftEdge-1]!=StoneType)
     
527. break;
     
528. LeftEdge--;
     
529. }
     
530. 
     
531. //算连续棋子右边界
     
532. while(RightEdge<GridNum)
     
533. {
     
534. if(AnalyLine[RightEdge+1]!=StoneType)
     
535. break;
     
536. RightEdge++;
     
537. }
     
538. LeftRange=LeftEdge;
     
539. RightRange=RightEdge;
     
540. //下面两个循环算出棋子可下的范围
     
541. while(LeftRange>0)
     
542. {
     
543. if(AnalyLine[LeftRange -1]==!StoneType)
     
544. break;
     
545. LeftRange--;
     
546. }
     
547. while(RightRange<GridNum)
     
548. {
     
549. if(AnalyLine[RightRange+1]==!StoneType)
     
550. break;
     
551. RightRange++;
     
552. }
     
553. //如果此范围小于4则分析没有意义
     
554. if(RightRange-LeftRange<4)
     
555. {
     
556. for(int k=LeftRange;k<=RightRange;k++)
     
557. m_LineRecord[k]=ANALSISED;
     
558. return false;
     
559. }
     
560. //将连续区域设为分析过的,防止重复分析此一区域
     
561. for(int k=LeftEdge;k<=RightEdge;k++)
     
562. m_LineRecord[k]=ANALSISED;
     
563. if(RightEdge-LeftEdge>3)
     
564. {
     
565. //如待分析棋子棋型为五连
     
566. m_LineRecord[nAnalyPos]=FIVE;
     
567. return FIVE;
     
568. }
     
569. 
     
570. if(RightEdge-LeftEdge== 3)
     
571. {
     
572. //如待分析棋子棋型为四连
     
573. bool Leftfour=false;
     
574. if(LeftEdge>0)
     
575. if(AnalyLine[LeftEdge-1]==NOSTONE)
     
576. Leftfour=true;//左边有气
     
577. 
     
578. if(RightEdge<GridNum)
     
579. //右边未到边界
     
580. if(AnalyLine[RightEdge+1]==NOSTONE)
     
581. //右边有气
     
582. if(Leftfour==true)//如左边有气
     
583. m_LineRecord[nAnalyPos]=FOUR;//活四
     
584. else
     
585. m_LineRecord[nAnalyPos]=SFOUR;//冲四
     
586. else
     
587. if(Leftfour==true)//如左边有气
     
588. m_LineRecord[nAnalyPos]=SFOUR;//冲四
     
589. else
     
590. if(Leftfour==true)//如左边有气
     
591. m_LineRecord[nAnalyPos]=SFOUR;//冲四
     
592. 
     
593. return m_LineRecord[nAnalyPos];
     
594. }
     
595. 
     
596. if(RightEdge-LeftEdge==2)
     
597. {
     
598. //如待分析棋子棋型为三连
     
599. bool LeftThree=false;
     
600. 
     
601. if(LeftEdge>1)
     
602. if(AnalyLine[LeftEdge-1]==NOSTONE)
     
603. //左边有气
     
604. if(LeftEdge>1 && AnalyLine[LeftEdge-2]==AnalyLine[LeftEdge])
     
605. {
     
606. //左边隔一空白有己方棋子
     
607. m_LineRecord[LeftEdge]=SFOUR;//冲四
     
608. m_LineRecord[LeftEdge-2]=ANALSISED;
     
609. }
     
610. else
     
611. LeftThree=true;
     
612. 
     
613. if(RightEdge<GridNum)
     
614. if(AnalyLine[RightEdge+1]==NOSTONE)
     
615. //右边有气
     
616. if(RightEdge<GridNum-1 && AnalyLine[RightEdge+2]==AnalyLine[RightEdge])
     
617. {
     
618. //右边隔1个己方棋子
     
619. m_LineRecord[RightEdge]=SFOUR;//冲四
     
620. m_LineRecord[RightEdge+2]=ANALSISED;
     
621. }
     
622. else
     
623. if(LeftThree==true)//如左边有气
     
624. m_LineRecord[RightEdge]=THREE;//活三
     
625. else
     
626. m_LineRecord[RightEdge]=STHREE; //冲三
     
627. else
     
628. {
     
629. if(m_LineRecord[LeftEdge]==SFOUR)//如左冲四
     
630. return m_LineRecord[LeftEdge];//返回
     
631. 
     
632. if(LeftThree==true)//如左边有气
     
633. m_LineRecord[nAnalyPos]=STHREE;//眠三
     
634. }
     
635. else
     
636. {
     
637. if(m_LineRecord[LeftEdge]==SFOUR)//如左冲四
     
638. return m_LineRecord[LeftEdge];//返回
     
639. if(LeftThree==true)//如左边有气
     
640. m_LineRecord[nAnalyPos]=STHREE;//眠三
     
641. }
     
642. 
     
643. return m_LineRecord[nAnalyPos];
     
644. }
     
645. 
     
646. if(RightEdge-LeftEdge==1)
     
647. {
     
648. //如待分析棋子棋型为二连
     
649. bool Lefttwo=false;
     
650. bool Leftthree=false;
     
651. 
     
652. if(LeftEdge>2)
     
653. if(AnalyLine[LeftEdge-1]==NOSTONE)
     
654. //左边有气
     
655. if(LeftEdge-1>1 && AnalyLine[LeftEdge-2]==AnalyLine[LeftEdge])
     
656. if(AnalyLine[LeftEdge-3]==AnalyLine[LeftEdge])
     
657. {
     
658. //左边隔2个己方棋子
     
659. m_LineRecord[LeftEdge-3]=ANALSISED;
     
660. m_LineRecord[LeftEdge-2]=ANALSISED;
     
661. m_LineRecord[LeftEdge]=SFOUR;//冲四
     
662. }
     
663. else
     
664. if(AnalyLine[LeftEdge-3]==NOSTONE)
     
665. {
     
666. //左边隔1个己方棋子
     
667. m_LineRecord[LeftEdge-2]=ANALSISED;
     
668. m_LineRecord[LeftEdge]=STHREE;//眠三
     
669. }
     
670. else
     
671. Lefttwo=true;
     
672. 
     
673. if(RightEdge<GridNum-2)
     
674. if(AnalyLine[RightEdge+1]==NOSTONE)
     
675. //右边有气
     
676. if(RightEdge+1<GridNum-1 && AnalyLine[RightEdge+2]==AnalyLine[RightEdge])
     
677. if(AnalyLine[RightEdge+3]==AnalyLine[RightEdge])
     
678. {
     
679. //右边隔两个己方棋子
     
680. m_LineRecord[RightEdge+3]=ANALSISED;
     
681. m_LineRecord[RightEdge+2]=ANALSISED;
     
682. m_LineRecord[RightEdge]=SFOUR;//冲四
     
683. }
     
684. else
     
685. if(AnalyLine[RightEdge+3]==NOSTONE)
     
686. {
     
687. //右边隔 1 个己方棋子
     
688. m_LineRecord[RightEdge+2]=ANALSISED;
     
689. m_LineRecord[RightEdge]=STHREE;//眠三
     
690. }
     
691. else
     
692. {
     
693. if(m_LineRecord[LeftEdge]==SFOUR)//左边冲四
     
694. return m_LineRecord[LeftEdge];//返回
     
695. 
     
696. if(m_LineRecord[LeftEdge]==STHREE)//左边眠三       
     
697. return m_LineRecord[LeftEdge];
     
698. 
     
699. if(Lefttwo==true)
     
700. m_LineRecord[nAnalyPos]=TWO;//返回活二
     
701. else
     
702. m_LineRecord[nAnalyPos]=STWO;//眠二
     
703. }
     
704. else
     
705. {
     
706. if(m_LineRecord[LeftEdge]==SFOUR)//冲四返回
     
707. return m_LineRecord[LeftEdge];
     
708. 
     
709. if(Lefttwo==true)//眠二
     
710. m_LineRecord[nAnalyPos]=STWO;
     
711. }
     
712. 
     
713. return m_LineRecord[nAnalyPos];
     
714. }
     
715. 
     
716. return 0;
     
717. }
     
718. 
     
719. //将历史记录表中所有项目全置为初值
     
720. void ResetHistoryTable()
     
721. {
     
722.     memset(m_HistoryTable,10,GRID_COUNT*sizeof(int));
     
723. }
     
724. 
     
725. //从历史得分表中取给定走法的历史得分
     
726. int GetHistoryScore(STONEMOVE* move)
     
727. {
     
728. return m_HistoryTable[move->StonePos.x][move->StonePos.y];
     
729. }
     
730. 
     
731. //将一最佳走法汇入历史记录
     
732. void EnterHistoryScore(STONEMOVE* move,int depth)
     
733. {
     
734. m_HistoryTable[move->StonePos.x][move->StonePos.y]+=2<<depth;
     
735. }
     
736. 
     
737. //对走法队列从小到大排序
     
738. //STONEMOVE* source原始队列
     
739. //STONEMOVE* target目标队列
     
740. //合并source[l…m]和 source[m +1…r]至target[l…r]
     
741. void Merge(STONEMOVE* source,STONEMOVE* target,int l,int m,int r)
     
742. {
     
743. //从小到大排序
     
744. int i=l;
     
745. int j=m+1;
     
746. int k=l;
     
747. while(i<=m && j<=r)
     
748. if(source[i].Score<=source[j].Score)
     
749. target[k++]=source[i++];
     
750. else
     
751. target[k++]=source[j++];
     
752. if(i>m)
     
753. for(int q=j;q<=r;q++)
     
754. target[k++]=source[q];
     
755. else
     
756. for(int q=i;q<=m;q++)
     
757. target[k++]=source[q];
     
758. }
     
759. 
     
760. void Merge_A(STONEMOVE* source,STONEMOVE* target,int l,int m,int r)
     
761. {
     
762. //从大到小排序
     
763. int i=l;
     
764. int j=m+1;
     
765. int k=l;
     
766. while(i<=m &&j<=r)
     
767. if(source[i].Score>=source[j].Score)
     
768. target[k++]=source[i++];
     
769. else
     
770. target[k++]=source[j++];
     
771. if(i>m)
     
772. for(int q=j;q<=r;q++)
     
773. target[k++]=source[q];
     
774. else
     
775. for(int q=i;q<=m;q++)
     
776. target[k++]=source[q];
     
777. }
     
778. 
     
779. //合并大小为 S 的相邻子数组
     
780. //direction 是标志,指明是从大到小还是从小到大排序
     
781. void MergePass(STONEMOVE* source,STONEMOVE* target,const int s,const int n,const bool direction)
     
782. {
     
783. int i=0;
     
784. while(i<=n-2*s)
     
785. {
     
786. //合并大小为 s的相邻二段子数组
     
787. if(direction)
     
788. Merge(source,target,i,i+s-1,i+2*s-1);
     
789. else
     
790. Merge_A(source,target,i,i+s-1,i+2*s-1);
     
791. i=i+2*s;
     
792. }
     
793. if(i+s<n)//剩余的元素个数小于2s
     
794. {
     
795. if(direction)
     
796. Merge(source,target,i,i+s-1,n-1);
     
797. else
     
798. Merge_A(source,target,i,i+s-1,n-1);
     
799. }
     
800. else
     
801. for(int j=i;j<=n-1;j++)
     
802. target[j]=source[j];
     
803. }
     
804. 
     
805. void MergeSort(STONEMOVE* source,int n,bool direction)
     
806. {
     
807. int s=1;
     
808. while(s<n)
     
809. {
     
810. MergePass(source,m_TargetBuff,s,n,direction);
     
811. s+=s;
     
812. MergePass(m_TargetBuff,source,s,n,direction);
     
813. s+=s;
     
814. }
     
815. }
     
816. 
     
817. int CreatePossibleMove(unsigned char position[][GRID_NUM], int nPly, int nSide)
     
818. {
     
819. int i,j;
     
820. m_nMoveCount=0;
     
821. for(i=0;i<GRID_NUM;i++)
     
822. for(j=0;j<GRID_NUM;j++)
     
823. {
     
824. if(position[i][j]==(unsigned char)NOSTONE)
     
825. AddMove(j,i,nPly);
     
826. }
     
827. 
     
828. //使用历史启发类中的静态归并排序函数对走法队列进行排序
     
829. //这是为了提高剪枝效率
     
830. //        CHistoryHeuristic history;
     
831. MergeSort(m_MoveList[nPly],m_nMoveCount,0);
     
832. 
     
833. return m_nMoveCount;//返回合法走法个数
     
834. }
     
835. 
     
836. //在m_MoveList中插入一个走法
     
837. //nToX是目标位置横坐标
     
838. //nToY是目标位置纵坐标
     
839. //nPly是此走法所在的层次
     
840. int AddMove(int nToX, int nToY, int nPly)
     
841. {
     
842. m_MoveList[nPly][m_nMoveCount].StonePos.x=nToX;
     
843. m_MoveList[nPly][m_nMoveCount].StonePos.y=nToY;
     
844. 
     
845. m_nMoveCount++;
     
846. m_MoveList[nPly][m_nMoveCount].Score=PosValue[nToY][nToX];//使用位置价值表评估当前走法的价值
     
847. return m_nMoveCount;
     
848. }
     
849. 
     
850. void CNegaScout_TT_HH()
     
851. {
     
852. ResetHistoryTable();
     
853. //        m_pThinkProgress=NULL;
     
854. }
     
855. 
     
856. void SearchAGoodMove(unsigned char position[][GRID_NUM],int Type)
     
857. {
     
858. int Score;
     
859. 
     
860. memcpy(CurPosition,position,GRID_COUNT);
     
861. m_nMaxDepth=m_nSearchDepth;
     
862. CalculateInitHashKey(CurPosition);
     
863. ResetHistoryTable();
     
864. Score=NegaScout(m_nMaxDepth,-20000,20000);
     
865. X=m_cmBestMove.StonePos.y;
     
866. Y=m_cmBestMove.StonePos.x;
     
867. MakeMove(&m_cmBestMove,Type);
     
868. memcpy(position,CurPosition,GRID_COUNT);
     
869. }
     
870. 
     
871. int IsGameOver(unsigned char position[][GRID_NUM],int nDepth)
     
872. {
     
873. int score,i;//计算要下的棋子颜色
     
874. i=(m_nMaxDepth-nDepth)%2;
     
875. score=Eveluate(position,i);//调用估值函数
     
876. if(abs(score)>8000)//如果估值函数返回极值，给定局面游戏结束
     
877. return score;//返回极值
     
878. return 0;//返回未结束
     
879. }
     
880. 
     
881. int NegaScout(int depth,int alpha,int beta)
     
882. {
     
883. int Count,i;
     
884. unsigned char type;
     
885. int a,b,t;
     
886. int side;
     
887. int score;
     
888. /*        if(depth>0)
     
889. {
     
890. i= IsGameOver(CurPosition,depth);
     
891. if(i!=0)
     
892. return i;  //已分胜负，返回极值
     
893. }
     
894. */
     
895. side=(m_nMaxDepth-depth)%2;//计算当前节点的类型,极大0/极小1
     
896. score=LookUpHashTable(alpha,beta,depth,side);
     
897. if(score!=66666)
     
898. return score;
     
899. if(depth<=0)//叶子节点取估值
     
900. {
     
901. score=Eveluate(CurPosition,side);
     
902. EnterHashTable(exact,score,depth,side);//将估值存入置换表
     
903. 
     
904. return score;
     
905. }
     
906. Count=CreatePossibleMove(CurPosition,depth,side);
     
907. for(i=0;i<Count;i++)
     
908. m_MoveList[depth][i].Score=GetHistoryScore(&m_MoveList[depth][i]);
     
909. 
     
910. MergeSort(m_MoveList[depth],Count,0);
     
911. int bestmove=-1;
     
912.     a=alpha;
     
913.     b=beta;
     
914. 
     
915.     int eval_is_exact=0;
     
916. 
     
917.     for(i=0;i<Count;i++)
     
918. {
     
919. type=MakeMove(&m_MoveList[depth][i],side);
     
920. Hash_MakeMove(&m_MoveList[depth][i],CurPosition);
     
921. t=-NegaScout(depth-1,-b,-a);//递归搜索子节点，对第 1 个节点是全窗口，其后是空窗探测
     
922. if(t>a && t<beta && i>0)
     
923. {
     
924. //对于第一个后的节点,如果上面的搜索failhigh
     
925. a=-NegaScout(depth-1,-beta,-t);//re-search
     
926. eval_is_exact=1;//设数据类型为精确值
     
927. if(depth==m_nMaxDepth)
     
928. m_cmBestMove=m_MoveList[depth][i];
     
929. bestmove=i;
     
930. }
     
931. Hash_UnMakeMove(&m_MoveList[depth][i],CurPosition);
     
932. UnMakeMove(&m_MoveList[depth][i]);
     
933. if(a<t)
     
934. {
     
935. eval_is_exact=1;
     
936. a=t;
     
937. if(depth==m_nMaxDepth)
     
938. m_cmBestMove=m_MoveList[depth][i];
     
939. }
     
940. if(a>= beta)
     
941. {
     
942. EnterHashTable(lower_bound,a,depth,side);
     
943. EnterHistoryScore(&m_MoveList[depth][i],depth);
     
944. return a;
     
945. }
     
946. b=a+1;                      /* set new null window */
     
947. }
     
948. if(bestmove!=-1)
     
949. EnterHistoryScore(&m_MoveList[depth][bestmove], depth);
     
950. if(eval_is_exact)
     
951. EnterHashTable(exact,a,depth,side);
     
952. else
     
953. EnterHashTable(upper_bound,a,depth,side);
     
954. 
     
955. return a;
     
956. }
     
957. 
     
958. unsigned char MakeMove(STONEMOVE* move,int type)
     
959. {
     
960. CurPosition[move->StonePos.y][move->StonePos.x]=type;
     
961. return 0;
     
962. }
     
963. 
     
964. void UnMakeMove(STONEMOVE* move)
     
965. {
     
966. CurPosition[move->StonePos.y][move->StonePos.x]=NOSTONE;
     
967. }
     
968. 
     
969. __int64 rand64(void)
     
970. {
     
971.     return rand()^((__int64)rand()<<15)^((__int64)rand()<<30)^
     
972. ((__int64)rand()<<45)^((__int64)rand()<<60);
     
973. }
     
974. 
     
975. //生成32位随机数
     
976. long rand32(void)
     
977. {
     
978.     return rand()^((long)rand()<<15)^((long)rand()<<30);
     
979. }
     
980. 
     
981. void CTranspositionTable()
     
982. {
     
983. InitializeHashKey();//建立哈希表，创建随机数组
     
984. }
     
985. 
     
986. void _CTranspositionTable()
     
987. {
     
988. //释放哈希表所用空间
     
989. delete m_pTT[0];
     
990. delete m_pTT[1];
     
991. }
     
992. 
     
993. void CalculateInitHashKey(unsigned char CurPosition[][GRID_NUM])
     
994. {
     
995. int j,k,nStoneType;
     
996. 
     
997. m_HashKey32=0;
     
998. m_HashKey32=0;
     
999. //将所有棋子对应的哈希数加总
     
1000. for(j=0;j<GRID_NUM;j++)
      
1001. for(k=0;k<GRID_NUM;k++)
      
1002. {
      
1003. nStoneType=CurPosition[j][k];
      
1004. if(nStoneType!=0xFF)
      
1005. {
      
1006. m_HashKey32=m_HashKey32^m_nHashKey32[nStoneType][j][k];
      
1007. m_HashKey64=m_HashKey64^m_ulHashKey64[nStoneType][j][k];
      
1008. }
      
1009. }
      
1010. }
      
1011. 
      
1012. void Hash_MakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM])
      
1013. {
      
1014. int type;
      
1015. 
      
1016. type=CurPosition[move->StonePos.y][move->StonePos.x];//将棋子在目标位置的随机数添入
      
1017. m_HashKey32=m_HashKey32^m_nHashKey32[type][move->StonePos.y][move->StonePos.x];
      
1018. m_HashKey64=m_HashKey64^m_ulHashKey64[type][move->StonePos.y][move->StonePos.x];
      
1019. }
      
1020. 
      
1021. void Hash_UnMakeMove(STONEMOVE *move,unsigned char CurPosition[][GRID_NUM])
      
1022. {
      
1023. int type;
      
1024. type=CurPosition[move->StonePos.y][move->StonePos.x];//将棋子现在位置上的随机数从哈希值当中去除
      
1025. m_HashKey32=m_HashKey32^m_nHashKey32[type][move->StonePos.y][move->StonePos.x];
      
1026. m_HashKey64=m_HashKey64^m_ulHashKey64[type][move->StonePos.y][move->StonePos.x];
      
1027. }
      
1028. 
      
1029. int LookUpHashTable(int alpha, int beta, int depth, int TableNo)
      
1030. {
      
1031. int x;
      
1032. HashItem* pht;
      
1033. 
      
1034. //计算二十位哈希地址，如果读者设定的哈希表大小不是 1M*2 的,
      
1035. //而是 TableSize*2，TableSize为读者设定的大小
      
1036. //则需要修改这一句为m_HashKey32% TableSize
      
1037. //下一个函数中这一句也一样
      
1038. x=m_HashKey32 & 0xFFFFF;
      
1039. pht=&m_pTT[TableNo][x];//取到具体的表项指针
      
1040. 
      
1041.     if(pht->depth>=depth && pht->checksum==m_HashKey64)
      
1042. {
      
1043. switch(pht->entry_type)//判断数据类型
      
1044. {
      
1045. case exact://确切值
      
1046. return pht->eval;
      
1047. 
      
1048. case lower_bound://下边界
      
1049. if(pht->eval>=beta)
      
1050. return pht->eval;
      
1051. else
      
1052. break;
      
1053. 
      
1054. case upper_bound://上边界
      
1055. if (pht->eval<=alpha)
      
1056. return pht->eval;
      
1057. else
      
1058. break;
      
1059.         }
      
1060. }
      
1061. 
      
1062. return 66666;
      
1063. }
      
1064. 
      
1065. void EnterHashTable(ENTRY_TYPE entry_type, short eval, short depth, int TableNo)
      
1066. {
      
1067. int x;
      
1068. HashItem* pht;
      
1069. 
      
1070. x=m_HashKey32 & 0xFFFFF;//计算二十位哈希地址
      
1071. pht=&m_pTT[TableNo][x]; //取到具体的表项指针
      
1072. 
      
1073. //将数据写入哈希表
      
1074. pht->checksum=m_HashKey64; //64位校验码
      
1075. pht->entry_type=entry_type;//表项类型
      
1076. pht->eval=eval;          //要保存的值
      
1077. pht->depth=depth;          //层次
      
1078. }
      
1079. 
      
1080. void InitializeHashKey()
      
1081. {
      
1082. int i,j,k;
      
1083. srand((unsigned)time(NULL));
      
1084. //填充随机数组
      
1085. for(i=0;i<15;i++)
      
1086. for(j=0;j<10;j++)
      
1087. for(k=0;k<9;k++)
      
1088. {
      
1089. m_nHashKey32[i][j][k]=rand32();
      
1090. m_ulHashKey64[i][j][k]=rand64();
      
1091. }
      
1092. 
      
1093. //申请置换表所用空间。1M "2 个条目，读者也可指定其他大小
      
1094. m_pTT[0]=new HashItem[1024*1024];//用于存放取极大值的节点数据
      
1095. m_pTT[1]=new HashItem[1024*1024];//用于存放取极小值的节点数据
      
1096. }
      
1097. 
      
1098. 
      
1099. //using namespace std;
      
1100. 
      
1101. int main(int argc, char *argv[])
      
1102. {
      
1103. SL=0;
      
1104. int colour;
      
1105. char command[10]; //用于保存命令的字符串
      
1106. for (int i = 0; i < GRID_NUM; i++)
      
1107. for (int j = 0; j < GRID_NUM; j++)
      
1108. m_RenjuBoard[i][j] = NOSTONE; //棋盘初始化
      
1109. 
      
1110.     int XS;
      
1111.     printf("请选择先手棋手：1表示AI先手 0表示棋手先手\n");
      
1112. cin >> XS; //是否电脑先手
      
1113. colour=BLACK;
      
1114. m_nUserStoneColor=WHITE;
      
1115. while (!SL)
      
1116. {
      
1117.         printf("\n请输入落子坐标：\n");
      
1118. int rival_x, rival_y; //用于保存对手上一步落子点
      
1119. cin >> rival_x >> rival_y; //读入对手上一步落子点  
      
1120. if(XS == 1 && rival_x == -1 && rival_y == -1) //如果己方执黑且是第一步，则占据棋盘中心位置
      
1121. {
      
1122. m_RenjuBoard[GRID_NUM / 2][GRID_NUM / 2] = colour; //更新棋盘信息
      
1123. //cout << GRID_NUM / 2 << ' ' << GRID_NUM / 2 << endl; //输出
      
1124. //cout << flush; //刷新缓冲区  
      
1125. }
      
1126. else
      
1127. {
      
1128. m_RenjuBoard[rival_x][rival_y] =m_nUserStoneColor;
      
1129. //更新棋盘信息
      
1130.            for (int i = 0; i < GRID_NUM; i++)
      
1131.       {
      
1132. for (int j = 0; j < GRID_NUM; j++)
      
1133. {
      
1134.             if(m_RenjuBoard[i][j]==WHITE)
      
1135. printf("O "); else  if(m_RenjuBoard[i][j]==BLACK)printf("X "); else printf("+ ");
      
1136.         }
      
1137.           printf("\n");
      
1138.         }
      
1139. m_nSearchDepth=4;//AI难度等级设置
      
1140. //最大搜索深度       
      
1141. do
      
1142. {
      
1143. CNegaScout_TT_HH();         //创建NegaScout_TT_HH搜索引擎
      
1144. CTranspositionTable();
      
1145. SearchAGoodMove(m_RenjuBoard,colour);
      
1146. m_RenjuBoard[X][Y]=colour;
      
1147. printf("\nAI落子坐标为：");
      
1148. cout << X << ' ' << Y << endl; //输出
      
1149. cout << flush; //刷新缓冲区
      
1150. _CTranspositionTable();
      
1151. break; //结束循环
      
1152. }
      
1153. while (!SL);
      
1154. //循环直至随机得到一个空位置
      
1155. for (int i = 0; i < GRID_NUM; i++)
      
1156.     {
      
1157. for (int j = 0; j < GRID_NUM; j++)
      
1158. {
      
1159.             if(m_RenjuBoard[i][j]==WHITE)
      
1160. printf("O "); else  if(m_RenjuBoard[i][j]==BLACK)printf("X "); else printf("+ ");
      
1161.         }
      
1162.           printf("\n");
      
1163.         }
      
1164.         
      
1165.         if(SL==1)printf("很遗憾AI胜利了继续努力吧少年！\n");else if(SL==2)printf("少年你太叼了居然打败了AI！\n");
      
1166.         
      
1167.         
      
1168.      }
      
1169. }
      
1170.    
      
1171.     system("PAUSE");
      
1172.     return EXIT_SUCCESS;
      
1173. }
      

复制代码

---

作者: 1095222570    时间: 2016-3-6 23:31


99999999999999999999999999999999

---

作者: ccl    时间: 2016-3-14 00:26
标题: RE: 博弈树加上α-β剪枝算法做出来的五子棋AI往前推6步无压力
楼主的代码有个bug，ai不会防守眠4，胜局时也不会自己连5，希望改全，邮箱1490325170@qq.com

---

作者: 堕落小CY    时间: 2018-3-22 09:17

ccl 发表于 2016-3-14 00:26
**** 作者被禁止或删除 内容自动屏蔽 ****

兄弟，楼主有回复你吗，有的话，代码发我一下，

---

作者: 堕落小CY    时间: 2018-3-26 09:22
楼主真大佬，代码能跑起来，有4个错误，改了就好了

---

作者: zyx132    时间: 2018-4-24 15:25

堕落小CY 发表于 2018-3-26 09:22
楼主真大佬，代码能跑起来，有4个错误，改了就好了

请问是哪四个错误啊

---

作者: 55622332    时间: 2019-7-4 15:09

堕落小CY 发表于 2018-3-26 09:22
**** 作者被禁止或删除 内容自动屏蔽 ****

你好，请问是那几个错误呢

---

作者: sophon    时间: 2019-10-13 17:05
我第一局13步就赢了，而且它判胜负还有问题

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1