背景

Nonogram，也称为Picross或Griddlers，是一个难题，其目标是使用每行上连续的彩色单元格的数量来确定2D网格上的每个单元格是彩色还是空白。

以下是带有解决方案的示例非图拼图。

问题是，某些商业Nonogram游戏/移动应用程序具有无法用手解决的难题（例如，具有多种解决方案，或者需要深度回溯）。但是，它们也为玩家提供了一些生命，当您尝试给正确答案为空白的单元格上色时，将会失去生命。因此，现在是时候对那些令人讨厌的“难题”进行暴力破解了！

为了简化任务，想象一下只有一条线索及其线索：

3 7 | _ _ _ _ _  _ _ _ _ _  _ _ _ _ _

这些[3,7]是线索，行长为15个单元格。由于它有多种可能的解决方案，因此我们需要冒一些生命危险才能完全解决此问题（即确定所有有色单元格）。

挑战

给定一条具有线索的行（正整数列表）和行长，假设您使用最佳策略对这条行进行暴力破解，找出将要失去的最大生命数。

请注意，您总是会猜到有色单元格。在实际的游戏中，猜测空单元（对还是错）对您的生活没有影响，因此您无法以这种方式“解决”难题。

另外，您可以假设输入始终代表有效的Nonogram行，因此您无需担心诸如的问题[6], 5。

说明

首先让我们看一些简单的例子。

[1,2], 5

此行完全有三种可能性（O一个彩色单元格，.一个空单元格）：

O . O O .
O . . O O
. O . O O

如果我们尝试为单元格0（从左开始的基于0的索引）着色，则会发生以下情况之一：

• 单元格已正确着色。现在，我们有两种可能性，我们可以在单元2和单元4之间进行选择，以完全求解直线。无论哪种情况，在最坏的情况下我们都会丧生。
• 牢房是空的，我们失去了生命。在这种情况下，我们已经确定了这条线的唯一解决方案，因此我们只损失了1条生命。

因此，答案[1,2], 5是1。

[5], 10

二进制搜索？不。

最明显的第一选择是4或5，这将显示一个空白的可能性（以1个生命为代价）。假设我们先选择了4个。如果单元格4确实是彩色的，则将其向左扩展，即尝试3、2、1和0直到失去生命（或者单元格0带有颜色，那么我们最终将完全没有生命）。每当失去生命时，我们都可以唯一地确定解决方案，例如，如果我们看到这样的情况：

_ _ X O O _ _ _ _ _

那么我们已经知道答案是这样的：

. . . O O O O O . .

因此，答案[5], 10也是1。

[3,7], 15

从单元格11开始，如果为空，将立即显示以下解决方案。

O O O . O O O O O O O X . . .

然后尝试12，如果为空，则有两种可能，但要花1个额外的时间才能解决。

O O O . . O O O O O O O X . .
. O O O . O O O O O O O X . .

现在尝试2。如果为空，将导致三种可能性，可以与[1,2], 5示例类似地解决。

. . X O O O . O O O O O O O .
. . X O O O . . O O O O O O O
. . X . O O O . O O O O O O O

如果您以这种方式将风险最小化，则可以以最大 花了2个生命。

测试用例

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

[2,1,1,3,1] 15 => 3
[1,1,1,2,1] 15 => 5

对于后两种情况，最佳策略不是经过最小的空白，而是从左到右（或从右到左）。感谢@crashoz指出这一点。

规则

适用标准代码高尔夫球规则。有效提交的最短字节数为准。

赏金

如果有人提出多项式时间算法（带有正确性证明），我将奖励+100赏金给这种解决方案。

红宝石，85字节

f=->l,n,s=n-l.sum-l.size+1{*a,b=l;b&&s>0?(a[0]?1+f[a,n-b-2,s-1]:(n.to_f/b).ceil-1):0}

在线尝试！

说明

$l=[l_1,l_2,...,l_x]$$x$$n$

$l_x$
$n-l_x$
$n-l_x$$1+f(l,n-l_x)$
$1+f(\tilde{l},n-l_x-2)$$\tilde{l}$$l$

$$f(l,n)=\begin{cases} 0, & \text{if } \sum_1^xl_i+x-1 \geq n\\ \lceil \frac{n}{l_x} \rceil - 1 & \text{if } x= 1\\ 1+\max\begin{cases} f(l,n-l_x)\\ f(\tilde{l},n-l_x-2) \end{cases}, & \text{otherwise} \end{cases}$$

这是一个_未知的例子，X是一个已知的空间，O是一个已知的有色细胞，L是丧命的

[2,2,4] 15                  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
(1) -> [2,2,4] 11           _ _ _ _ _ _ _ _ _ _ _ L X X X
    (1) -> [2,2,4] 7        _ _ _ _ _ _ _ L X X X L X X X
        0                   X X X L X X X L X X X L X X X
    (2) -> [2,2] 5          _ _ _ _ _ X O O O O L L X X X
        0                   O O X O O X O O O O L L X X X 
