Hoy aprendí las ideas básicas de la programación dinámica e hice tres preguntas de entrenamiento.
Pregunta 1: https://leetcode-cn.com/problems/stone-game/
Si se adopta la solución de programación dinámica, se usa una matriz de programación dinámica bidimensional y dp [i] [j] registra el número máximo de piedras que la persona seleccionó primero en la secuencia de p [i] ap [j ] puede obtener más que el oponente,
Al inicializar, para los elementos en la diagonal, dp [i] [i] significa seleccionar de la secuencia de p [i] ap [i], y termina después de la selección, entonces dp [i] [i] = p [i]
Si eliges p [i], entonces el rango opcional del oponente se convierte en p [i + 1] ap [j], por lo que el número actual de piedras obtenidas menos el número dp que el oponente puede obtener después de nosotros [ i + 1] [j], que es el resultado actual (p [i] -dp [i + 1] [j])
De manera similar, el resultado de elegir p [j] es p [j] -dp [i] [j-1], entonces dp [i] [j] = max (p [i] -dp [i + 1] [j ], p [j] -dp [i] [j-1])
parte del código:
Pregunta 2: https://leetcode-cn.com/problems/count-square-submatrices-with-all-ones/
Aprenda de la idea del tipo grande en la solución del problema.
Aquí la matriz [i] [j] registra el número de cuadrados con este punto como la esquina inferior derecha. La
ecuación de transición del estado clave:
matriz [i] [j] = min (matriz [i-1] [j-1], min (matriz [i-1] [j], matriz [i] [j-1])) + 1;
atraviesa desde la esquina superior izquierda a la inferior esquina derecha. El estado del primero ya no cambia, por lo que puede grabar directamente en la matriz original.
Tome un cuadrado de tamaño dos como ejemplo:
—Si existe, hay 1 cuadrados
de tamaño uno en la parte superior izquierda, lados superior e izquierdo. Tome un cuadrado de tamaño tres como ejemplo:
—Si existe, la esquina superior izquierda, la esquina superior izquierda, hay 1 cuadrados de tamaño dos a la izquierda,
y la programación dinámica llega a una conclusión
部分 代码 ：
int min (int a, int b) { if (a <b) return a; else { return b; } } int countSquares (int ** matriz, int tamañoMatriz, int * tamañoColMatriz) { int hang = tamañoColMatriz; int suma = 0; for (int i = 0; i <matrixSize; i ++) { for (int j = 0; j <hang; j ++) { if (matrix [i] [j]
0) continuar;
si yo0 || j == 0) sum ++; // El punto en la columna más a la izquierda o en la fila superior es un 1 1 rectángulo
else { matrix [i] [j] = min (matrix [i-1] [j- 1] , min (matriz [i-1] [j], matriz [i] [j-1])) + 1; suma + = matriz [i] [j]; } } } devuelve suma; } Pregunta 3: https: / /leetcode-cn.com/problems/reducing-dishes/ Tome el ejemplo 1satisfaction = [-1, -8,0,5, -9] como ejemplo: Después de ordenar en orden ascendente: satisfacción = [-9, -8 , -1,0,5] tendrá los siguientes valores: 5 × 1 = 5 5 × 2 + 0 × 1 = 10 5 × 3 + 0 × 2 + (- 1) × 1 = 14 5 × 4 + 0 × +. 3 (-. 1) × 2 + (-. 8) = 10 ×. 1. 5 × ×. 4. 5 + 0 + (-. 1). 3 × + (-. 8) × 2 + ( -. 9). 1 = -3 × finalmente tomado 14, el más grande. Usando programación dinámica para resolver el problema: 1. Primero, qordenar la matriz de satisfacción; 2. Si el valor máximo en la matriz de satisfacción es menor o igual a 0, devuelva 0 directamente; 3. Cree una matriz dp unidimensional y establezca it Valor inicial, dp [talla-1] = satisfacción [talla-1];
4. Utilice pow para contar la suma de tamaño-1 a i, y encuentre el valor máximo de la suma del tiempo favorito de todos los platos según dp [i] = max (dp [i + 1], dp [i + 1 ] + temp).
Parte del código:
int k (const void a, const void b) {//
Retorno rápido de fila (int ) a- (int ) b;
}
int max (int a, int b) { if (a> b ) return a; else {return b;} } int maxSatisfaction (int * satisfacción, int tamaño de satisfacción) { int pow; qsort (satisfacción, tamaño de satisfacción, tamaño de (int), k); if (satisfacción [tamaño de satisfacción-1] <= 0 ) return 0; int dp [tamaño de satisfacción]; dp [tamaño de satisfacción-1] = satisfacción [tamaño de satisfacción-1]; for (int i = tamaño de satisfacción-2; i> = 0; i -) { pow = 0; for (int j = tamaño de satisfacción-1; j> = i; j -) {
pow + = satisfacción [j];
}
dp [i] = max (dp [i + 1], dp [i + 1] + pow); / La combinación del bucle for en la capa interna superior aquí dp da cuenta del peso máximo Multiplique por el tiempo máximo y disminuya gradualmente los requisitos /
}
return dp [0]; // Regrese al valor máximo
}
Resumen: El método de resolución de problemas de programación dinámica radica en una comprensión profunda del problema. Estos problemas suelen ser pequeños eventos del mismo enfoque. Finalmente, el problema de buscar el resultado final, partiendo del resultado final, empujando hacia adelante y registrando cada paso. Comparado con el algoritmo recursivo, ahorra tiempo. En el proceso de operación, se debe prestar atención a muchos pequeños detalles, como combinar el significado de la pregunta desde el resultado final hasta Al avanzar, la oración de cambio en cada paso debe ajustarse al significado de la pregunta.