Triangle Peg Solitaire(孔明棋)

最新推荐文章于 2024-02-09 10:18:11 发布
最新推荐文章于 2024-02-09 10:18:11 发布
阅读量4.5k 收藏 9
点赞数 2
分类专栏： DFS 基础编程 java 孔明棋 文章标签： java DFS 回溯
java 同时被 3 个专栏收录
35 篇文章 0 订阅
订阅专栏
基础编程
18 篇文章 0 订阅
订阅专栏
DFS
1 篇文章 0 订阅
订阅专栏
孔明棋，是法国跳棋 独立钻石在中国的别称，也有人叫它跳弹珠，或者叫它「Pegged」。一般流传的玩法是先取去中央的那个棋子，便可以展开游戏。游戏时，是将棋子跳过邻近的棋子，到达一个旁边空着的位置，被跳过的棋子则从棋盘上取开；跳的路径可以前，后，左，右，但不可对角跳，直到剩下最后的一颗棋子，游戏便结束了。这是一种流传很广的益智游戏，也有很多种变形的棋盘摆法，而本文要讲的是在三角形棋盘上的玩法，它是自17世纪末就在欧洲开始被人们玩起来了。当各大餐厅为每一个餐桌上等待食物的顾客都放置一个棋盘以供他们娱乐的时候，这类益智游戏变得越来越流行。
本文实际上通过一段简单的回溯算法DFS去搜索找出一个解决给定棋盘上的出发点的解决方案。

背景
这个方案的主要目的是陈述一个递归函数的概念，本质上就是递归问题和回溯。它还提供了一个面向对象的思维，在一个可重用的类里来保存所有回溯逻辑形式。解决这个难题，需要使用被称为回溯的技术来搜索所有可能的移动路径，这是很容易使用递归实现的。

基本的步骤

三角之谜是15孔组织成一个三角形的集合，在其中放置钉，留下至少一个空孔。通常，该益智游戏开始只有一个空孔，如在结构（a）所示，其中实心圆圈代表钉，而空的圆圈代表孔。解谜的目的是通过一系列合法的移动，每个移动造成一个钉被删除，直到最后只剩下一个钉。一个钉被删除仅仅是通过跳过它的其他钉。因此，一个合法的移动只能是由一个位于孔和其他钉的侧面的钉移动，它们排列在一行。例如，结构（b）所示的结构是由结构（a）经过一次跳跃获得，然后（c）又由（b）再次一次跳跃得到。





代码
GameBoard.java:此类是为了生成三角形状的棋盘 
package com.game.board;

import java.util.List;
import java.util.ArrayList;


public class GameBoard {
	
	// board consists of pegs and holes in a 5 x 5, but only uses triangular pyramid
	boolean[][] pins = new boolean[5][5];

	
	public GameBoard(int row, int col) {
		for (int i = 0; i < 5; ++i)
			for (int j = 0; j <= i; ++j)
				pins[i][j] = true;
		pins[row][col] = false;
	}
	

	public GameBoard(int board) {
		for (int i = 4; i >= 0; --i)
			for (int j = i; j >= 0; --j) {
				if ((board & 1 ) == 1) 
					pins[i][j] = true;
				else
					pins[i][j] = false;
					board /= 2;
			}

	}

	
	// copy constructor
	public GameBoard(GameBoard that) {
		for (int i = 0; i < 5; ++i)
			for (int j = 0; j <= i; ++j)
				pins[i][j] = that.pins[i][j];
	}


