Cortar palos iguales de palos diferentes

Tienes palos de longitudes arbitrarias, no necesariamente integrales.$n$

Al cortar algunos palos (un corte corta un palo, pero podemos cortar con la frecuencia que queramos), desea obtener palos de manera que:$k<n$

• Todos estos palos tienen la misma longitud;$k$
• Todos los palos son al menos tan largos como todos los demás palos.$k$

Tenga en cuenta que obtenemos palos después de realizar cortes en$n + C$$C$

¿Qué algoritmo usarías para que el número de cortes necesarios sea mínimo? ¿Y cuál es ese número?

Como ejemplo, tome y cualquier . Se puede usar el siguiente algoritmo:n ≥ $k=2$$n\geq 2$

• Ordene los palos por orden descendente de longitud tal que .$L_1\geq L_2 \geq \ldots \geq L_n$
• Si , corte el palo # 1 en dos piezas iguales. Ahora hay dos palos de longitud , que son al menos tan largos como los palos restantes .L 1 / 2 2 ... $L_1\geq 2 L_2$$L_1 / 2$$2 \ldots n$
• De lo contrario ( ), corte palo # 1 a dos piezas desiguales de tamaños y . Ahora hay dos palos de longitud , que es más larga que y los otros palos .L 2 L 1 - L 2 L 2 L 1 - L 2 3 … $L_1 < 2 L_2$$L_2$$L_1-L_2$$L_2$$L_1-L_2$$3 \ldots n$

En ambos casos, un solo corte es suficiente.

Traté de generalizar esto a más grande , pero parece que hay muchos casos a considerar. ¿Puedes encontrar una solución elegante?$k$

La primera observación central para resolver este problema es que la viabilidad de una longitud de corte ,$l$

,$\qquad\displaystyle \operatorname{Feasible}(l) = \biggl[\, \sum_{i=1}^n \Bigl\lfloor\frac{L_i}{l} \Bigr\rfloor \geq k \,\biggr]$

es constante a trozos, continuo a la izquierda y no aumenta en . Dado que el número de cortes necesarios se comporta de manera similar, encontrar la longitud óptima es solo$l$

$\qquad\displaystyle l^{\star} = \max \{ l \mid \operatorname{Feasible}(l) \}$

Además, como las otras respuestas han propuesto, todas las discontinuidades de salto tienen la forma . Esto nos deja con un problema discreto de búsqueda unidimensional susceptible de búsqueda binaria (después de clasificar un conjunto finito de candidatos).$L_i/j$

Tenga en cuenta además que solo tenemos que considerar los que son más cortos que el grande, ya que ese siempre es factible.$L_i$$k$

Entonces, diferentes límites en conducen a algoritmos de diferente eficiencia.$j$

• $1 \leq j \leq k$ da como resultado un espacio de búsqueda de tamaño cuadrático (en ),$k$
• L $1 \leq j \leq \lceil k/i \rceil$ en (suponiendo que se ordenan por tamaño decreciente), y$L_i$
• límites ligeramente más involucrados en uno lineal.

