J'ai quelques livres et une étagère. Je voudrais mettre autant de livres sur l'étagère que possible mais j'ai une règle. Toutes les dimensions des livres (hauteur, largeur et profondeur) doivent former une séquence non croissante sur l'étagère.

Cela signifie que chaque livre doit être au moins aussi élevé que ceux qui le suivent sur lui-même. Il en va de même pour la largeur et la profondeur. Vous ne pouvez pas faire pivoter les livres pour échanger leur hauteur, largeur et profondeur.

Vous devez écrire un programme ou une fonction qui donne les dimensions de tous les livres comme sorties d'entrée ou renvoie le nombre maximal de livres que je peux mettre sur l'étagère.

Contribution

• Une liste de triplets d'entiers positifs où chaque triplet définit la hauteur, la largeur et la profondeur d'un livre.
• Il y aura au moins un triplet dans la liste d'entrée.
• Deux livres peuvent avoir les mêmes longueurs selon un nombre quelconque de dimensions.

Production

• Un seul entier positif, le nombre maximal de livres qui tiennent sur l'étagère obéissant à la règle.

Complexité temporelle

Votre algorithme doit avoir un polynôme de complexité temporelle dans le pire des cas dans le nombre de livres. Cela signifie par exemple que les complexités temporelles suivantes sont toutes valides: O (N ^ 3), O (log (N) * N ^ 2), O (N) et les suivantes ne sont pas valides: O (2 ^ N), O (N!), O (N ^ N).

Exemples

Entrée => Sortie

(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

C'est le golf de code, donc l'entrée la plus courte gagne.

Un défi de tri de livres intéressant: le tri de piles de livres .

Python 3: 436 octets

Au début, j'ai vu cela comme le problème NP-complet de trouver le chemin simple le plus long dans un graphique dirigé avec des cycles. Cependant, chaque cycle du graphique (en fait un sous-graphique complet) peut être représenté comme un seul sommet. En d'autres termes, traitez les livres identiques comme un seul livre, à placer sur l'étagère comme un tout. Nous pouvons alors construire un graphe acyclique dirigé où a-> b signifie que b pourrait suivre a sur l'étagère. Enfin, nous trouvons la hauteur maximale du ou des arbres sortants à l'aide d'une méthode récursive.

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 octets

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

Pas rapide, mais c'est polynomial.

Équivalent Python3:

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 octets

Essayez-le ici

Mon programme se trompe actuellement sur les deux derniers exemples. Quelqu'un peut-il m'aider à le réparer, s'il vous plaît? Merci.

Je trie la liste des 6 ordres de permutation possibles des 3 dimensions, puis je vois quelle est la relation d'ordonnancement continue la plus longue dans la liste, puis je trouve le maximum de ceux-ci.

De plus, je sais si on peut jouer beaucoup plus au golf, mais je ne pouvais pas savoir si je pouvais le reducefaire. Autrement dit, cette façon était la plus facile à faire dans un délai raisonnable sans que mon cerveau n'explose.

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