	public List<GameBoard> possibleBoards() {
		List<GameBoard> boards = new ArrayList<GameBoard>();
		
		for (int i = 0; i < 5; ++i)
			for (int j = 0; j <= i; ++j) {
				Position start = new Position(i,j);
				List<Move> possibleMoves = Moves.getMoves(start);
				for (Move move : possibleMoves) {
					if (validMove(move))
						boards.add(jump(move));
				}
			}
		
		return boards;
	}
	
	
	public boolean validMove(Move move) {
		if (!pins[move.getStart().getRow()][move.getStart().getCol()])	// empty start
			return false;
		if (!pins[move.getJump().getRow()][move.getJump().getCol()])	// empty jump over
			return false;
		if (pins[move.getEnd().getRow()][move.getEnd().getCol()])		// filled in end
			return false;
		
		return true;
	}
	
	
	public GameBoard jump(Move move) {
		GameBoard gb = new GameBoard(this);
		
		gb.pins[move.getStart().getRow()][move.getStart().getCol()] = false;
		gb.pins[move.getJump().getRow()][move.getJump().getCol()] = false;
		gb.pins[move.getEnd().getRow()][move.getEnd().getCol()] = true;
		
		return gb;
	}
	
	
	public boolean finalBoard() {
		int remainingPins = 0;

		for (int i = 0; i < 5; ++i)
			for (int j = 0; j <= i; ++j) 
				if (pins[i][j]) {
					remainingPins++;
					if (remainingPins > 1)	// optimize, early out, more than 1 pin is not final board
						return false;
				}
		
	    return remainingPins == 1;
	}	

	
	public int toInt() {
		int ret = 0;
		for (int i = 0; i < 5; ++i)
			for (int j = 0; j <= i; ++j) {
				ret *= 2;
				if (pins[i][j]) {
					ret |= 1;
				}
			}

		return ret;
	}
	
	
	public String toString() {
		StringBuffer sb = new StringBuffer();
		
		for (int i = 0; i < 5; ++i) {
			for (int s = 4-i; s > 0; --s)
				sb.append(" ");
			for (int j = 0; j <= i; ++j) {
				sb.append(pins[i][j] ? 'X' : 'O').append(" ");
			}
			sb.append("\n");
		}
//		sb.append(toInt()+ "\n");
		
		return sb.toString();
	}
}
Move.java：移动的坐标指向类 
package com.game.board;

public class Move {
	private Position start;
	private Position jump;
	private Position end;
	
	public Move(Position start, Position jump, Position end) {
		this.start = start;
		this.jump = jump;
		this.end = end;
	}
	
	public Position getStart() { return start; }
	public Position getJump() { return jump; }
	public Position getEnd() { return end; }
	
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("{"+start);
		sb.append(","+jump);
		sb.append(","+end+ "}");
		
		return sb.toString();
	}
}
Moves.java：将所有起始点可以移动的方向全部列举并放入map集合中 
package com.game.board;

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;


public class Moves {
	private static Map<Position,List<Move>> validMoves = new HashMap<Position,List<Move>>();
	
	static {
		/* 
		 *          0,0 
		 *       1,0  1,1
		 *     2,0  2,1  2,2
		 *   3,0  3,1  3,2  3,3
		 * 4,0  4,1  4,2  4,3  4,4
		 * 
		 */
		Position start;
		
		start = new Position(0,0);	
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(1,0), new Position(2,0)));
		validMoves.get(start).add(new Move(start, new Position(1,1), new Position(2,2)));
		
		start = new Position(1,0);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,0), new Position(3,0)));
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(3,2)));
		
		start = new Position(1,1);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(3,1)));
		validMoves.get(start).add(new Move(start, new Position(2,2), new Position(3,3)));	
		/* 
		 *          0,0 
		 *       1,0  1,1
		 *     2,0  2,1  2,2
		 *   3,0  3,1  3,2  3,3
		 * 4,0  4,1  4,2  4,3  4,4
		 * 
		 */	
		start = new Position(2,0);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(1,0), new Position(0,0)));
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(2,2)));
		validMoves.get(start).add(new Move(start, new Position(3,0), new Position(4,0)));
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(4,2)));
	
		start = new Position(2,1);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(4,1)));
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(4,3)));
		
		start = new Position(2,2);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(1,1), new Position(0,0)));
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(2,0)));
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(4,2)));
		validMoves.get(start).add(new Move(start, new Position(3,3), new Position(4,4)));	
		/* 
		 *          0,0 
		 *       1,0  1,1
		 *     2,0  2,1  2,2
		 *   3,0  3,1  3,2  3,3
		 * 4,0  4,1  4,2  4,3  4,4
		 * 
		 */	
		start = new Position(3,0);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,0), new Position(1,0)));
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(3,2)));	

		start = new Position(3,1);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(1,1)));
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(3,3)));

		start = new Position(3,2);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,1), new Position(1,0)));
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(3,0)));	
		
		start = new Position(3,3);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(2,2), new Position(1,1)));
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(3,1)));	
		/* 
		 *          0,0 
		 *       1,0  1,1
		 *     2,0  2,1  2,2
		 *   3,0  3,1  3,2  3,3
		 * 4,0  4,1  4,2  4,3  4,4
		 * 
		 */	
		start = new Position(4,0);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,0), new Position(2,0)));
		validMoves.get(start).add(new Move(start, new Position(4,1), new Position(4,2)));	

		start = new Position(4,1);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(2,1)));
		validMoves.get(start).add(new Move(start, new Position(4,2), new Position(4,3)));	
		
		start = new Position(4,2);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,1), new Position(2,0)));
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(2,2)));
		validMoves.get(start).add(new Move(start, new Position(4,1), new Position(4,0)));
		validMoves.get(start).add(new Move(start, new Position(4,3), new Position(4,4)));
		
		start = new Position(4,3);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,2), new Position(2,1)));
		validMoves.get(start).add(new Move(start, new Position(4,2), new Position(4,1)));

		start = new Position(4,4);
		validMoves.put(start, new ArrayList<Move>());	
		validMoves.get(start).add(new Move(start, new Position(3,3), new Position(2,2)));
		validMoves.get(start).add(new Move(start, new Position(4,3), new Position(4,2)));	
	}

	
	public static List<Move> getMoves(Position position) {
		if (!validMoves.containsKey(position))
			throw new RuntimeException("Invalid position: " + position);
		
		return validMoves.get(position);
	}

	
	public String toString() {
		return validMoves.toString();
	}
}
position.java：坐标类 
package com.game.board;

