Edit: quebra-cabeça de recompensa no final da pergunta.

Dado um conjunto de números de um dígito, você deve determinar a altura da torre que eles podem construir.

Os dígitos vivem em um plano horizontal com um nível do solo onde podem ficar. Nenhum dígito quer ser confundido com um número de vários dígitos, portanto, eles sempre têm um espaço vazio nos dois lados.

4 2  1 9  6  8

Um dígito pode estar em cima de outro:

2
6

ou pode ser suportado por outras duas na diagonal abaixo:

 9
5 8

A parte inferior precisa suportar o peso que a parte superior suporta (se houver), mais a parte superior, que é sempre 1 . Se houver dois apoiadores, eles dividem o peso total da parte superior igualmente (50% -50%).

O peso de cada dígito é 1, independentemente do seu valor.

Se um dígito suporta dois outros, ele deve ser capaz de suportar a soma do peso correspondente. Um dígito pode suportar no máximo seu valor numérico.

Algumas torres válidos (com alturas 4, 3e 5):

            0          
7           1
5    1     1 1         9 supports a total weight of 1.5 = (1+1/2)/2 + (1+1/2)/2
2   5 4    5 5        
3  5 9 5  5 6 3        6 supports a total weight of 3 =  1.5 + 1.5 = (2*1+(2*1/2))/2 + (2*1+(2*1/2))/2

Algumas torres inválidas:

1         5           The problems with the towers are (from left to right):
1  12    2 3     8      1 can't support 1+1; no space between 1 and 2;
1  5 6  1 1 1   9       1 can't support 1.5 = (1+1/2)/2 + (1+1/2)/2; 8 isn't properly supported (digits at both bottom diagonals or exactly below the 8)    

Você deve escrever um programa ou função que forneça uma lista de dígitos como saídas de entrada ou retorne a altura da torre mais alta construível usando alguns (talvez todos) desses dígitos.

Entrada

• Uma lista de números de um dígito não negativos com pelo menos um elemento.

Saída

• Um único número inteiro positivo, a altura da torre construtiva mais alta.
• Sua solução precisa resolver qualquer exemplo de caso de teste em menos de um minuto no meu computador (apenas testarei casos encerrados. Tenho um PC abaixo da média.).

Exemplos

O formato é Input list => Output numbercom uma torre possível nas próximas linhas que não faz parte da saída.

[0]  =>  1

0

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

  0
  1
 1 1

[1, 1, 1, 1, 1, 2, 2]  =>  4

   1
   1
  1 1
 1 2 2

[0, 0, 2, 2, 2, 2, 2, 5, 5, 5, 7, 7, 9]  =>  9

0
2
2
5
5
5
7
7
9

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]  =>  9

   1
   2
   2
   3
   4
   5
  3 3
 4 4 4
5 5 5 5

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

   0
   1
   2
   3
   4
   5
  3 3
  4 5
  5 5
 3 7 3
2 7 9 2

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

 0
 1
 2
 3
 4
 5
 6
 7
4 5
6 7
8 8
9 9

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

      0
      1
      2
      3
      4
      5
      6
      7
      8
      9
     5 5
     6 6
     7 7
    4 8 4
   3 7 7 3
  2 6 8 6 2
 2 5 8 8 5 2
 3 9 9 9 9 3

Isso é código-golfe, então a entrada mais curta vence.

Recompensa

Premiarei 100 recompensas de reputação (não relacionadas à já premiada) por resolver o problema estendido abaixo em tempo polinomial (em relação ao comprimento da lista de entradas) ou provar que isso não é possível (assumindo P! = NP). Detalhes do problema estendido:

• números de entrada podem ser números inteiros não negativos e não apenas dígitos
• números de vários dígitos ocupam o mesmo lugar que números de um dígito
• números de vários dígitos podem suportar valor numérico, por exemplo, 24podem suportar24

A oferta de recompensa não tem prazo de validade. Adicionarei e recompensarei a recompensa se aparecer uma prova.

Python 2 - 326

Funciona facilmente abaixo do limite de tempo para todos os exemplos dados, embora eu tenha sacrificado alguma eficiência pelo tamanho, o que provavelmente seria perceptível devido a entradas muito maiores. Agora que penso nisso, uma vez que apenas números de um dígito são permitidos, a maior torre possível pode não ser muito grande, e me pergunto qual é o máximo.

def S(u,c=0,w=[]):
 for(s,e)in[(len(w),lambda w,i:w[i]),(len(w)+1,lambda w,i:.5*sum(([0]+w+[0])[i:i+2]))]:
    m=u[:];l=[-1]*s
    for n in u:
     for i in range(s):
        if 0>l[i]and n>=e(w,i):m.remove(n);l[i]=n;break
    if([]==l or-1in l)==0:
     for r in S(m,c+1,[1+e(w,i)for i in range(s)]):yield r
 yield c
print max(S(sorted(input())))