Ho dei libri e uno scaffale. Vorrei mettere quanti più libri sullo scaffale possibile ma ho una regola. Tutte le dimensioni dei libri (altezza, larghezza e profondità) dovrebbero formare una sequenza non crescente sullo scaffale.

Ciò significa che ogni libro deve essere alto almeno quanto quelli che lo seguono da solo. Lo stesso vale per larghezza e profondità. Non è possibile ruotare i libri per scambiarne altezza, larghezza e profondità.

Dovresti scrivere un programma o una funzione che fornisca le dimensioni di tutti i libri come output di input o restituisca il numero massimo di libri che posso mettere sullo scaffale.

Ingresso

• Un elenco di terzine di numeri interi positivi in ​​cui ogni terzina definisce l'altezza, la larghezza e la profondità di un libro.
• Ci sarà almeno una tripletta nell'elenco di input.
• Due libri possono avere le stesse lunghezze in qualsiasi numero di dimensioni.

Produzione

• Un unico numero intero positivo, il numero massimo di libri che si adattano allo scaffale obbedendo alla regola.

Complessità temporale

Il tuo algoritmo dovrebbe avere un polinomio di complessità nel caso peggiore nel numero di libri. Ciò significa che ad esempio sono valide tutte le seguenti complessità temporali: O (N ^ 3), O (log (N) * N ^ 2), O (N) e le seguenti non sono valide: O (2 ^ N), O (N!), O (N ^ N).

Esempi

Input => Output

(1, 1, 1) =>  1

(5, 2, 5), (1, 3, 5) =>  1

(5, 2, 5), (1, 2, 5) =>  2

(2, 2, 2), (2, 2, 2), (2, 2, 2), (1, 3, 6) =>  3

(1, 2, 5), (1, 3, 5), (1, 2, 8), (1, 2, 5), (7, 7, 7) =>  4

(5, 19, 3), (9, 4, 16), (15, 16, 13), (7, 4, 16), (1, 13, 14), (20, 1, 15), (9, 8, 19), (4, 11, 1) =>  3

(1, 1, 18), (1, 13, 7), (14, 1, 17), (8, 15, 16), (18, 8, 12), (8, 8, 15), (10, 1, 14), (18, 4, 6), (10, 4, 11), (17, 14, 17), (7, 10, 10), (19, 16, 17), (13, 19, 2), (16, 8, 13), (14, 6, 12), (18, 12, 3) =>  5

Questo è il codice golf, quindi vince l'ingresso più breve.

Un'interessante sfida di ordinamento dei libri correlata: ordinamento di stack di libri .

Python 3: 436 byte

All'inizio ho visto questo come il problema NP completo di trovare il percorso più lungo semplice in un grafico diretto con cicli. Tuttavia, ogni ciclo nel grafico (in realtà un sottografo completo) può essere rappresentato come un singolo vertice. In altre parole, tratta i libri identici come un libro, da posizionare sullo scaffale come un'unità. Possiamo quindi costruire un grafico aciclico diretto in cui a-> b significa che b potrebbe seguire a sullo scaffale. Infine, troviamo l'altezza massima degli alberi fuori usando un metodo ricorsivo.

import sys
b=[]
n={}
r=[]
for L in sys.stdin.readlines():z=[int(x)for x in L.split()];r+=[z];z in b or b+=[z]
def l(a,b):return a[0]<=b[0]and a[1]<=b[1]and a[2]<=b[2]
R=range(len(b))
for i in R: 
    n[i]=[]
    for j in R:i!=j and l(b[i],b[j])and n[i]+=[j]
def L(t):
    global v;best=0
    if t in v:
            return v[t]
    for s in n[t]:best=max(best,L(s)+1)
    v[t]=best+r.count(b[t])-1;return best
m=0
for i in R:v={};m=max(L(i)+1,m)
print(m)

Pyth, 40 byte

KYleolNe.eaK+e+]])olNf.A.eg@YbZeT<Kk]YSQ

Non veloce, ma è polinomiale.

Python3 equivalente:

def num_books(l):
    l = sorted(l)
    s = []
    for i, Y in enumerate(l):
        s.append(max([T for T in s[:i]
                      if all(Y[e] >= t for e, t in enumerate(T[-1]))] + [[]],
                     key=len) + [Y])
    return max(len(u) for u in s)

Python 2, 231 byte

Provalo qui

Il mio programma attualmente sbaglia gli ultimi due esempi. Qualcuno può aiutarmi a risolverlo, per favore? Grazie.

Ordino l'elenco di tutti i 6 possibili ordini di permutazione delle 3 dimensioni, quindi vedo qual è la relazione di ordinamento continuo più lunga nell'elenco, quindi trovo il massimo di quelli.

Inoltre, so se si può giocare a golf molto di più, ma non sono riuscito a capire se potrei usarlo reduceper farlo. In poche parole, in questo modo è stato il modo più semplice da realizzare in un tempo ragionevole senza che il mio cervello esplodesse.

from operator import*
from itertools import*
def f(t):
    m=1
    for l in(sorted(t,key=itemgetter(*o))for o in permutations(range(3))):
        c=1
        for k in range(len(l)-1):
            c+=all(i<=j for i,j in zip(l[k],l[k+1]))
        m=max(m,c)
    print m