public class Position {
	int row;
	int col;
	
	public Position(int row, int col) {
		this.row = row;
		this.col = col;
	}
	
	public int getRow() { return row; }
	public int getCol() { return col; }

	public String toString() {
		return "[" + row + "," + col + "]";
	}
	
	public int hashCode() {
		int result = 17;
		
		result = 37*result + row;
		result = 37*result + col;
		
		return result;
	}
	
	public boolean equals(Object other) {
		if (!(other instanceof Position))
			return false;
		Position that = (Position) other;
		
		if (this.row != that.row)
			return false;
		
		return this.col == that.col;
	}
}
GameTree.java：以树的形式保存遍历的所有路径 
package com.game.play;

import java.util.List;
import java.util.ArrayList;

import com.game.board.GameBoard;


public class GameTree {
	GameTree level;
	
	GameBoard gb;
	List<GameTree> children = new ArrayList<GameTree>();
	
	public GameTree(GameBoard gb) {
		this.gb = gb;
	}
	
	public void addChild(GameTree child) {
		children.add(child);
	}

	public GameBoard getGameBoard() { return gb; }

	public boolean hasChildren() {
		return children.size() > 0;
	}

	public GameTree getFirstChild() {
		return children.get(0);
	}

	public void removeFirstChild() {
		children.remove(0);
	}
	
	public int numChildren() {
		return children.size();
	}
}
Play.java：通过DFS搜索所有可能的路径 
package com.game.play;

import java.io.IOException;
import java.util.List;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import com.game.board.GameBoard;

public class Play {
	
	GameBoard startBoard;
	
	
	public Play(String[] args) throws IOException {
		if (args.length == 0) {
			int n1,n2;
	        BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));
	        System.out.println("Name: samudra ");
	        System.out.println("......................................");
			System.out.println("Enter the position of the hole:");
			n1=Integer.parseInt( stdin.readLine());
			n2=Integer.parseInt( stdin.readLine());
            init(n1,n2);
		}
		else
			init(Integer.parseInt( args[0]),Integer.parseInt( args[1]));
	}
	
	
	private void init(int row, int col) {
		startBoard = new GameBoard(row, col);
	}
	
	//DFS function
	public void DFS() {
		GameTree root = new GameTree(startBoard);
		
		for (GameBoard nextBoard : startBoard.possibleBoards()) {
			GameTree nextNode = new GameTree(nextBoard);
			if (play(nextBoard, nextNode))
				root.addChild(nextNode);
		}
		
		 printWinningGame(root); 

	}
	
	// to iterate is human, to recurse divine
	// print game board at each node on the way down, removing the printed child on the way up
	private void printWinningGame(GameTree parent) {
		System.out.println(parent.getGameBoard());
		
		if (parent.numChildren() > 0) {
			GameTree nextNode = parent.getFirstChild();			
			printWinningGame(nextNode);				// recurse
			if (nextNode.numChildren() == 0)	
				parent.removeFirstChild();
		} else {
			System.out.println("===============================================");
		}
	}
	
	// chase all possible boards
	private boolean play(GameBoard gb, GameTree parent) {
		
		if (gb.finalBoard())	// remember this path was a winning path
			return true;
		
		List<GameBoard> nextBoards = gb.possibleBoards();
			
		boolean found = false;
		
		for (GameBoard nextBoard : nextBoards) {
			GameTree nextNode = new GameTree(nextBoard);
			if (play(nextBoard, nextNode)) {				// recurse
				found = true;
				parent.addChild(nextNode);
			}
		}
		
		return found;
	}
	
	
}
PegBord.java：主方法 
package com.game.main;

