【算法】程序猿不写代码是不对的48

package com.kingdz.algorithm.time201705;

import java.util.Random;

/**
 * 生命游戏<br>
 * 
 * <pre>
 * 规则
 * 假设平面上画许多方形网格，每个方格放置一个生命细胞，细胞有两种状态：生或死
 * 对于每个网格有8个相邻的网格
 * 孤独死亡：若相邻的网格中没有细胞存在，则在下一状态中死亡
 * 拥挤死亡：若相邻的网格中细胞数量在4个以上，则在下一状态死亡
 * 复活：若相邻网格中细胞数量为3个，则当前位置的细胞复活
 * 稳定：若相邻网格中细胞数量为2个，则当前位置保持原状
 * </pre>
 * 
 * @author kingdz
 * 
 */
public class Algo04 {

	// 初始细胞数目
	private static final int INITIAL_CELLS = 10;
	// 初始行数
	private static final int ROWS = 10;
	// 初始列数
	private static final int COLS = 10;
	// 允许演化的总次数
	private static final int TOTAL_STEP = 10000;

	public static void main(String[] args) {
		int[][] cells = new int[ROWS][COLS];
		initCells(cells);
		live(cells);
	}

	/**
	 * 初始化原始细胞
	 * 
	 * @param cells
	 */
	private static void initCells(int[][] cells) {
		Random r = new Random(System.currentTimeMillis());
		for (int i = 0; i < INITIAL_CELLS; i++) {
			int x = r.nextInt(cells.length);
			int y = r.nextInt(cells[0].length);
			cells[x][y] = 1;
		}
	}

	private static void live(int[][] board) {
		int[][] back = new int[board.length][board[0].length];

		int time = 0;
		while (true) {
			time++;
			System.out.println("第" + time + "次结果");
			output(board);
			if (time >= TOTAL_STEP) {
				break;
			}

			for (int i = 0; i < board.length; i++) {
				for (int j = 0; j < board[i].length; j++) {
					int neighbor = getNeighbor(i, j, board);
					if (neighbor == 0) {
						back[i][j] = 0;
					} else if (neighbor == 2) {
						back[i][j] = board[i][j];
					} else if (neighbor == 3) {
						back[i][j] = 1;
					} else if (neighbor >= 4) {
						back[i][j] = 0;
					}
				}
			}

			if (same(board, back)) {
				break;
			}

			copyArray(back, board);

		}
	}

	/**
	 * 复制二维数组
	 * 
	 * @param from
	 * @param to
	 */
	private static void copyArray(int[][] from, int[][] to) {
		for (int i = 0; i < to.length; i++) {
			for (int j = 0; j < to[i].length; j++) {
				to[i][j] = from[i][j];
			}
		}
	}

	/**
	 * 获得周围邻居的细胞数之和
	 * 
	 * @param i
	 * @param j
	 * @param board
	 * @return
	 */
	private static int getNeighbor(int i, int j, int[][] board) {
		int sum = 0;
		sum = sum + getXY(i - 1, j - 1, board);
		sum = sum + getXY(i - 1, j, board);
		sum = sum + getXY(i - 1, j + 1, board);

		sum = sum + getXY(i, j - 1, board);
		sum = sum + getXY(i, j + 1, board);

		sum = sum + getXY(i + 1, j - 1, board);
		sum = sum + getXY(i + 1, j, board);
		sum = sum + getXY(i + 1, j + 1, board);
		return sum;
	}

	/**
	 * 获得任意坐标的值，越界返回0
	 * 
	 * @param i
	 * @param j
	 * @param board
	 * @return
	 */
	private static int getXY(int i, int j, int[][] board) {
		if (i < 0 || j < 0) {
			return 0;
		}

		if (i >= board.length || j >= board[i].length) {
			return 0;
		}
		return board[i][j];
	}

	/**
	 * 判断两个二维数组是否相同
	 * 
	 * @param board
	 * @param back
	 * @return
	 */
	private static boolean same(int[][] board, int[][] back) {
		for (int i = 0; i < board.length; i++) {
			for (int j = 0; j < board[i].length; j++) {
				if (board[i][j] != back[i][j]) {
					return false;
				}
			}
		}
		return true;
	}

	private static void output(int[][] board) {
		for (int i = 0; i < board.length; i++) {
			for (int j = 0; j < board[i].length; j++) {
				int n = board[i][j];
				if (n == 0) {
					System.out.print(" ");
				} else {
					System.out.print("1");
				}
				// System.out.print(i + "" + j + "\t");
			}
			System.out.println();
		}
	}

}