`

五子棋 AI 预测

算法java递归 
阅读更多
  9月1日，又到了这个让我们又爱又恨的时候。算一下我们开学的剩余使用数量也没有几次了。想到这不觉有种蛋蛋的忧伤，不过离开校园迟早的事，我们何不好好享受在校园的日子。
   闲话少说，在我学习JAVA的第二周，我大概花了4天4夜写出了这个五子棋AI，其中包括预测，其中实现的基础是权值法，就是给棋盘上的每一个点赋予相应的值。择其最大值落子。所有的数据都存在接口里，方便操作。

这里要注意的几点是
数组越界的问题，这个要忒别小心。
第二，看到网上有人用三维数组，估计会比我用二维数组做代码要写的少。
博弈树+剪枝，Alpha-Beta搜索算法，这个我还没实现。

这里是我的接口
package xy_五子棋0717;

public interface data {

	int MAX[]=new int[1];
	int ROW=15;
	int COL=15;
	
	int SIZE=30;
	
	int ARRAY[][]=new int[15][15]; 
	
	int VALUE[][]=new int[15][15];
	
	int PREDICT[][]=new int[15][15];
	
	
	int FINAL[]=new int[2];
	
	int MAXK[][]=new int[15][15];
	
}

五子棋的界面
package xy_五子棋0717;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

/**
 * 在这继承面板对象是为了后面写重绘时方便
 * @author Administrator
 *
 */
public class chessBoard extends JPanel{
	
	AI1 a;
	public static void main(String[] args){
		chessBoard ch=new chessBoard();
		ch.initUI();
	}

	private void initUI() {
		JFrame jf=new JFrame();
		jf.setTitle("五子棋");
		jf.setSize(650,600);
		jf.setLocation(300,50);
		jf.setDefaultCloseOperation(3);
		
		JPanel jpNorth=new JPanel();
		JButton jb1=new JButton("保存");
		JButton jb2=new JButton("读出");
		JButton jb3=new JButton("悔棋");
		jpNorth.add(jb1);
		jpNorth.add(jb2);
		jpNorth.add(jb3);
		//用内部类给两个按钮加监听器
		ActionListener ac=new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
				//得到动作命令
				String commond=e.getActionCommand();
				if("保存".equals(commond)){
//					System.out.println("保存");
					//创建文件输出对象
					FileIO fi=new FileIO();
					try {
						fi.save("F:\\java\\保存五子棋\\a1.as",data.ARRAY,a.getSt());
					} catch (IOException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
				}
				else if("读出".equals(commond)){
					//创建文件输入对象
					FileIO fi=new FileIO();
					try {
						StepList st1=fi.read("F:\\java\\保存五子棋\\a1.as");
						StepList st=a.getSt();
						for(int i=0;i<st1.size();i++){
							st.add(st1.get(i));
						}
					} catch (IOException e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
					repaint();
				}
				else if("悔棋".equals(commond)){
					//得到下棋的每一步数据的队列
					StepList st=a.getSt();
					EveryStep ev=st.get();
					data.ARRAY[ev.bx][ev.by]=0;
					data.ARRAY[ev.wx][ev.wy]=0;
					st.delete();
					repaint();
				}
			}};
			jb1.addActionListener(ac);
			jb2.addActionListener(ac);
			jb3.addActionListener(ac);
		jpNorth.setPreferredSize(new Dimension(0,80));
		jpNorth.setBackground(Color.white);
		jf.add(jpNorth,BorderLayout.SOUTH);
		
		this.setBackground(Color.orange);
		jf.add(this,BorderLayout.CENTER);
		
		jf.setVisible(true);
		
		Graphics g=this.getGraphics();
		
		//实例化一个棋子的监听器
		//chessListener ch=new chessListener(g);
		
		//给棋盘加一个监听器（人人）
		//this.addMouseListener(ch);
		
//		gobangAI0 go=new gobangAI0(g);
//		给棋盘加一个监听器（人机0）
//		this.addMouseListener(go);
		 a=new AI1(g);
		this.addMouseListener(a);
		
//		g.setColor(Color.black);
//		// System.out.println(data.VALUE[i][j]);
//		g.fillOval(5 + 7 * data.SIZE, 5 + 7 * data.SIZE, 30, 30);
//		data.ARRAY[7][7] = 2;
		
		
	} 
	
	/**
	 * 调用重绘的方法
	 * 重写重绘的方法
	 * 每次显示窗体都会自动调用此方法
	 */
	public void paint(Graphics g){
		super.paint(g);//调用父类的方法
		board(g);
		chess(g);
	}
	
	//绘制棋盘的方法
	public void board(Graphics g){
	   for(int i=0;i<data.ROW;i++){
		   g.drawLine(20, 20+data.SIZE*i, 440, 20+data.SIZE*i);
	   }
	   for(int i=0;i<data.ROW;i++){
		   g.drawLine( 20+data.SIZE*i,20,  20+data.SIZE*i,440);
	   }
	}
	//写一个重绘棋子的方法
	public void chess(Graphics g){
		for(int i=0;i<15;i++)
			for(int j=0;j<15;j++){
				if(data.ARRAY[i][j]==1)
				{
					g.setColor(Color.white);
					g.fillOval(5+i*data.SIZE,5+j*data.SIZE,30,30);}
				if(data.ARRAY[i][j]==2)
				{
					g.setColor(Color.black);
					g.fillOval(5+i*data.SIZE,5+j*data.SIZE,30,30);}
			}
	}
	
}

人工智能开始的地方
其实实现五子棋AI最简单的方法就是贴着它的棋子下，我们就暂且称它为AI0。 
package xy_五子棋0717;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;

import javax.swing.ImageIcon;

public class gobangAI0 extends MouseAdapter {

	private Graphics g;
	private boolean k = true;
	Random r = new Random(2);

	public gobangAI0(Graphics g) {
		this.g = g;
	}

	public void mouseClicked(MouseEvent e) {
		int a = e.getX();
		int b = e.getY();

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (a < (35 + i * data.SIZE) && a > (5 + i * data.SIZE)
						&& b > (5 + j * data.SIZE) && b < (35 + j * data.SIZE)) {

					// 判断位置是否为空，是否是黑棋或白棋
					if (k && data.ARRAY[i][j] == 0) {
						g.setColor(Color.white);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);

						data.ARRAY[i][j] = 1;
						int w = r.nextInt(3) - 1;
						int c = r.nextInt(3) - 1;
						int w1 = r.nextInt(5) - 2;
						int c1 = r.nextInt(5) - 2;
						int w2 = r.nextInt(7) - 3;
						int c2 = r.nextInt(7) - 3;

						if (data.ARRAY[i + c][j + w] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c) * data.SIZE, 5 + (j + w)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c][j + w] = 2;
						} else if (data.ARRAY[i + c1][j + w1] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c1) * data.SIZE, 5 + (j + w1)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c1][j + w1] = 2;
						} else if (data.ARRAY[i + c2][j + w2] == 0) {
							g.setColor(Color.black);
							g.fillOval(5 + (i + c2) * data.SIZE, 5 + (j + w2)
									* data.SIZE, 30, 30);

							data.ARRAY[i + c2][j + w2] = 2;
						}

						// 显示图片
						judge j1 = new judge(g);
						j1.judge1();
					}

				}
			}

	}

}


判断输赢的算法 
package xy_五子棋0717;

import java.awt.Graphics;
import java.awt.Image;

import javax.swing.ImageIcon;

public class judge {

	private Graphics g;

	public judge(Graphics g) {
		this.g = g;
	}

	// 判断输赢的方法
	public void judge1() {
		int j = 0, l = 0;
		for (int i = 0; i < data.ROW; i++)
			for (int k = 0; k < (data.ROW); k++) {
				// System.out.println(i+"   "+k);
				// 判断横排是否有5个

				if (i < 11 && (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i + 1][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 2][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 3][k] == data.ARRAY[i][k]
						&& data.ARRAY[i + 4][k] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
				// 判断竖排是否有5个
				if (k < 11 && (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i][k + 2]
						&& data.ARRAY[i][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i][k + 4] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}

				// 判断右斜排是否有5个
				if (i < 11 && k < 11
						&& (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i + 1][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i + 2][k + 2]
						&& data.ARRAY[i + 3][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i + 4][k + 4] == data.ARRAY[i][k]) {
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
				// 判断左斜排是否有5个

				if (i > 3 && k < 11
						&& (data.ARRAY[i][k] == 1 || data.ARRAY[i][k] == 2)
						&& data.ARRAY[i - 1][k + 1] == data.ARRAY[i][k]
						&& data.ARRAY[i][k] == data.ARRAY[i - 2][k + 2]
						&& data.ARRAY[i - 3][k + 3] == data.ARRAY[i][k]
						&& data.ARRAY[i - 4][k + 4] == data.ARRAY[i][k]) {
					// System.out.println("*******************");
					if (data.ARRAY[i][k] == 1)
						j = 9;
					if (data.ARRAY[i][k] == 2)
						j = 8;
				}
			}

		// System.out.println(j);

		ImageIcon im = new ImageIcon("images/2.png");
		Image i = im.getImage();
		if (j == 9)
			g.drawImage(i, 0, 0, null);

		ImageIcon im1 = new ImageIcon("images/1.png");
		Image i1 = im1.getImage();
		if (j == 8)

			g.drawImage(i1, 0, 0, null);
	}

}


后来有了权值，五子棋一下子聪明了一大步。
用方法计算好了权值点，就可以下棋了。如果有几个权值点是一样的就取随机数。
我们称其为AI1。 
package xy_五子棋0717;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Random;

public class AI1 extends MouseAdapter {
	int K;
	int bx;
	int by;
	int wx;
	int wy;
	StepList st=new StepList();

	Random ra = new Random();
	private Graphics g;
	public AI1(Graphics g) {
		this.g = g;
	}

//	// 电脑下第一步
//	public void mousePressed(MouseEvent e) {
//		
//	}

	// 下棋
	public void mouseClicked(MouseEvent e) {
		// 重置权值点
		K = 0;
		// 看看棋盘上有多少个棋子
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.ARRAY[i][j] != 0)
					K++;
			}

		// System.out.println(K);
		fun f = new fun();
		prediction pr = new prediction();

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				data.VALUE[i][j] = 1000;
			}
		int a = e.getX();
		int b = e.getY();
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (a < (35 + i * data.SIZE) && a > (5 + i * data.SIZE)
						&& b > (5 + j * data.SIZE) && b < (35 + j * data.SIZE)) {

					if (data.ARRAY[i][j] == 0) {
						g.setColor(Color.white);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);
						data.ARRAY[i][j] = 1;
						wx=i;
						wy=j;

						// 赋值

						f.value();

						// 预测是否有双三
						if (K > 7) {
							pr.pre(3);
						}

						// 查找,并下棋子
						search();
						//记录这一步，人和电脑下的棋子
						EveryStep ev=new EveryStep(bx,by,wx,wy);
						//加入到队列
						st.add(ev);
					}

					// 显示图片
					judge j1 = new judge(g);
					j1.judge1();
				}
			}

	}

	public StepList getSt() {
		return st;
	}

	public void setSt(StepList st) {
		this.st = st;
	}

	// 寻找权值最大的点 ，并下棋子
	public void search() {
		int MAX = 0;
		int k = 0;

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {

				if (data.VALUE[i][j] > MAX) {
					MAX = data.VALUE[i][j];

				}
			}

		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.VALUE[i][j] == MAX) {
					// System.out.println(MAX);
					data.VALUE[i][j] = k;
					k++;
					// System.out.println(data.VALUE[i][j]);
				}
			}

		// 取随机下的点
		int q = ra.nextInt(k);

		if (K > 7) {
			// System.out.println("hi");
			g.setColor(Color.black);
			//System.out.println(data.FINAL[0] + "          " + data.FINAL[1]);
			g.fillOval(5 + data.FINAL[0] * data.SIZE, 5 + data.FINAL[1]
					* data.SIZE, 30, 30);
			data.ARRAY[data.FINAL[0]][data.FINAL[1]] = 2;
			bx=data.FINAL[0];
			by=data.FINAL[1];
		}

		else {
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {
					if (q == data.VALUE[i][j]) {
						g.setColor(Color.black);
						g.fillOval(5 + i * data.SIZE, 5 + j * data.SIZE, 30, 30);
						data.ARRAY[i][j] = 2;
						bx=i;
						by=j;
					}
				}

		}
	}
}


给大家看一下我的一部分权值表 
package xy_五子棋0717;

/**
 * 五子棋赋值算法
 * 
 * @author Administrator 还有一个BUG就是黑棋会往白棋堵死的地方下G
 */
public class fun {

	int ONE = 16;
	int NOONE = 5;
	int TWO = 136;
	int BTHREE = 1001;
	int NOTWO = 10;
	int THREE = 1000;
	int NOTHREE = 130;
	int WWIN = 3000;
	int BWIN = 3300;

	fun1 hu1 = new fun1();
	fun2 hu2 = new fun2();

	public void value() {

		four();
		three();
		two();
		one();
		hu1.five();
		hu1.eight();
		hu1.twotwo();
		hu2.seven();
		hu2.six();
		in();

		// System.out.println();
		// for(int k=0;k<data.ROW;k++)
		// {
		// for(int i=0;i<(data.ROW);i++){
		// System.out.print("  ["+(i+1)+"]["+(k+1)+"]="+data.ARRAY[i][k]);
		// }
		// System.out.println();
		// }
	}

	// 判断是否有棋子
	public void in() {
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {
				if (data.ARRAY[i][j] != 0) {
					data.VALUE[i][j] = -60000;
					// System.out.println("123");
				}
			}
	}

后来为了打败我们的熊哥，我又给电脑加了简单的预测，是用递归实现的，后来发现递归的使用大大增加了计算时间，而且简答的预测很明显是打不过熊哥的。不过电脑已经第一次看到了未来，我就暂且称它为AI1的修正版。 
package xy_五子棋0717;

public class prediction {

	fun f = new fun();

	int NX;
	int NY;
	int NBXX;
	int NBYY;

	public void pre(int n) {
		if (n == 0) {
			return;
		}
		int MAX = 0;
		for (int i = 0; i < 15; i++)
			for (int j = 0; j < 15; j++) {

				if (data.VALUE[i][j] > MAX) {
					MAX = data.VALUE[i][j];

					data.FINAL[0] = i;
					//System.out.println();
					NX = i;
					data.FINAL[1] = j;
					NY = j;
					//System.out.println(data.FINAL[0] + " hihi       "
							//+ data.FINAL[1]);
					// System.out.println(data.FINAL[0]+"   "+data.FINAL[1]);
				}
			}

		// 先判断白棋，因为要堵白子的双三
		if (MAX < 1500) {

			// 假设白棋下的地方
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {

					// 找到没下的点
					if (data.ARRAY[i][j] == 0) {
						// 重置权值点
						for (int i2 = 0; i2 < 15; i2++)
							for (int j2 = 0; j2 < 15; j2++) {
								data.VALUE[i2][j2] = 1000;
							}
						int k = 0;

						// 假设白子下的地方
						data.ARRAY[i][j] = 1;
						f.value();
						// 遍历找极大值
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.VALUE[i1][j1] > 1700
										&& data.VALUE[i1][j1] < 2600) {
									k++;
									// System.out.println(k);
								}
								if (data.VALUE[i1][j1] > 2800) {
									k += 3;
									// System.out.println(k);
								}
							}
						// 存储极大值的全指点
						data.MAXK[i][j] = k;

						int MAX2 = 0;
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.MAXK[i1][j1] > MAX2) {
									MAX2 = data.MAXK[i1][j1];
									NBXX = i1;
									NBYY = j1;
								}
							}

						// 如果它的极值点有两个,
						// System.out.println(k);
						if (MAX2 > 3 && data.VALUE[NBXX][NBYY] > 0) {
							//System.out.println(NBXX + "  " + NBYY);
							//System.out.println(data.VALUE[NBXX][NBYY]);
							data.FINAL[0] = NBXX;
							data.FINAL[1] = NBYY;
							//System.out.println(MAX2);
							//System.out.println("HAHA" + data.FINAL[0]
								//	+ data.FINAL[1]);
							MAX2 = 0;
						} else {
							pre(n - 1);
						}

						// 把假设的白子去掉
						data.ARRAY[i][j] = 0;

					}

				}

		}

		// 后判断黑棋，因为要保证黑棋先赢
		if (MAX < 1500) {
			// 假设黑棋下的地方
			for (int i = 0; i < 15; i++)
				for (int j = 0; j < 15; j++) {
					// 重置权值点
					for (int i2 = 0; i2 < 15; i2++)
						for (int j2 = 0; j2 < 15; j2++) {
							data.VALUE[i2][j2] = 1000;
						}
					int k = 0;
					// 找到没下的点
					if (data.ARRAY[i][j] == 0) {
						// 假设黑子下的地方
						data.ARRAY[i][j] = 2;

						f.value();
						// 遍历找极大值
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.VALUE[i1][j1] > 1700
										&& data.VALUE[i1][j1] < 2600) {
									k++;
								}
								if (data.VALUE[i1][j1] > 2600) {
									k += 3;
								}

							}

						int MAX2 = 0;// 最大K值点
						for (int i1 = 0; i1 < 15; i1++)
							for (int j1 = 0; j1 < 15; j1++) {
								if (data.MAXK[i1][j1] > MAX2) {
									MAX2 = data.MAXK[i1][j1];
									NBXX = i1;
									NBYY = j1;
								}
							}
						// 如果它的极值点有两个,
						// System.out.println(k);
						if (MAX2 > 3 && data.VALUE[NBXX][NBYY] > 0) {
							//System.out.println(k);
							data.FINAL[0] = NBXX;
							data.FINAL[1] = NBYY;
							//System.out.println("LALA");
							MAX2 = 0;
						} else {
							pre(n - 1);
						}

						// 把假设的黑子去掉
						data.ARRAY[i][j] = 0;
					}

				}

		}

	}
}

对于AI的完美追求是没有止境的，但是在追求人工智能的道路上每一步都需要汗水与思维碰撞出新鲜的思维。对于AI2.0我已经把接口写好了，大概思路就是用博弈树+剪枝，Alpha-Beta搜索算法。但我现在还没有想好如何去写，等以后有机会我一定会好好完善我的五子棋AI2.0，实现我打败熊哥的承诺。
下面是还没填好的AI2.0 
package xy_五子棋0717;

public class AI2 {
	
	int val;
	public int AlphaBeta(int depth, int alpha, int beta) { 
		if (depth == 0) { 
		return Evaluate(); 
		} 
		GenerateLegalMoves(); 
		while (MovesLeft()) { 
		MakeNextMove(); 
		val = -AlphaBeta(depth - 1, -beta, -alpha); 
		UnmakeMove(); 
		if (val >= beta) { 
		return beta; 
		} 
		if (val > alpha) { 
		alpha = val; 
		} 
	} 
		return alpha; 
		}

	private int Evaluate() {
		// TODO Auto-generated method stub
		return 0;
	}

	private void UnmakeMove() {
		// TODO Auto-generated method stub
		
	}

	private void MakeNextMove() {
		// TODO Auto-generated method stub
		
	}

	private boolean MovesLeft() {
		// TODO Auto-generated method stub
		return false;
	}

	private void GenerateLegalMoves() {
		// TODO Auto-generated method stub
		
	} 

}

其实，实现AI并不像我们想象的那么难，不要一开始就被它吓到了，试一下，你就会发现它真的很简单，至少比预测妹纸们的。。。要容易的多。。。。。。

分享到：
| array list
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    五子棋算法

    其它像围棋的“手淡”、象棋的“将族”等也以其优秀的人工智能深受棋迷喜爱；而我们今天将向大家介绍的是五子棋的算法。 　当我们与电脑对战时，您知道这些软件是怎样象人脑一样进行思考的吗？前不久我曾编写过一个...

    五子棋游戏，可以自动下棋

    　我们主要讨论五子棋的核心算法，即：人工智能部分，而其他像图形显示、键盘鼠标控制等，因较为简单，所以就不作过多介绍了。 　首先，请仔细阅读图1： 　我们看到本程序由六个基本功能模块构成，各模块的详细...

    C编写的五子棋

    可以预测两步，但是AI还是比较低的，但是还是可以下来玩玩儿，VC++6.0运行的

    用go写的五子棋预测算法的实现

    five in a row (五子棋成功预测) 从横、纵、 左斜升、 左斜降 四个角度判断 const( matrix = 50*50 point = 3 ) type Coordinat struct{ x int y int } type Allinat struct{ key []Coordinat } func In...

    wuziqi.rar_visual c_五子棋

    人工智能五子棋,采用多层迭代。可以预测10步。

    基于负极大值搜索的五子棋（C#版）

    人工智能课上的实验，采用负极大值搜索方法，能向前预测2步，基于VS2008的项目。

    wuziqi.rar_delphi 五子棋_delphi 搜索_delphi 递归_五子棋 delphi

    五子棋的delphi语言实现，实现向前搜索的人工智能搜索算法，加入递归调用，在电脑中预测出今后几步的各种走法，以便作出最佳选择。 可以实现人机博弈

    五子棋代码

    用MFC编写的五子棋代码小程序，具备部分人工智能，实现进行由低到高的预测分析功能，可进行人机对弈以及人人对弈

    AI 五子棋 beta1 （修改了一些小bug）

    可执行程序，dll为qt和.net相关文件， 该版本没有预测功能（源程序能生成预测子节点树结构，但是考虑到预算量太大，没有最终实现）

    C语言五子棋源程序(前个学期C语言实训的产物)

    这个是上个学期c语言实训时写的东西,用了大概3天时间,可以选择人机对战,人与人对战,不过由于时间比较仓促没有实现鼠标控制功能,画面也没有美化.电脑AI属新手级,因为我没让它多预测几步.

    gmssl_漏洞security_人机围棋_GmSSL_GmSSL计算机_alphago_

    因此，我利用人工智能的相关知识和计算机博弈的知识设计了基于神经网络的五子棋博弈算法，并开发了可演示算法的演示系统以及算法的接口dll。本作品的核心和难点在于神经网络的结构（包括网络拓扑结构，输入结构，...

    本科期末作业小项目代码.zip

    数据分析模块：运用统计学、人工智能等技术对数据进行深度挖掘和智能分析，提供决策支持。 业务流程管理模块：设计、执行、监控和优化业务流程，确保各项任务按照预定规则高效运转。 决策支持模块：基于数据...

    c语言资料（复习）

    3、可以再更进一步，用这个算法来预测以后的几步棋，再选择预测值最好的一步，这样电脑的AI就更高了 4、这个算法没有考虑黑棋的禁手（双3、双四和多于五子的连棋）。因为在平时我下的五子棋是没有这些 禁手的。

    数据结构与算法综合资料库.CHM

    3、可以再更进一步，用这个算法来预测以后的几步棋，再选择预测值最好的一步，这样电脑的AI就更高了 4、这个算法没有考虑黑棋的禁手（双3、双四和多于五子的连棋）。因为在平时我下的五子棋是没有这些 禁手的。

    JAVA上百实例源码以及开源项目

    百度云盘分享 简介 笔者当初为了学习JAVA，收集了很多经典源码，源码难易程度分为初级、中级、高级等，详情看源码列表，需要的可以直接下载！ 这些源码反映了那时那景笔者对未来的盲目，对代码的热情、执着，对...

    JAVA上百实例源码以及开源项目源代码

    Java 源码包 Applet钢琴模拟程序java源码 2个目标文件，提供基本的音乐编辑功能。编辑音乐软件的朋友，这款实例会对你有所帮助。 Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 ...

Magicbox
Global site tag (gtag.js) - Google Analytics