Nonogram line brute-force solving
Ruby, 85 bytes



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


Try it online!

Explanation

The first step is to establish a recursive divide and conquer strategy to solve subproblems.
I will use the variables \$l=[l_1,l_2,...,l_x]\$ for the list of clues, \$x\$ for the number of clues and \$n\$ for the number of cells.

Try to fit the last clue \$l_x\$:
We test the cell at \$n-l_x\$
(1) If it's empty: then all of the clues are before \$n-l_x\$.
So we lose a life and we call recursively \$1+f(l,n-l_x)\$
(2) If it's colored:
We are not sure how to place the last clue, so we test every cells to the right until finding an empty one
The worst case is finding the empty cell at the last index, we lose a life, but we have placed the last clue
so we can call recursively \$1+f(\tilde{l},n-l_x-2)\$ where \$\tilde{l}\$ is \$l\$ without the last clue.

So we can get the number of lives with this function
$$
f(l,n)=\begin{cases}
  0, &amp; \text{if } \sum_1^xl_i+x-1 \geq n\\
  \lceil \frac{n}{l_x} \rceil - 1 &amp; \text{if } x= 1\\
  1+\max\begin{cases}
f(l,n-l_x)\\
f(\tilde{l},n-l_x-2)
  \end{cases}, &amp; \text{otherwise}
\end{cases}
$$

Here is an example _ are unknown, X is a known space, O is a known colored cell and L is life lost

[2,2,4] 15                  _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
(1) -&gt; [2,2,4] 11           _ _ _ _ _ _ _ _ _ _ _ L X X X
    (1) -&gt; [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) -&gt; [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) -&gt; [2,2] 9              _ _ _ _ _ _ _ _ _ X O O O O L
    (1) -&gt; [2,2] 7          _ _ _ _ _ _ _ L X X O O O O L
        (1) -&gt; [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) -&gt; [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) -&gt; [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


It makes a binary tree, to get the number of lives lost, we just need to count the maximum height of the tree.
However this makes it \$\mathcal{O}(2^n)\$ because we evaluate all of the branches. We can do better.

Let's define a cost function \$h\$ that will help us "choose" the right branch at each step.

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

\$h\$ counts the number of superfuous spaces we have if we pack all the clues with one space in between.
So it is essentially an indicator of how much lives we are going to need to solve the instance, the higher it is,
the more lives are necessary. The idea is to apply this indicator on our recursive formula.

By definition of \$h\$ we have,
$$
\begin{align}
h(l,n-l_x) &amp;= n - l_x - \sum_1^xl_i-x+1\\
&amp; =(n - \sum_1^xl_i-x+1) - l_x\\
&amp; = h(l,n) - l_x
\end{align}
$$

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

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

We want to maximize \$h\$ at each step to get the worst case so let's check the difference between the two expressions in the recurrence

$$
[h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1]\\
\begin{align}
 &amp;= 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]\\
 &amp;=-2
\end{align}
$$

$$
\begin{align}
  [h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1] &amp;=-2\\
  [h(l,n-l_x)+l_x] - [h(\tilde{l},n-l_x-2)+1] &amp;&lt; 0\\
  [h(l,n-l_x)+l_x] &amp;&lt; [h(\tilde{l},n-l_x-2)+1]
\end{align}
$$
So the 2nd expression is always the max, we can remove the first one

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

Finally this recursive definition of \$h\$ shows us that option (2) in function \$f\$ is always the worst case (giving the maximum number of possibilities i.e. maximizing \$h\$)

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

Every step we decrease \$n\$ by at least 3 and there is now a single recursive call, complexity is \$\mathcal{O}(n)\$