在n * n网格上生成路径

Question

我有n*n网格，例如n=10。我必须用黑色和白色元素填充它。每个黑色元素都必须有一个，两个或三个黑色邻居。不允许包含具有四个或零个邻居的黑色元素。

我应该如何构建这种网格？

编辑：

更具体地说，它是二维数组，例如有两个for循环：

n = 10
array = [][];
for ( x = 0; x < n; x++ ) {
    for ( y = 0; y < n; y++ ) {
        array[x][y] = rand(black/white)
    }
}

这个伪代码构建了一些像：

我期待的是：

Answer 1

显然，您正试图在写入网格上生成“黑色路径”形状。

所以，让我们去做吧。

• 从白色网格开始。
• 随意将一些乌龟放在上面。
• 然后，当您的网格不符合正确的白/黑单元格比率时，请执行以下操作
  • 将每只乌龟沿着一个随机方向移动一个细胞并将其涂成黑色，除非这样做会打破“不超过三个黑色邻居”规则。

Answer 2

也许这个python代码可能有用。它的基本思想是对网格进行某种广度的首次遍历，确保黑化像素遵守它们不超过3个黑色邻居的约束。对应于网格的黑化部分的图形是树，因为您想要的结果似乎是。

import Queue
import Image
import numpy as np
import random

#size of the problem
size = 50

#grid initialization
grid = np.zeros((size,size),dtype=np.uint8)

#start at the center
initpos = (size/2,size/2)

#create the propagation queue
qu = Queue.Queue()

#queue the starting point
qu.put((initpos,initpos))

#the starting point is queued
grid[initpos] = 1


#get the neighbouring grid cells from a position
def get_neighbours(pos):
  n1 = (pos[0]+1,pos[1]  )
  n2 = (pos[0]  ,pos[1]+1)
  n3 = (pos[0]-1,pos[1]  )
  n4 = (pos[0]  ,pos[1]-1)
  return [neigh for neigh in [n1,n2,n3,n4] 
                  if neigh[0] > -1 and \
                     neigh[0]<size and \
                     neigh[1] > -1 and \
                     neigh[1]<size \
         ]


while(not qu.empty()):
  #pop a new element from the queue
  #pos is its position in the grid
  #parent is the position of the cell which propagated this one
  (pos,parent) = qu.get()

  #get the neighbouring cells
  neighbours = get_neighbours(pos)

  #legend for grid values
  #0 -> nothing
  #1 -> stacked
  #2 -> black
  #3 -> white

  #if any neighbouring cell is black, we could join two branches
  has_black = False
  for neigh in neighbours:
    if neigh != parent and grid[neigh] == 2:
      has_black = True
      break

  if has_black:
    #blackening this cell means joining branches, abort
    grid[pos] = 3
  else:
    #this cell does not join branches, blacken it
    grid[pos] = 2

    #select all valid neighbours for propagation
    propag_candidates = [n for n in neighbours if n != parent and grid[n] == 0]
    #shuffle to avoid deterministic patterns
    random.shuffle(propag_candidates)
    #propagate the first two neighbours
    for neigh in propag_candidates[:2]:
      #queue the neighbour
      qu.put((neigh,pos))
      #mark it as queued
      grid[neigh] = 1

#render image
np.putmask(grid,grid!=2,255)
np.putmask(grid,grid<255,0)
im = Image.fromarray(grid)
im.save('data.png')

以下是结果设置size = 50

另一个设置size = 1000

你也可以玩树的根。

Answer 3

使用您在此处显示的大小，您可以轻松地进行一些强力实施。

编写一个函数，检查您是否满足要求，只需迭代所有单元格并计算邻居。

之后，做这样的事情：

Start out with a white grid.
Then repeatedly:
    pick a random cell
    If the cell is white:
        make it black
        call the grid checking routine.
        if the grid became invalid:
            color it gray to make sure you don't try this one again

do this until you think it took long enough, or there are no more white cells.
then make all gray cells white.

如果您的网格很大（数千个像素），您应该寻找更高效的算法，但对于10x10网格，这将在瞬间计算。