Con esto, podemos resolver el problema propuesto en tiempo y espacio .Θ ( n + k $\Theta(n + k \log k)$$\Theta(n + k)$

Una observación adicional es que la suma en crece en por para cada candidato "aprobado", contando los duplicados. Con esto, podemos usar la selección de rango en lugar de la búsqueda binaria y obtener un algoritmo que se ejecuta en tiempo y espacio , que es óptimo. l 1 L i / j Θ ( n $\mathrm{Feasible}$$l$$1$$L_i/j$$\Theta(n)$

Encuentre los detalles en nuestro artículo Algoritmos eficientes para la división de bastones sin envidia con cortes de Fewest (por Reitzig y Wild, 2015).

Como sugirió @randomA, procederemos en dos fases: primero encontramos el conjunto de palos que se cortarán y luego minimizamos el número de cortes.

Como en el caso especial de la pregunta, clasificamos / nombramos los palos para que . Esto lleva tiempo O ( n log n ) .$L_1 \ge L_2 \ge \dots \ge L_n$$O(n\log n)$

Como señaló @ user1990169, nunca tenemos que cortar una pieza .$i\ge k$

En la primera fase, empleamos una búsqueda binaria para encontrar el número , 1 ≤ s ≤ k , de modo que los palos 1 , ... , s puedan cortarse en al menos k piezas de tamaño L s (más algunas piezas más pequeñas), pero los palos 1 , ... , s - 1 no se pueden cortar en k piezas de tamaño L s - 1 . Esto llevará tiempo O ( k log k ) .$s$$1\le s \le k$$1, \dotsc, s$$k$$L_s$$1, \dotsc, s-1$$k$$L_{s-1}$$O(k\log k)$

Si , este valor es el tamaño óptimo y podemos omitir la fase dos.$L_{s-1} = L_s$

De lo contrario, sabemos que el tamaño óptimo satisface L s - 1 > o ≥ L s y si o > L s entonces o resulta de cortar al menos uno de los palos en piezas de igual tamaño. La fase dos determinará o :$o$$L_{s-1} > o \ge L_s$$o > L_s$$o$$o$

Para cada palo , 1 ≤ i ≤ s , determinar un conjunto de tamaños candidatos como sigue: Si el corte en trozos de tamaño L s vueltas el palo en r i piezas (incluyendo el más corto, en su caso), entonces el candidatos para este palo son todos los valores L $i$$1\le i \le s$$L_s$$r_i$ , dondej≤riyL$\frac{L_i}j$$j\le r_i$. (Consultela respuesta de @ user1990169 para saberpor qué estos son los únicos tamaños candidatos).$\frac{L_i}j<L_{s-1}$

Mantenga para cada tamaño de candidato, con qué frecuencia ocurrió. Usando un árbol de búsqueda equilibrado, esto se puede hacer en , ya que el número total de tamaños candidatos está limitado por ∑ i r i ≤ 2 k .$O(k\log k)$$\sum_i r_i \le 2k$

Ahora, el tamaño del candidato que se produjo con mayor frecuencia y conduce a un corte válido es el que nos da la solución óptima. Además, si cualquier tamaño candidato conduce a un corte válido, cualquier tamaño más pequeño también conducirá a un corte válido.

Entonces podemos emplear nuevamente la búsqueda binaria para encontrar la longitud de candidato más grande que conduzca a un corte válido en . Luego iteramos sobre el conjunto de longitudes de candidatos hasta este umbral y encontramos el que tiene la mayor multitud entre ellos en O ( k ) .$O(k\log k)$$O(k)$

En total, obtenemos un tiempo de ejecución en , u O ( k log k ) , si ignoramos (o no tenemos que hacer) la ordenación inicial.$O(n\log n)$$O(k\log k)$

Después de haber ordenado a los palos con el fin de sus longitudes descendente, a continuación, un palo será cortada solamente si todos los palos L 1 , L 2 , . . . L i - 1 han sido cortados.$L_i$$L_1, L_2, ... L_{i-1}$

Ahora, dado que , no haremos ningún corte en los palos L k en adelante, ya que siempre podemos tener k palos con una longitud L k .$k < n$$L_{k}$$k$$L_{k}$

Entonces, en lugar de , estamos tratando con solo k - 1 palos (posiblemente agregando el k -th palo como un todo), y el número máximo de cortes que se requerirán en el peor de los casos = k - 1 .$n$$k-1$$k$$= k-1$

Además, si el número óptimo de cortes es , entonces habrá al menos un juego de palos entre esos palos k - 1 que se tomarán como un todo de 1 palo original$< k-1$$k-1$ (ya sea en partes o en 1 pieza) , es decir, ninguna parte de ese palo original se dejará 'sin tomar'. Esto se debe a que, según el principio del agujero de paloma , habrá al menos 1 corte que deberá producir más de 1 palo válido.

Luego puede realizar dos bucles anidados (ambos hasta ). El bucle externo indicará el número de palo i cuyas partes deben tomarse y el bucle interno indicará el número de partes j hechas de ese palo. Para cada talla L $k$$i$$j$
verifique si puede obtener palos k factibles cortando palosL1 enadelante secuencialmente y, si puede, actualice los cortes mínimos requeridos hasta ahora si el número requerido actual es menor.$\frac{L_i}{j}$$L_1$

La complejidad total del algoritmo anterior es $O(nlog(n) + k^3)$

La idea de alto nivel sería la búsqueda binaria.

El tamaño de cada uno de los k sticks solicitados será al menos el más pequeño y, como máximo, el más grande. Debido a esto, procedemos mediante la búsqueda binaria en el tamaño del stick central, veamos qué número podemos obtener, si este k ′ es mayor que el k dado, entonces sabemos que necesitamos elegir un nuevo tamaño de candidato de referencia. Entonces nos movemos al más grande o más pequeño usando un nuevo stick de referencia. Nos detenemos cuando k ′ es menor que $k'$$k'$$k$$k'$$k$

Una vez que hayamos encontrado el palo de referencia apropiado, hay un caso de esquina donde necesitaríamos refinar aún más el tamaño. Podemos ordenar todos los palos cortados por el número de cortes en ellos y el tamaño del palo. Elija el que tenga el menor número de cortes y el menor tamaño. Reduzca el número de cortes en este palo en 1 y haga todos los subgrupos de este tamaño. Este será el nuevo tamaño de referencia, verifique si este nuevo tamaño puede conducir a una aceptable . Lo admito, no sé cómo limitar el tiempo de ejecución en este caso.$k'$

Con suerte, puedo ver algo útil de otras respuestas.