¿Cómo aprender programación dinámica?

No existe ningún atajo para aprender un algoritmo, y mucho menos aprender programación dinámica.

¡Ven conmigo para resolver preguntas sobre algoritmos de programación dinámica y aprender programación dinámica juntos!

1. Análisis de preguntas

El título de esta pregunta es muy fácil de entender: encontrar el número de la subsecuencia creciente más larga.

Cabe señalar lo mismo, es decir, las subsecuencias se pueden buscar omitiendo.

2. Principio del algoritmo

1. Visualización de estado

dp[i] representa el número de la subsecuencia creciente más larga entre todas las subsecuencias que terminan en la posición i.

De hecho, primero debemos conocer la longitud de la subsecuencia antes de poder encontrar el número.

len [i] representa la longitud de la subsecuencia creciente más larga entre todas las subsecuencias que terminan en la posición i.

count [i] representa el número de la subsecuencia creciente más larga entre todas las subsecuencias que terminan en la posición i.

2. Ecuación de transición de estado

Suponemos que el intervalo de j es 0 ~ i - 1

Si ellos mismos son una subsecuencia, entonces len[i] = count[i] = 1

Si ellos mismos suman cualquier número anterior como subsecuencia, entonces:

Recorra el intervalo 0 ~ i - 1, encuentre la situación en la que nums [j] <nums[i] y luego analice:

Cuando len[j] + 1 == len[i], count[i] += count[j] (la misma longitud)

Cuando len[ j ] + 1 < len[ i ], el conteo no se mueve (la longitud es menor que la longitud más larga actual)

Cuando len[ j ] + 1 > len[ i ], len[ i ] = len[ j ] + 1 (actualiza la longitud más larga y vuelve a contar) count[ i ] = count[ j ]

3. Inicialización

Simplemente inicialícelos todos a 1.

4. Orden de cumplimentación del formulario

De izquierda a derecha.

5. Valor de retorno

Calculado simultáneamente durante el recorrido.

3. Escritura de código

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        int n = nums.size(), maxCnt = 1, maxLen = 1;
        vector<int> len(n, 1), cnt(n, 1);
        for(int i = 1; i < n; i++) {
            for(int j = 0; j < i; j++) {
                if(nums[j] < nums[i]) {
                    if(len[j] + 1 == len[i]) cnt[i] += cnt[j];
                    else if(len[j] + 1 > len[i]) {
                        len[i] = len[j] + 1;
                        cnt[i] = cnt[j];
                    }
                }
            }
            if(maxLen == len[i]) maxCnt += cnt[i];
            else if(maxLen < len[i]) maxLen = len[i], maxCnt = cnt[i];
        }
        return maxCnt;
    }
};

Escribe al final:

Ese es el contenido de este artículo, gracias por leer.

Si crees que has ganado algo, puedes darle un me gusta al blogger .

Si hay omisiones o errores en el contenido del artículo, envíe un mensaje privado al blogger o indíquelo en el área de comentarios ~

[Aprenda programación dinámica] El número de subsecuencias crecientes más largas (28)