(2) -> [2,2] 9              _ _ _ _ _ _ _ _ _ X O O O O L
    (1) -> [2,2] 7          _ _ _ _ _ _ _ L X X O O O O L
        (1) -> [2,2] 5      _ _ _ _ _ L X L X X O O O O L
            0               O O X O O L X L X X O O O O L
        (2) -> [2] 3        _ _ _ X O O L L X X O O O O L
            1               O O L X O O L L X X O O O O L               
    (2) -> [2] 5            _ _ _ _ _ X O O L X O O O O L
        2                   O O L L X X O O L X O O O O L

它生成一棵二叉树，要获取失去的生命数量，我们只需要计算树的最大高度即可。但这使它成为因为我们评估了所有分支。我们可以做得更好。$\mathcal{O}(2^n)$

让我们定义一个成本函数，它将帮助我们在每个步骤中“选择”正确的分支。$h$

$$h(l,n)=n - \sum_1^xl_i-x+1$$

$h$如果我们将所有线索打包在一起，并且它们之间有一个空格，那么就是我们拥有的多余空格的数量。因此，从本质上说，这是我们解决实例需要多少生命的指标，它越高，需要的生命就越多。想法是将此指标应用于我们的递归公式。

根据定义， $h$

$$\begin{align} h(l,n-l_x) &= n - l_x - \sum_1^xl_i-x+1\\ & =(n - \sum_1^xl_i-x+1) - l_x\\ & = h(l,n) - l_x \end{align}$$

并且，

$$\begin{align} h(\tilde{l},n-l_x-2) &= n - l_x - 2 - \sum_1^{x-1}l_i-(x-1)+1\\ & =(n - \sum_1^xl_i-x+1) - 1\\ & = h(l,n) - 1 \end{align}$$

然后，

$$h(l,n)=\begin{cases} \leq 0, & \text{if } \sum_1^xl_i+x-1 \geq n\\ n - l_x, & \text{if } x=1\\ \max\begin{cases} h(l,n-l_x)+l_x\\ h(\tilde{l},n-l_x-2)+1 \end{cases}, & \text{otherwise} \end{cases}$$

我们希望在每个步骤中最大化 以得到最坏的情况，因此让我们检查循环中两个表达式之间的差异$h$

$$[h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1]\\ \begin{align} &= n-l_x-n - \sum_1^xl_i-x+1 + l_x - [n-l_x-2 -\sum_1^{x-1}l_i-(x-1)+1+1]\\ &=-2 \end{align}$$

$$\begin{align} [h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1] &=-2\\ [h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1] &< 0\\ [h(l,n-l_x)+l_x] &< [h(\tilde{l},n-l_x-2)+1] \end{align}$$ 因此第二个表达式始终是最大值，我们可以删除第一个表达式

$$h(l,n)=\begin{cases} \leq 0, & \text{if } \sum_1^xl_i+x-1 \geq n\\ n - l_x, & \text{if } x=1\\ h(\tilde{l},n-l_x-2)+1 & \text{otherwise} \end{cases}$$

最后，递归定义向我们表明，函数中的选项（2）始终是最坏的情况（给出最大可能性，即最大化）$h$$f$$h$

$$f(l,n)=\begin{cases} 0, & \text{if } \sum_1^xl_i+x-1 \geq n\\ \lceil \frac{n}{l_x} \rceil - 1 & \text{if } x= 1\\ 1+ f(\tilde{l},n-l_x-2), & \text{otherwise} \end{cases}$$

我们每减少至少三步，现在就有一个递归调用，复杂度为$n$$\mathcal{O}(n)$

Python中，303个 289字节

长时间打高尔夫球，所以可能会有很多多余的脂肪。（感谢Jo King找到了14个字节的值。）

函数f会生成所有可能的排列方式（尽管始终以空格作为第一个字符，但是只要在调用它之前将长度加1，就可以了）。函数g选择空白和递归最少的位置。函数h将它们放在一起。

f=lambda l,n:["."*i+"X"*l[0]+c for i in range(1,n-l[0]+1)for c in f(l[1:],n-i-l[0])]if l else["."*n]
def g(q,n):O,X=min([[[p[:i]+p[i+1:]for p in q if p[i]==u]for u in".X"]for i in range(n)],key=lambda x:len(x[0]));return(len(q)>1)*1and max(1+g(O,n-1),g(X,n-1))
h=lambda l,n:g(f(l,n+1),n+1)

这些示例都运行良好：

>>> h([3,7],15)
2
>>> h([3,4],15)
3
>>> h([1,1,1,2,1],15)
6