3-in-a-row逻辑谜题：对列表/数组中的序列约束进行优化

Question

在下面的谜题中，我们尝试用以下方式填充网格：蓝色和白色方块：

• 不允许使用相同颜色的3-in-row（或列）。
• 每行和每列都有相同数量的蓝色和白色方块。

如果我们现在用0表示白色，用1表示蓝色，我们得到：

0 _ _ _ 1 _
_ 0 _ _ _ _
_ _ _ _ _ 0
1 _ _ 0 _ _
_ _ 1 1 _ _
_ 0 _ _ 1 _

我们可以很快验证

0 1 0 0 1 1 
0 0 1 1 0 1 
1 1 0 1 0 0 
1 1 0 0 1 0 
0 0 1 1 0 1 
1 0 1 0 1 0 

是此示例的解决方案。

作为约束，我写了以下内容：

constraints(Board,N) :-
    N2 is N // 2,
    ( for(I,1,N), param(Board,N2,N)
    do
      Row is Board[I,1..N],
      Col is Board[1..N,I],
      ic_global:sequence_total(N2,N2,1,2,3,Row),
      ic_global:sequence_total(N2,N2,1,2,3,Col)
    ).

sequence_total/6确保值1应该在行/列中完全出现N2次（N次的一半），并且3个元素的指定行/列中的每个序列应该包含1到2次值为1（因此没有3个方格，值为1可以相互出现）。

我得到了18x18拼图实例（*）的以下结果：

Solved in 147 backtracks
Yes (10.39s cpu, solution 1)

看起来限制在执行任何搜索之前都能很好地完成工作，因为只有＆＃39;需要147次回溯。然而，运行时间对我来说似乎很长，特别是与回溯的数量相比。我猜这是因为必须进行所有序列检查？改变search/6中任何选择/选择方法对运行时间几乎没有影响的事实似乎证实了这一点。

如果是这样，是否还有其他更有效的方法来限制列表/数组中的序列，使N个相同的元素彼此相邻并缩短运行时间？

修改

使用以下@jschimpf提供的分解版本后，获得以下结果：

Solved in 310 backtracks
Yes (0.22s cpu, solution 1)

新约束不如sequence / 6强，我们确实需要更多回溯，但我们的运行时间从10.39secs下降到0.22secs，因此整体结果非常理想。

示例数据：

用于此问题的拼图（无需回溯解决）

  

问题（P（6,1），[（1,1,0），（1,5,1），（2,2,0），（3,6,0），（4,1， 1），（4,4,0），（5,3,1），（5,4,1），（6,2,0），（6,5,1）]）。

我发布结果的拼图（*）：

  

问题（P（18,1），[（1,3,0），（1,9,0），（1,10,0），（1,12,0），（1,14， 0），（1,18,1），（2,4,0），（2,7,1），（2,8,1），（3,2,1），（3,6,0） ，（3,16,0），（3,17,0），（4,2,1），（4,4,1），（4,10,1），（4,13,1），（ 4,18,1），（5,8,1），（5,10,1），（5,15,0），（5,16,1），（6,12,1），（7， 3,0），（7,4,0），（7,6,1），（7,9,0），（7,12,1），（7,17,0），（8,1， 1），（8,4,0），（8,8,1），（8,15,1），（8,16,1），（9,7,0），（9,10,0） ，（9,14,0），（10,2,1），（10,4,1），（10,6,1），（10,13,1），（11,7,0），（ 11,10,1），（12,1,1），（12,4,1），（12,7,1），（12,15,1），（12,16,1），（13， 1,1），（13,6,0），（13,8,1），（13,10,0），（13,16,1），（14,5,1），（14,10， 0），（14,13,1），（15,1,1），（15,3,1），（15,12,0），（15,13,​​1），（15,15,0） ，（16,2,1），（16,4,0），（16,12,0），（16,18,0），（17,9,0），（17,15,0），（ 17,18,0），（18,2,1），（18,8,1），（18,11,1），（18,15,1），（18,16,1）]）。< / p>

Answer 1

事实证明，在这种情况下，序列约束的手工制作，分解版本效率更高。例如使用

sequence_1_2([X1,X2,X3|Xs]) :- !,
    S #:: 1..2,
    X1+X2+X3 #= S,
    sequence_1_2([X2,X3|Xs]).
sequence_1_2(_).

将任何3元素子序列的总和约束为1或2，并用

替换sequence_total / 6约束

    ...,
    sum(Row) #= N2,
    sequence_1_2(Row),

这使得解决时间缩短到0.2秒。