标题：生命游戏
康威生命游戏是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。
这个游戏在一个无限大的2D网格上进行。
初始时，每个小方格中居住着一个活着或死了的细胞。
下一时刻每个细胞的状态都由它周围八个格子的细胞状态决定。
具体来说：
- 当前细胞为存活状态时，当周围低于2个（不包含2个）存活细胞时， 该细胞变成死亡状态。（模拟生命数量稀少）
- 当前细胞为存活状态时，当周围有2个或3个存活细胞时， 该细胞保持原样。
- 当前细胞为存活状态时，当周围有3个以上的存活细胞时，该细胞变成死亡状态。（模拟生命数量过多）
- 当前细胞为死亡状态时，当周围有3个存活细胞时，该细胞变成存活状态。 （模拟繁殖）
当前代所有细胞同时被以上规则处理后, 可以得到下一代细胞图。按规则继续处理这一代的细胞图，可以得到再下一代的细胞图，周而复始。
例如假设初始是:(X代表活细胞，.代表死细胞)
…
…
.XXX.
…
下一代会变为:
…
…X…
…X…
…X…
…
康威生命游戏中会出现一些有趣的模式。例如稳定不变的模式：
…
.XX.
.XX.
…
还有会循环的模式：
… … …
.XX… .XX… .XX…
.XX… .X… .XX…
…XX. -> …X. -> …XX.
…XX. …XX. …XX.
… … …
本题中我们要讨论的是一个非常特殊的模式，被称作"Gosper glider gun"：
…
…X…
…X.X…
…XX…XX…XX.
…X…X…XX…XX.
.XX…X…X…XX…
.XX…X…X.XX…X.X…
…X…X…X…
…X…X…
…XX…
…
假设以上初始状态是第0代，请问第1000000000(十亿)代一共有多少活着的细胞？
注意：我们假定细胞机在无限的2D网格上推演，并非只有题目中画出的那点空间。
当然，对于遥远的位置，其初始状态一概为死细胞。
注意：需要提交的是一个整数，不要填写多余内容。
PS：像这种什么十亿后是什么的一看就知道不能按照他的思路做，肯定有循环，或者有一些其他的捷径，慢慢摸索，
千万不要被题目吓住，慢慢读题，细细品他
package 第三次模拟;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class Point{ //代表细胞
public int x; //行
public int y; //列
public Point(int x,int y){
this.x=x;
this.y=y;
}
@Override
public boolean equals(Object obj) {
Point newPoint=(Point)obj;
return this.x==newPoint.x && this.y==newPoint.y;
}
}
static int row=11;
static int rank=38;
static List<Integer> saveCellNum=new ArrayList<Integer>(); //存放每一代的细胞数
static List<Point> livingCell=new ArrayList<Point>(); //存放活细胞
static List<Point> nextLivingCell; //存放下一代的活细胞
static int dirX[]={-1,-1,-1,0,0,1,1,1}; //八个方向，左上、上、右上、左、右、左下、下、右下
static int dirY[]={-1,0,1,-1,1,-1,0,1};
public static void main(String args[]){
Scanner reader=new Scanner(System.in);
char tmp[][]=new char[row][rank];
for(int i=0;i<row;i++){
String str=reader.nextLine();
tmp[i]=str.toCharArray();
}
//加入活细胞
for(int i=0;i<row;i++){
for(int j=0;j<rank;j++){
if(tmp[i][j]=='X'){
livingCell.add(new Point(i,j));
}
}
}
saveCellNum.add( new Integer(livingCell.size()) ); //加入第0代活细胞数目
for(int loop=1;loop<=300;loop++){ //循环100次观察规律
nextLivingCell=new ArrayList<Point>();
for(int i=0;i<livingCell.size();i++){ //遍历当前代的所有活细胞
Point curPoint=(Point)livingCell.get(i);
int nigorCells=0; //周围八个细胞的存活数目
for(int j=0;j<8;j++){
int dx=curPoint.x+dirX[j];
int dy=curPoint.y+dirY[j];
if(livingCell.contains(new Point(dx,dy))){
nigorCells++;
}else{ //只有在活细胞旁边的死亡细胞才存在存活的可能
if(!nextLivingCell.contains(new Point(dx,dy))){ //需要注意，不同的活细胞周围可能存在同一个死亡细胞
int nigorhPoint=0;
for(int k=0;k<8;k++){ //同样判断此白细胞
int dxx=dx+dirX[k];
int dyy=dy+dirY[k];
if(livingCell.contains(new Point(dxx,dyy))){
nigorhPoint++;
}
}
if(nigorhPoint==3){ //死亡细胞复活
nextLivingCell.add(new Point(dx,dy));
}
}
}
}
if(nigorCells==2 || nigorCells==3){ //活细胞延续
nextLivingCell.add(curPoint);
}
}
//至此上一代的已经更新完毕
saveCellNum.add(new Integer(nextLivingCell.size()));
livingCell=nextLivingCell;
}
for(int i=0;i<saveCellNum.size();i++){
System.out.print(saveCellNum.get(i)+" ");
}
System.out.println();
for(int i=1;i<saveCellNum.size();i++){
System.out.print(saveCellNum.get(i)-saveCellNum.get(i-1)+" ");
}
}
}
按照这个规律出来的前300个结果
/*
* ......................................
.........................X............
.......................X.X............
.............XX......XX............XX.
............X...X....XX............XX.
.XX........X.....X...XX...............
.XX........X...X.XX....X.X............
...........X.....X.......X............
............X...X.....................
.............XX.......................
......................................
39 43 48 51 44 51 48 61 42 48 50 54 55 56 42 44 47 53 54 54 54 49 60 43 50 47 47 50 48 41 44 48 53 56 49 56 53 66 47 53 55 59 60 61 47 49 52 58 59 59 59 54 65 48 55 52 52 55 53 46 49 53 58 61 54 61 58 71 52 58 60 64 65 66 52 54 57 63 64 64 64 59 70 53 60 57 57 60 58 51 54 58 63 66 59 66 63 76 57 63 65 69 70 71 57 59 62 68 69 69 69 64 75 58 65 62 62 65 63 56 59 63 68 71 64 71 68 81 62 68 70 74 75 76 62 64 67 73 74 74 74 69 80 63 70 67 67 70 68 61 64 68 73 76 69 76 73 86 67 73 75 79 80 81 67 69 72 78 79 79 79 74 85 68 75 72 72 75 73 66 69 73 78 81 74 81 78 91 72 78 80 84 85 86 72 74 77 83 84 84 84 79 90 73 80 77 77 80 78 71 74 78 83 86 79 86 83 96 77 83 85 89 90 91 77 79 82 88 89 89 89 84 95 78 85 82 82 85 83 76 79 83 88 91 84 91 88 101 82 88 90 94 95 96 82 84 87 93 94 94 94 89 100 83 90 87 87 90 88 81 84 88 93 96 89 96 93 106 87 93 95 99 100 101 87 89 92 98 99 99 99 94 105 88 95 92 92 95 93 86
4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7 3 4 5 3 -7 7 -3 13 -19 6 2 4 1 1 -14 2 3 6 1 0 0 -5 11 -17 7 -3 0 3 -2 -7
*
* */
这里我们可以看出来，有循环，虽然出来的数量是没有循环的，但是他的递增递减是由循环的
那么o(*￣▽￣*)ブ
public class Demo8生命游戏 {
public static void main(String args[]){
int a[]={3, 4 ,5 ,3 ,-7, 7, -3 ,13 ,-19, 6, 2 ,4 ,1, 1, -14, 2 ,3 ,6, 1, 0, 0 ,-5 ,11, -17, 7 ,-3 ,0,3 ,-2, -7};
int sum=0;
for(int i=0;i<a.length;i++){
sum+=a[i];
}
System.out.println(sum);
int k=0;
k=(1000000000/30)*sum+36;
int b[]=new int[1000000000%30];
for(int i=0;i<b.length;i++){
b[i]=a[i];
k+=b[i];
}
System.out.println(k);
}
}