import java.io.IOException;

import com.game.play.Play;

public class PegBoard {

/**
* @param args
*/
	public static void main(String[] args) throws IOException {
		Play play = new Play(args);
		play.DFS();
	}
	
}

运行结果展示：
Name: samudra 
......................................
Enter the position of the hole:
2
1
    X 
   X X 
  X O X 
 X X X X 
X X X X X 


    X 
   X X 
  X X X 
 X O X X 
X O X X X 


    X 
   X X 
  X X X 
 X X O O 
X O X X X 


    X 
   O X 
  X O X 
 X X X O 
X O X X X 


    X 
   O O 
  X O O 
 X X X X 
X O X X X 


    X 
   X O 
  O O O 
 O X X X 
X O X X X 


    O 
   O O 
  X O O 
 O X X X 
X O X X X 


    O 
   O O 
  X O O 
 O X X X 
X X O O X 


    O 
   O O 
  O O O 
 O O X X 
X X X O X 


    O 
   O O 
  O O O 
 O O X X 
X O O X X 


    O 
   O O 
  O O X 
 O O X O 
X O O X O 


    O 
   O O 
  O O O 
 O O O O 
X O X X O 


    O 
   O O 
  O O O 
 O O O O 
X X O O O 


    O 
   O O 
  O O O 
 O O O O 
O O X O O 


===============================================
















