Programación dinámica: división de enteros

No entraré en detalles sobre la idea de programación dinámica aquí. Si necesita comprenderla, lea este artículo Pasos de planificación dinámica

Vayamos directamente al tema y usemos ideas de programación dinámica para resolver 343. División de enteros: LeetCode .

El primer paso es determinar la matriz dp y crear una matriz que almacene el producto máximo obtenido después de dividir los números enteros.

# 确定数组的长度，每次拆分的计算结果是为上一次的最大乘积，作为占位符。
dp = [0] * (n+1)  

El segundo paso es determinar el valor inicial de la matriz dp.

Podemos saber por la pregunta que no tiene sentido dividir n == 0 o n == 1. Obviamente, cuando dividimos n == 2, podemos obtener 2 = 1 + 1, por lo que el producto máximo es 1, es decir , dp[2] = 1, y los resultados del producto calculados posteriormente también se basan en los resultados de dp[2].

dp[2] = 1

El tercer paso es determinar la ecuación de transición de estado. dp[i] = máx(dp[i], j * (ij), j * dp[i - j])  

Podemos explicarlo con un ejemplo sencillo: cuando n = 5, la matriz dp almacena el valor del producto máximo obtenido al dividir cada número entero.

Hay varias cuestiones que es necesario tener en cuenta:

1. Problema de división: Necesitamos dividir un número entero de modo que la suma de dos o más números enteros sea igual al número original y el producto de los valores divididos sea el mayor. Por lo tanto, debemos considerar dividir dos números enteros positivos y luego dividirlos o no.

1) Divida i en la suma de j e i−j, y i−j ya no se divide en múltiples enteros positivos. El producto en este momento es j * (ij)

2) Divida i en la suma de j e i−j, y continúe dividiendo i−j en múltiples enteros positivos. El producto en este momento es j * dp[ij]. En este momento, necesitamos el valor anterior en el Se llama al valor de la matriz dp.

2. j comienza a atravesar desde 1. Se puede entender que ij resta el valor transversal correspondiente de j del valor de n que debe dividirse.

 j * (i - j) es el producto de dividir dos números enteros.

3. Necesitamos comparar el máximo del producto de j * (i - j) y j * dp[ij].

Por lo tanto, la ecuación de transición de estado es: dp[i] = dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

for i in range(3, n + 1):
   for j in range(1, i - 1):
      dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))

El cuarto paso es determinar el orden transversal.

dp [i] depende del estado de dp [i - j], por lo que atravesar i debe atravesarse de adelante hacia atrás, i comienza desde 3 y cuando se enumera j, comienza desde 1. De esta manera, dp [i - j] es dp [2], que puede calcularse según el valor que inicializamos.

El quinto paso, usando n = 5 como ejemplo, se puede deducir de la tabla anterior.

visualización del código Python:

def integerBreak(n):
    dp = [0] * (n + 1)
    dp[2] = 1
    for i in range(3, n + 1):
        for j in range(1, i - 1):
            dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
    return dp[n]
print(integerBreak(5))