8

我有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)
    }
}

此伪代码构建如下：

当前的

我期望的是：

预期的

4

3 回答 3

5

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

所以让我们去做吧。

  • 从白色网格开始。
  • 在上面随机放置一些海龟。
  • 然后，当您的网格不符合适当的白/黑单元格比例时，请执行以下操作
    • 将每只乌龟随机移动一个单元格并将其涂成黑色，除非这样做会违反“不超过三个黑色邻居”规则。
于 2012-10-30T15:10:39.330 回答
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

网格上的黑树，宽度 50

和另一个设置size = 1000

网格上的黑树，宽度 1000

你也可以玩树的根。

于 2012-10-30T17:05:05.180 回答
1

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

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

之后，执行以下操作：

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 网格，这将在瞬间计算。

于 2012-10-30T15:32:45.460 回答