ColdOrCoder
关注
专栏目录
孔明棋(手機遊戲JAVA源代碼)
02-28
孔明棋的手機遊戲JAVA源代碼，作業的環境為Android，可在模擬器上執行
java版孔明棋
06-11
java版孔明棋，支持自动生成棋局，console和swing界面。
孔明棋
lcmssd
01-30 6630
跳转原文 说明：写完才发现，文中的很多截图都被csdn打上水印，其实这些截图都来自上述原文，尊重原著！！ 根据WIKI孔明棋应该起源于欧洲，原名pegged, 不知道现在怎么和诸葛亮扯上了关系。规则和跳棋相似，但是一个人就可以玩，目标是按照规则移动棋子，最终只有一个棋子留在棋盘上。发展至今，pegged已经发展出很多新的形式，但是最典型的是如下形式 33个棋子
孔明棋算法
qq_41046491的博客
03-02 6297
背景 先来介绍下孔明棋吧，它是法国跳棋独立钻石在中国的别称，英文叫做“Pegged”。简单介绍下玩法吧， 常见棋盘如下： 走棋规则如下： 图中的黑点为有棋子，白点为无棋子。 算法介绍 这个算法其实整个程序不是很难，但是针对程序的设计很容易走弯路，导致算法复杂度增加。初次尝试时，我当时考虑到这一问题，随着棋盘复杂度增加，白点越来越少，因此我把白点作为参考点，然后遍历所...
我用VB做的孔明棋游戏
翔的窝窝
05-29 1190
我用VB做的孔明棋游戏附源码http://download1.csdn.net/down3/20070530/30200905916.rar
triangle_matlab重载函数_triangle函数_三角形周长、面积计算_
09-29
本案例中，我们关注的是一个名为`triangle`的重载函数，该函数用于计算三角形的周长和面积。以下是关于这个主题的详细讲解。 首先，我们需要理解函数重载的概念。在MATLAB中，函数重载通过提供多个具有相同名称但...
draw_triangle.rar_VISIO draw triangle_glut triangle_triangle_颜色
09-20
在给定的"draw_triangle.rar"压缩包中，包含的资源可能是一个教学或实践项目，教导如何在GLUT（OpenGL Utility Toolkit）环境下利用OpenGL绘制颜色渐变的三角形。GLUT是一个用于创建和管理OpenGL窗口、处理用户输入...
gl_triangle.zip_triangle
09-21
在这个“gl_triangle.zip_triangle”压缩包中，我们聚焦于一个基础且重要的概念：绘制三角形。三角形在3D图形中是基本构建块，用于构建更复杂的形状和场景。 `Main.cpp`通常是C++程序的入口点，这里很可能是实现...
sierpinski-triangle.zip_Sierpinski_triangle_triangle code
07-15
**塞尔皮斯基三角形（Sierpinski Triangle）** 塞尔皮斯基三角形，又称为谢尔宾斯基三角或谢尔宾斯基金字塔，是数学中一个经典的分形几何形状。这个图形是由波兰数学家瓦迪斯瓦夫·塞尔皮斯基在1915年提出的。它...
glut_triangle.rar_triangle
09-14
在"glut_triangle.rar_triangle"这个压缩包中，我们主要关注的是如何使用OpenGL来绘制一个基本的三角形。文件"glut_triangle.cpp"是实现这一功能的C++源代码。 在OpenGL中，三角形是最基本的图形单元，几乎所有的...
Triangular Peg Solitaire solver-开源
04-28
一个简单的命令行工具，用于解决三角钉单人纸牌游戏，例如Cracker Barrel上的那种。 还具有其他一些功能。
java 编写的孔明棋 (具有人工智能)
11-10
开发工具 JBuilder,孔明棋具有启发式搜索及其盲目搜索功能,.jar文件可以直接运行，或者用jbuilder打开工程可以编辑
Peg solitaire CppBFS版
10-05
Peg solitaire CppBFS版
孔明棋App源码
05-05
孔明棋 chromeApppegsolitaire-master
2016 UESTC Training for Math Problem B-三角形棋盘上的博弈游戏（打表+DP）
lovemejj的博客
06-09 627
B - 三角形棋盘上的博弈游戏 Time Limit: 3000/1000MS (Java/Others)    Memory Limit: 65535/65535KB (Java/Others) 柱爷有天上课无聊，于是和同桌卿学姐一起下一种奇特的棋： 棋盘如图： 在开始游戏前，棋盘上已经放好了一些边，然后柱爷先手，开始在棋盘上没有边的位置添加一条边上去 如果添加边后围成一个三角
URAL 1051 跳跳棋（孔明棋）（加强版） 数学找规律（较弱哦）
chenwenxiaocom的专栏
05-20 3731
 跳跳棋（加强版）问题描述hty想到最近出过一道1*N的跳跳棋游戏，于是他想是否2维也能有很好的方法呢？于是有了下面这道题，题目如下：在一个无限大的棋盘的格子上有一些棋子，这些棋子构成一个M*N的矩形(M为高度，N为宽度)。你可以用一个棋子跳过另一个相邻的棋子，被跳过的棋子将被移去，请你求出最少能剩下几个棋子。输入文件本题有多组数据。对于每组数据，仅有一行，两个正整数M，N，最后一行M=N=0，无需处理此行数据。输出文件对于每组数据，一个正整数，表示最少剩下的棋子数。输入样例3 40 0输出样例2数据规
P9700 [GDCPC2023] Peg Solitaire
最新发布
xxyrcgtzbh554488的博客
02-09 449
每一次寻找一个当前存在棋子的格子，往上，下，左，右四个方向，判断合不合法，判断条件为题面中的图，若合法，就按题意走出一步，并继续搜索。vis[i][j+2])//往右跳。vis[i+2][j])//往下跳。vis[i][j-2])//往左跳。vis[i-2][j])//往上跳。
Go语言解决孔明棋的玩法(加深对for循环的认识)
深度学习领域优质创作者，CSDN博客专家
10-27 719
遍历的学习，区别于其他语言的for
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值