由于明天是5月4日，因此这里有一个以“星球大战”为主题的小贴士，可以让您从心理上做好应对明天来临的所有恶作剧的准备。

故事背景

在银河参议院会议期间，所有参议员都坐在n*n网格中。JarJar流感的突然爆发（持续不断，并导致被感染者像JarJar Binks一样说话）导致某些参议员受到感染。

这是一个带有6*6网格的示例，其中X感染了参议员，对应的列表是[[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[0,5]]：：

之后，感染开始逐步传播。如果两个参议员共享网格上的整个边缘（即，上，下，右，左），则它们是相邻的，这意味着我们不包括对角线。

我们可以得出结论，一个参议员可以与2,3或4个其他参议员相邻，并声明以下感染规则：

• 被感染的参议员永远保持感染
• 如果某位参议员在上一步中与2位或更多位受感染的参议员相邻，则该步骤将被感染。

这是先前网格的示例，显示了感染的两个第一步：

在接下来的步骤之后，所有参议院将被感染

你的任务

您的代码不需要处理无效输入，例如列表大于n*n或坐标不是唯一的。

您的代码将输入一对整数（或二进制网格或任何其他适合您的语言的格式）和一个整数n（如果您使用除列表以外的其他格式，则不必要）的列表，例如：

8 [[1,2],[1,1],[7,4],[2,7],[4,3]]

n是网格的侧面，这意味着该网格将是一个* n网格，而整数对列表是最初感染的参议员的细胞的坐标。

网格的左下角是[0,0]，右上角是[n-1，n-1]。左上角是[0，n-1]。

您的代码必须输出一个整数：

-1 或伪造的值或错误（如果整个网格永远不会被完全感染）或感染整个网格所需的最少步骤

测试用例

6 [[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]] => 7

4 [[1,1][0,3][1,0][3,0][3,3]] => 9

请记住，这是代码高尔夫，因此以字节为单位的最短答案为胜！

MATL，29 28字节

tn:"tlY6Z+1>Z|t?@.]]Nl=?l_]&

输入采用1和0的2D矩阵形式

在MATL Online上尝试

说明

        % Implicitly grab user input as a 2D matrix
t       % Duplicate the inputs
n:      % Count the number of elements in the input (N) and create the array [1...N]
"       % Loop this many times (maximum number of steps we analyze)
  t     % Duplicate the top element
  lY6   % Push the 2D array => [0 1 0; 1 0 1; 0 1 0]
  Z+    % Perform 2D convolution (and maintain the size)
  l>    % Find all values that are >= 2
  Z|    % Perform an element-wise OR with the previous state
  t?    % If all elements are 1's
    @.  % Push the current index and break out of the loop
  ]     % End of if 
]       % End of for loop
Nl=?    % If there is only one element on the stack
  l_    % Push a negative one
]       % End of if statement
&       % Display the top stack element

APL（Dyalog 16.0），54个字符或60个字节

以封闭矩阵为参数，返回完成感染的步数，即1 =已经被完全感染。0 =未完全散布，仅是1 + OP的数字。

54个字符（Unicode）：

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

60个字节（经典）：

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⎕U233A 3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

⌺ 相当于 ⎕U233A

示例运行：

      g←(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵ ⋄ (⊂f⊃⍵),⍵}⍣≡
      ⎕IO←0
      b←⊂⊖⍉~@(⎕JSON'[[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]]')⊢0⍴⍨2⍴6
      g b
8
      b←⊂⊖⍉~@(⎕JSON'[[1,1],[0,3],[1,0],[3,0],[3,3]]')⊢0⍴⍨2⍴4
      g b
10

步骤如下：

┌────────────┬─────────┬ ──────┬────────────┬─────────┬──────────┬ ──────────┐
│XX│XXX│XXXX│XXXXX│XXXXX│XXXXX│XXXXX│XXXXXX│
│X│XXX│XXXX│XXXXX│XXXXX│XXXXX│XXXXXX│XXXXXX│
│XX│XXX│XXXX│XXXX│XXXXX│XXXXXX│XXXXXX│XXXXXX│
││X│XXX│XXXXX│XXXXXX│XXXXXX│XXXXXX│XXXXXX│
│X│XX│XXX│XXXXX│XXXXXX│XXXXXX│XXXXXX│XXXXXX│
│XX│XXXX│XXXX│XXXX│XXXXX│XXXXXX│XXXXXX│XXXXXX│
└────────────┴─────────┴ ──────┴────────────┴─────────┴──────────┴ ──────────┘
────────┬───────┬┬────────┬──────┬ ────────┬───────┬┬────────┬──────┬ ┐
│XX│XX│XX│XX│XX│XX│XXX│XXXX│XXXX│XXXX│
││││││X│XX│XXX│XXXX│XXXX│XXXX│
│X│X│XX│XXX│XXX│XXX│XXX│XXX│XXXX│XXXX│
│XX│XXX│XXX│XXX│XXX│XXX│XXX│XXX│XXX│XXXX│
────────┴───────┴┴────────┴──────┴ ────────┴───────┴┴────────┴──────┴ ┘

Pyth，49个字节

J^UE2*lK.uS{+NeMf>hT1r8S@Jsmm+VdkNs_MB_MBU2Q)qJeK

测试套件。

对输出使用1索引。

Python，231字节

g=input()
q=lambda r,c:g[r][c]if(0<=r<m)*(0<=c<m)else 0
m=len(g);p=t=0;n=range(m)
while not all([r for k in g for r in k]):h=[[g[r][c]or sum([q(r+1,c),q(r-1,c),q(r,c+1),q(r,c-1)])>1 for c in n] for r in n];t+=1;0/(g!=h);g=h
print t

如果不可能，则会引发错误。

在线尝试！

JavaScript（ES6），132个字节

f=s=>(w=s.search`\n`,t=` `.repeat(w+1),t+=s+t,t=s.replace(/0/g,(_,i)=>1-t[i]-t[i+=w]-t[i+=2]-t[i+w]>>>31),t==s?0/!/0/.test(s):1+f(t))

其中\n代表文字换行符。在换行符分隔的数组中将输入作为0s和1s 的字符串。返回NaN网格是否永远不会被完全感染。