intel2011多线程编程大赛之一Game Of Life 最优寻址单线程-CSDN博客

本文链接：https://blog.csdn.net/ThinkinGall/article/details/6417036

2011/05/13

Game Of Life 实现最优寻址之一单线程

MazeOfLife类，实现细胞规则的check，和网格的重新分布，算法的寻址。重点类。

MazeQueue类是容器类，这里的所以节点内容都存放在此类属性LinkedList（是个好东西）类容器中。

Node类节点类，包括point，当前point对应的网格数组分布，前节点preNode。

Point类是坐标点类，(0,0)开始，(0,1)是数组的第0行，第一列。

DebugLog类是打印类，用于结果输出和Debug输出用。

重点类使用了计时器。测试时间。System.currentTimeMillis();

MazeOfLife.class

/******************************************************************************* * @file MazeOfLife * @brief MazeOfLife class * @note Copyright (C) 2010 * @author XuYD * @date 2011/05/08 * @version 1.0 ******************************************************************************/ package intel.life; public class MazeOfLife { /** 网格地图 */ private int[][] mazeGrid = null; /** 相邻节点计算结果网格地图 */ private int[][] ai = null; /** 目标点 */ private Point tarPoint = null; /** 当前点 */ private Point curPoint = null; /** 地图行 */ private int rows = 0; /** 地图列 */ private int cols = 0; /** * 对象0-8个方向坐标 * 1 2 3 * 8 0 4 * 7 6 5 */ private int[] x = {-1, 0, 1, 1, 1, 0, -1, -1, 0}; private int[] y = {-1, -1, -1, 0, 1, 1, 1, 0, 0}; /** 队列 */ private MazeQueue queue = new MazeQueue(); /** 前一次寻址路径 */ private String preResultValue = ""; /** 当前寻址路径 */ private String curResultValue = ""; /** 是否找到路径 */ private boolean searchResult = false; /** while循环次数 */ private int count = 0; /** 结果方案个数 */ private int number = 0; /** * constructor */ public MazeOfLife() {} /** * main method * @param args */ public static void main(String[] args) { MazeOfLife maze = new MazeOfLife(); maze.initialize(); long start = System.currentTimeMillis(); maze.doSearch(); long end = System.currentTimeMillis(); DebugLog.printResultln((end - start) + "ms"); } /** * initialize */ public void initialize() { /*-------假设从gridin.txt读取的值如下 Start--------*/ rows = 7; cols = 7; ai = new int[rows + 2][cols + 2]; // mazeGrid = // new int[][]{{0, 0, 0, 0, 0, 0, 0}, {0, 1, 1, 0, 0, 0, 0}, {0, 1, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, // {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}}; // /* (3,1)(3,5)*/ // curPoint = new Point(2, 2); // tarPoint = new Point(5, 5); // mazeGrid = // new int[][]{{0, 0, 0, 0, 0, 0, 0}, {0, 1, 1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, // {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}}; // // /* (3,1)(3,5)*/ // curPoint = new Point(2, 1); // tarPoint = new Point(2, 2); // mazeGrid = // new int[][]{{0, 0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0}, // {0, 0, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0, 0}}; // /* (3,1)(3,5) 1/5*/ // curPoint = new Point(3, 1); // tarPoint = new Point(3, 5); // mazeGrid = // new int[][]{{0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 1, 1, 1, 0, 0}, // {0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}}; // /* (3,1)(3,5) 1/5*/ // curPoint = new Point(5, 1); // tarPoint = new Point(1, 5); mazeGrid = new int[][]{{0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 1, 0, 0}, {0, 0, 1, 0, 1, 0, 0}, {0, 0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}}; /* (1,1)(5,5) 3/5 */ curPoint = new Point(1, 1); tarPoint = new Point(5, 5); // mazeGrid = // new int[][]{{0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 1, 0, 1, 0}, {0, 0, 1, 0, 1, 0, 0}, {0, 0, 0, 1, 0, 0, 0}, // {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}}; // /* (1,3)(5,3) 4/5 */ // curPoint = new Point(1, 3); // tarPoint = new Point(5, 3); // mazeGrid = // new int[][]{{1, 1, 0, 0, 0, 0, 0}, {1, 1, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 0, 0, 0}, // {0, 0, 0, 0, 1, 1, 0}, {0, 0, 0, 0, 1, 0, 1}, {0, 0, 0, 0, 0, 1, 0}}; // /* (1,1)(5,5) 5/5 */ // curPoint = new Point(1, 1); // tarPoint = new Point(5, 5); /*-------假设从gridin.txt读取的值 END--------*/ } /** * 开始寻找路径 * 1.bug1=>Queue的数组队列使用出界。解决：选用了LinkedList类(FIFO，LIFO) * 2.bug2=>就是出现【584334047】和【5843340470】这样结果。解决：目标点检测的时候：是->print，break；不是->入队列。 * 3.bug3=>暂时没有出现，就是死循环，比如四个正方形点的时候。解决：如果在向0方向移动且节点一样就不入队列。 * 4.bug4=>那有没有这种情况，在某个循环范围内出现重复，比如走3-5-7-1，这样3和1节点是一样的情况。解决：暂时没有方法... * 5.问题=>为什么每次第一个输出的就是最优解呢。 * 6.期望=>无线地循环下去了，节点经过多次也能到达的取消，即选择最优解。 * * 对于5=>首先我们知道FIFO的队列，每次都从同一节点循环一周(0-8)方向， * 对列中节点距原始点距离从小到大排序(12233) * 所以肯定是最上面节点先找到。因为弹出是从上面开始的。 * 如果上面的节点找到路径，则下面的节点找到路径的长度 * 一定是大于等于他(个数最多是好像不确定，不是8个)。 * * 对于4的需要加个判断。 * * 对于6=>当下一次找到刚好大于前一次节点的距离时候，就终止，说明之前的就是最优解。 */ public void doSearch() { /* * 节点对象,当前点的上一个节点为null * 由于网格地图是变化的，不像迷宫一样，所以每次如同节点入队列，网格地图也要保存 */ Node curNode = new Node(curPoint, null, mazeGrid); /* 是否是在当前不移动 */ boolean isSelfNode = false; /* 向队列末尾追加 */ if (!queue.addNode(curNode)) { DebugLog.printFatalln("队列空间不足！~"); return; } while (!queue.isEmpty()) { /* 开始走,出栈,从head */ curNode = queue.popNode(); count++; // DebugLog.printInfoln("*****第 "+ count +" 次出栈("+curNode.point.x+","+curNode.point.y +")*****"); // if(count == 10){ // return; // } /* * i=0 => 矩阵(左上) * i=1 => 矩阵(向上) * i=2 => 矩阵(右上) * i=3 => 矩阵(向右) * i=4 => 矩阵(右下) * i=5 => 矩阵(向下) * i=6 => 矩阵(左下) * i=7 => 矩阵(向左) */ for (int i = 0; i < x.length; ++i) { Node nextNode = new Node(new Point(), null, null); /* set the next node */ nextNode.point.x = curNode.point.x + x[i]; nextNode.point.y = curNode.point.y + y[i]; nextNode.preNode = curNode; nextNode.setGridCopy(curNode.getGridCopy()); // DebugLog.printInfoln("-----第 "+i+" 循环:----从("+curNode.point.x+","+curNode.point.y +")=>" + "("+nextNode.point.x+","+nextNode.point.y +")"); /* 判断是否向0方向移动 */ isSelfNode = nextNode.point.equals(curNode.point); /* 检查下一个点 */ if (!unitCheck(nextNode, isSelfNode)) { continue; } else { /* 尝试move到新节点 */ moveToNextPoint(nextNode); /* 检查是否遵循规则，按照规则修改网格地图的所以点 */ if (ruleScanCheck(nextNode)) { /* 1.如果等于目标点,从该点的节点回溯遍历 */ if (nextNode.point.equals(tarPoint)) { searchResult = true; /* print result */ if(printSearchResult(nextNode)){ return; } /* 找到的话就不用再去循环试探了,循环结束开始重新弹出一个节点 */ break; } /* 2.如果不是目标点 */ else { /* 2.1 如果是向0方向移动且网格数组一样就不入队列 */ if (isSelfNode == true) { if (nextNode.compare(nextNode.preNode)) { continue; } } /* 2.2 向队列末尾追加 */ if (!queue.addNode(nextNode)) { DebugLog.printFatalln("队列空间不足！~"); return; } } } } } } if (!searchResult) { DebugLog.printResultln("没有找到路径" + ++number + "--size" + queue.size() + ": "); } } /** * 输出寻址的结果,寻址到最短路径就结束 * * @param node * @return true...寻址结束；false...继续寻址 */ public boolean printSearchResult(Node node) { Node curNode = null; /* 创建堆栈,存放该节点 */ java.util.Stack<Node> stack = new java.util.Stack<Node>(); stack.push(node); /* * 当前节点指向该节点的前节点 * 循环从该节点获取前节点 * 前节点再向前索取,这样循环获取节点 */ while ((curNode = node.preNode) != null) { /* 当前节点指向该节点 */ node = curNode; /* 压栈 */ stack.push(curNode); } /* 循环获取路径 */ curResultValue = ""; for (int k = stack.size() - 2; k >= 0; k--) { /*--------get the path result---------*/ curResultValue += coordinatorToOrientation(stack.get(k + 1).point, stack.get(k).point); } if ((preResultValue.length() > 0) && (curResultValue.length() > preResultValue.length())) { return true; } else { preResultValue = curResultValue; DebugLog.printResult("解决方案路径" + ++number + "--出栈："+count+"次--队列深度：" + queue.size() + ": "); DebugLog.printResultln(preResultValue); return false; } } /** * 根据坐标求出方向0-8 * 1 1 1 * 1 0 1 * 1 1 1 * * @param prePoint 原始坐标 * @param nextPoint 目标坐标 * @param mazeGridCopy 网格数组副本 * * @return none */ private int coordinatorToOrientation(Point prePoint, Point nextPoint) { int orientation = -1; int distanceRow = nextPoint.x - prePoint.x; int distanceCol = nextPoint.y - prePoint.y; /* 水平向左：1,8,7 */ if (distanceCol == -1) { /* 向左上：1 */ if (distanceRow == -1) { orientation = 1; } /* 向左：8 */ else if (distanceRow == 0) { orientation = 8; } /* 向左下：7 */ else if (distanceRow == 1) { orientation = 7; } } /* 水平居中：2,0,6 */ else if (distanceCol == 0) { /* 水平向上：2 */ if (distanceRow == -1) { orientation = 2; } /* 水平：0 */ else if (distanceRow == 0) { orientation = 0; } /* 水平向下：6 */ else if (distanceRow == 1) { orientation = 6; } } /* 水平向右：3,4,5 */ else if (distanceCol == 1) { /* 水平向上：3 */ if (distanceRow == -1) { orientation = 3; } /* 水平：4 */ else if (distanceRow == 0) { orientation = 4; } /* 水平向下：5 */ else if (distanceRow == 1) { orientation = 5; } } return orientation; } /** * 节点基本检查 * 1.处在地图范围内 * 2.节点是处于活动(0)状态 * 3.如果在当前不移动，则不用check2 * @param point * @param isSelfNode * @return boolean,OK...NG */ private boolean unitCheck(Node node, boolean isSelfNode) { int row = node.point.x; int col = node.point.y; /* 处在地图范围内 */ if ((row < 0 || row >= node.getGridCopy().length) || (col < 0 || col >= node.getGridCopy()[0].length)) { return false; } /* 点上没有节点状态 */ if (!isSelfNode && node.getGridCopy()[row][col] != 0) { return false; } return true; } /** * 从前节点移动到下一个节点 * @param node */ private void moveToNextPoint(Node node) { node.getGridCopy()[node.preNode.point.x][node.preNode.point.y] = 0; node.getGridCopy()[node.point.x][node.point.y] = 1; } /** * 节点规则检查 * 1.是否遵循规则，保证节点可以存活 * 2.存活的话，按照规则修改网格地图的节点 * * @param point * @return boolean,OK...NG */ private boolean ruleScanCheck(Node node) { int row = node.point.x; int col = node.point.y; /* 相邻节点计算结果网格地图初始化 */ for (int i = 0; i < rows + 2; i++) { for (int j = 0; j < cols + 2; j++) { ai[i][j] = 0; } } /* * 如果life数组中life[i][j] = 1则，设置al数组[i][j]四周都是+1 * 1 1 1 * 1 0 1 * 1 1 1 * 叠加之后，就可以算出life[i][j]点周围有几个节点，就是al[i][j]的值。 */ for (int i = 1; i < rows + 1; i++) { for (int j = 1; j < cols + 1; j++) { if ((node.getGridCopy()[i - 1][j - 1] & 1) == 1) { ai[i - 1][j - 1]++; ai[i - 1][j]++; ai[i - 1][j + 1]++; ai[i][j - 1]++; ai[i][j + 1]++; ai[i + 1][j - 1]++; ai[i + 1][j]++; ai[i + 1][j + 1]++; } } } /* 坐标点转换为数组(对角变换)获取节点周围节点个数 */ if ((ai[row + 1][col + 1] < 2) || (ai[row + 1][col + 1] > 3)) { return false; } // printArrayTest("--------节点走后地图更新前---------", node.getGridCopy()); // printArrayTest("--------节点走后地图重新计算---------", ai); /* * 数组按照规则重新布置处理 * 因为节点是同时发生的，所以保证有一个副本(al数组)存在才能判断(周围节点个数)， * 否则life数据变更，而无法判断节点出生 */ for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { /* 1.如果有节点存在 */ if (node.getGridCopy()[i][j] == 1) { /* 1.1 判断时候可以存活(周围为0或者1，或者大于3) */ if (ai[i + 1][j + 1] < 2 || ai[i + 1][j + 1] > 3) { node.getGridCopy()[i][j] = 0; } } /* 2.如果没有节点存在，如果周围节点数位3，则出生 */ else if (ai[i + 1][j + 1] == 3) { node.getGridCopy()[i][j] = 1; } } } // printArrayTest("--------节点走后地图更新后---------", node.getGridCopy()); return true; } /** * TEST, array out * @param note * @param al */ public void printArrayTest(String note, int[][] arrPrint) { DebugLog.printInfoln(note); for (int j1 = 0; j1 < arrPrint.length; j1++) { DebugLog.printInfo("[" + j1 + "] "); for (int j = 0; j < arrPrint[0].length; j++) { DebugLog.printInfo(arrPrint[j1][j] + " "); if (j == arrPrint[j1].length - 1) { DebugLog.printInfoln(""); } } } } }

MazeQueue.class

/******************************************************************************* * @file Queue * @brief Queue class * @note Copyright (C) 2010 * @author XuYD * @date 2011/05/08 * @version 1.0 ******************************************************************************/ package intel.life; import java.util.LinkedList; public class MazeQueue { /** 是一种先进先出的队列结构，从底部进从头部出 */ LinkedList<Node> queueNodes = null; public MazeQueue() { queueNodes = new LinkedList<Node>(); } /** * 入栈，从底部开始放入 * * @param node * @return */ public boolean addNode(Node node) { queueNodes.offer(node); return true; } /** * 出栈，从顶部开始获取 * * @return */ public Node popNode() { return queueNodes.poll(); } /** * check is empty * * @return */ public boolean isEmpty() { return queueNodes.isEmpty(); } /** * queueNodes size */ public int size() { return queueNodes.size(); } /** * print queueNodes * */ public void printQueue() { for (int i = 0; i < queueNodes.size(); i++) { DebugLog.printInfoln("(" + queueNodes.get(i).point.x + "," + queueNodes.get(i).point.y + ")"); } } }

Node.class

/******************************************************************************* * @file Node * @brief Node class * @note Copyright (C) 2010 * @author XuYD * @date 2011/05/08 * @version 1.0 ******************************************************************************/ package intel.life; public class Node { /** 当前网格坐标点 */ Point point = null; /** 前一网格节点 */ Node preNode = null; /** 当前节点对应的网格地图 */ private int[][] gridCopy = null; /** * constructor */ public Node() { this(null, null, null); } /** * constructor * @param point * @param node * @param grid */ public Node(Point point, Node preNode, int[][] grid) { this.point = point; this.preNode = preNode; setGridCopy(grid); } /** * compare node differ * @param node * @return */ public boolean compare(Node node){ if(!point.equals(node.point)){ return false; } for (int i = 0; i < gridCopy.length; i++) { for (int j = 0; j < gridCopy[0].length; j++) { if(gridCopy[i][j] !=node.getGridCopy()[i][j]){ return false; } } } return true; } public Point getPoint() { return point; } public void setPoint(Point point) { this.point = point; } public Node getPrevious() { return preNode; } public void setPrevious(Node preNode) { this.preNode = preNode; } public int[][] getGridCopy() { return gridCopy; } public void setGridCopy(int[][] grid) { /* copy grid array */ if (grid != null && grid.length != 0) { gridCopy = new int[grid.length][grid[0].length]; for (int i = 0; i < grid.length; i++) { for (int j = 0; j < grid[0].length; j++) { gridCopy[i][j] = grid[i][j]; } } } } }

Point.class

/******************************************************************************* * @file Point * @brief Point class * @note Copyright (C) 2010 * @author XuYD * @date 2011/05/08 * @version 1.0 ******************************************************************************/ package intel.life; public class Point { int x = 0; int y = 0; public Point() { this(0, 0); } public Point(int x, int y) { this.x = x; this.y = y; } public boolean equals(Point p) { return (x == p.x) && (y == p.y); } @Override public String toString() { return "(" + x + "," + y + ")"; } }

DebugLog.class

/******************************************************************************/ /** @file DebugLog.java @brief DebugLog class @note Copyright (C) 2010 @author ThinkinGall @date 2010/08/30 @version 1.0 *******************************************************************************/ package intel.life; /** * debug output class * * @class DebugLog */ public class DebugLog { /** log printFatal */ private static Boolean suppressFatal = false; /** log printInfo */ private static Boolean suppressInfo = false; /** log result */ private static Boolean suppressResult = false; /** * Constructor * * @param none * @return none */ public DebugLog() { } /** * print info log content * * @param msg * Log contents * @return none */ public static void printResultln(Object msg) { if (suppressResult == true) { return; } System.out.println(msg); } /** * print info log content * * @param msg * Log contents * @return none */ public static void printResult(Object msg) { if (suppressResult == true) { return; } System.out.print(msg); } /** * print info log content * * @param msg * Log contents * @return none */ public static void printInfoln(Object msg) { if (suppressInfo == true) { return; } System.out.println(msg); } /** * print info log content * * @param msg * Log contents * @return none */ public static void printInfo(Object msg) { if (suppressInfo == true) { return; } System.out.print(msg); } /** * print fatal log content * * @param msg * Log contents * @return none */ public static void printFatalln(Object msg) { if (suppressFatal == true) { return; } System.out.println(msg); } /** * set debug log print state * * @param blInfo * @return none */ public static void setSuppressInfo(Boolean blInfo) { suppressInfo = blInfo; } }

如果所有路径都寻址的话，最终在寻址到12895条路径，java的new 的对象太多。heap空间不足。

解决方案路径12895--size859715: 344825015317260242205

报
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at intel.life.MazeOfLife.ruleScanCheck(MazeOfLife.java:357)
    at intel.life.MazeOfLife.doSearch(MazeOfLife.java:183)
    at intel.life.MazeOfLife.main(MazeOfLife.java:66)

内存资源不足了。

下面开始实现多线程的寻址。

期待......