ejercicio de programación dinámica para cortar cuerdas

He estado trabajando en el siguiente problema de este libro .

Un cierto lenguaje de procesamiento de cadenas ofrece una operación primitiva que divide una cadena en dos partes. Como esta operación implica copiar la cadena original, se necesitan n unidades de tiempo para una cadena de longitud n, independientemente de la ubicación del corte. Supongamos, ahora, que quiere romper una cadena en muchas partes. El orden en que se realizan los descansos puede afectar el tiempo total de ejecución. Por ejemplo, si desea cortar una cadena de 20 caracteres en las posiciones $3$ y $10$ , entonces hacer el primer corte en la posición $3$ incurre en un costo total de $20 + 17 = 37$ , mientras que hacer la posición 10 primero tiene un mejor costo de $20 + 10 = 30$.

Necesito un algoritmo de programación dinámico que, dado $m$ cortes, encuentre el costo mínimo de cortar una cadena en $m +1$ piezas.

La idea básica es: Pruebe todas las posiciones de corte como primera opción, resuelva las partes respectivas de forma recursiva, agregue el costo y elija el mínimo.

En la fórmula:

$\qquad \displaystyle \operatorname{mino}(s, C) = \begin{cases} |s| &, |C| = 1 \\ |s| + \min_{c \in C} \left[ \begin{align}&\operatorname{mino}(s_{1,c}, \{c' \in C \mid c' < c\})\ \\ +\ &\operatorname{mino}(s_{c+1,|s|}, \{c' - c \in C \mid c' > c\}) \end{align}\right] &, \text{ else} \end{cases}$

Tenga en cuenta que aplicar la memorización a esta recursión realmente ahorra trabajo, ya que cambiar el orden de cualquier par de cortes aplicados sucesivamente da como resultado la resolución de los mismos tres subproblemas.

Siempre es una buena idea encontrar primero un algoritmo recursivo y luego convertirlo en una tabla.

1. $f(C,n)$
2. $~~$si (C = ) devuelve 0;$\emptyset$
3. $~~$más
4. $~~~~$opt = infinito;
5. $~~~~$para cada do$c\in C$
6. $~~~~~~D=\{d\in C:d<c\}$
7. $~~~~~~E=\{e-c:e\in D,e>c\}$
8. $~~~~~~opt = min\{opt,f(D,c)+f(E,n-c)\}$
9. $~~~~$$opt+n$

$n \choose 2$$E$$f$

Esto es muy similar a Quicksort en un conjunto múltiple; es óptimo cuando el punto de corte está más cerca del medio, y luego recurrimos.

$s_k$