Jeter les chats de windows

Selon un récent épisode de Radiolab (à propos de "la Chute"), un chat atteint la vitesse terminale au 9ème étage. Après cela, il se détend et est moins susceptible d'être blessé. Il y a complètement indemne chats après une chute à partir de ci-dessus le 30. Les plus risqués que les planchers sont en 5e au 9e.

J'ai d'abord lu ce problème dans de Steven Skiena de la Conception d'un Algorithme Manuel (exercice 8.15). Il a suivi un chapitre sur la programmation dynamique, mais vous n'avez pas besoin de connaître la programmation dynamique pour prouver précise les limites de la stratégie de. D'abord l'énoncé du problème, alors la solution ci-dessous.

Oeufs casser en cas de chute d'assez grande hauteur. Étant donné un n-la construction de l'histoire, il doit y avoir un étage de f tels que les œufs ont chuté de plancher f briser, mais des oeufs a chuté de plancher f-1 survivre. (Si l'œuf pauses à partir de tout type de sol, nous allons dire f = 1. Si l'ovule survit à partir de n'importe quel étage, on va dire f = n+1).

Vous cherchez à trouver la critique de plancher f. La seule opération que vous pouvez effectuer est de déposer un oeuf au loin certains étage et voir ce qui se passe. Vous commencez avec un k œufs, et de chercher à éliminer les oeufs que peu de fois que possible. Oeufs cassés ne peuvent pas être réutilisés (intact œufs). Supposons que E(k,n) le nombre minimum d'oeuf excréments qui sera toujours suffire.

1. Montrer que E(1,n) = n.
2. Montrent que E(k,n) = Θ(n**(1/k)).
3. Trouver une récurrence de E(k,n). Qu'est-ce que le temps d'exécution du programme dynamique pour trouver E(k,n)?

---

Seulement 1 œuf

Déposer l'oeuf de chaque étage de départ lors de la première trouverez la critique étage (au-pire) n opérations.

Il n'y a pas d'algorithme plus rapide. À tout moment, dans n'importe quel algorithme, soit g l'étage le plus élevé à partir de laquelle l'œuf a été vu pour ne pas casser. L'algorithme doit tester étage g+1 avant tout l'étage supérieur h > g+1, sinon si l'oeuf à la pause de sol h, il ne pouvait pas distinguer entre f=g+1 et f=h.

2 oeufs

D'abord, considérons le k=2 œufs cas, lorsque n = r**2 est un carré parfait. Voici une stratégie qui prend O(sqrt(n)) de temps. Commencez par déposer le premier œuf en incréments de r étages. Lorsque le premier œuf de pauses, à dire, à l'étage ar, nous savons que la critique de plancher f doit être (a-1)r < f <= ar. Nous avons ensuite déposer le deuxième oeuf de chaque étage de départ à (a-1)r. Lorsque le deuxième oeuf se brise, nous avons trouvé la critique de l'étage. Nous avons baissé de chaque œuf à la plupart de la recherche, alors cet algorithme prend au-pire 2r opérations, qui est Θ(sqrt(n)).

Lorsque n n'est pas un carré parfait, prendre r = ceil(sqrt(n)) ∈ Θ(sqrt(n)). L'algorithme reste Θ(sqrt(n)).

La preuve que l'algorithme prend au moins sqrt(n) fois. Supposons qu'il existe un algorithme plus rapide. Tenir compte de la séquence de sols à partir de laquelle il tombe le premier œuf (à condition qu'il ne se casse pas). Depuis, il tombe moins de sqrt(n), il doit y avoir un intervalle d'au moins n/sqrt(n) qui est sqrt(n). Lorsque f est, dans cet intervalle, l'algorithme doit enquêter avec le deuxième oeuf, et qui doit être fait étage par étage rappelant l'1-oeuf. La CONTRADICTION.

k œufs

L'algorithme présenté pour 2 œufs peuvent être facilement étendu à k œufs. Déposer chaque oeuf avec des intervalles constants, ce qui devrait être pris que les pouvoirs de la k-ième racine de n. Par exemple, pour n=1000 et k=3, la recherche des intervalles de 100 étages avec le premier œuf, 10 avec le deuxième oeuf et 1 avec le dernier oeuf.

De la même façon, nous pouvons prouver qu'aucun algorithme est plus rapide Θ(n**(1/k)) en récupérant à partir de k=2 preuve.

Solution exacte

Nous en déduisons que la récidive par l'optimisation de l'endroit où déposer le premier œuf (plancher g), en supposant que nous savons des solutions optimales pour les plus petits paramètres. Si l'oeuf se brise, nous avons le g-1 étages ci-dessous pour explorer avec k-1 oeufs. Si l'ovule survit, on a n-g étages au-dessus d'explorer avec k œufs. Le diable choisit le pire pour nous. Ainsi, pour k>1 la récurrence

E(k,n) = min(max(E(k,n-g), E(k-1,g))) minimised over g in 1..n

J'ai pris une méthode légèrement différente pour produire une solution.

J'ai commencé à travailler sur le plancher maximale qui pourrait être couverts à l'aide x chats et y suppositions à l'aide de la méthode suivante.

Commencer avec 1 étage et de continuer à augmenter le nombre de suppositions tout en gardant la trace d'étages vérifié, ce qui suppose qu'ils ont été contrôlés et la façon dont beaucoup de chats ont été restant pour chaque étage.

Répétez cette opération jusqu'à y fois.

Ce très inefficace code pour calculer la réponse qui est donnée, mais néanmoins utile pour le petit nombre de chats /étages.

Code Python:

def next_step(x, guess):
  next_x = []
  for y in x:
    if y[0] == guess:
      if y[1] != 1:
        next_x.append((guess+1, y[1] - 1))
    next_x.append(y)
    if y[0] == guess:
      next_x.append((guess+1, y[1]))
  return next_x

x = [(1, TOTAL_NUM_CATS)]
current_floor = 1
while len(x) <= TOTAL_NUM_FLOORS:
  x = next_step(x, current_floor)
  current_floor += 1
  print len(x)

Pour 2 chats le maximum d'étages qui peuvent être identifiés dans x devine est:

1, 3, 6, 10, 15, 21, 28...

Pour 3 chats:

1, 3, 7, 14, 25, 41, 63...

Pour 4 chats:

1, 3, 7, 15, 30, 56, 98...

Après de longues recherches (essentiellement en tapant les numéros de séquences en OEIS), j'ai remarqué que le maximum d'étages pour x suit un combinaison par morceaux motif.

Pour 2 chats:

n < 2 : 2^n - 1

n >= 2 : C(n, 1) + C(n, 2)

Pour 3 chats:

n < 3 : 2^n - 1

n >= 3 : C(n, 1) + C(n, 2) + C(n, 3)

Pour 4 chats:

n < 4 : 2^n - 1

n >= 4 : C(n, 1) + C(n, 2) + C(n, 3) + C(n, 4)

De là, j'ai pris la simple approche d'une simple incrémentation de n jusqu'à ce que je passe le nombre d'étages.

Code Python:

def find_smallest(floors, eggs):
  maximum_floors = 0
  n = 0
  while maximum_floors < floors:
    maximum_floors = 0
    n += 1
    if n < eggs:
      maximum_floors = 2**n - 1
    else:
      count = 0
      for x in xrange(1, eggs+1):
        maximum_floors += combination(n, x)
  print n

Cela donne la bonne solution pour (100, 2) = 14.

Pour quelqu'un qui veut vérifier quelque chose de moins banal, il donne (1 000 000, 5) = 43.

Cela s'exécute en O(n) où n est la réponse au problème (les chats de plus le mieux).

Cependant, je suis sûr que quelqu'un avec un niveau élevé de mathématiques pourrait simplifier la par morceaux formules permettant de calculer en O(1).

Je ne peut pas lire le google blogspot sur ce (grâce à des travaux blogwall) mais je ne pense pas droite binaire de recherche de style serait le mieux. La raison étant que le binaire de recherche est basé autour de l'idée que la réponse que vous recherchez a une chance égale d'être à tout indice dans la liste. Toutefois, dans ce cas la ce n'est pas vrai. Dans ce cas, la réponse aura une probabilité plus élevée d'être plus proche d'une extrémité de la gamme que l'autre. Je n'ai aucune idée de comment en tenir compte dans la recherche, mais c'est une question intéressante.