Emperador risa! Un tarro de puntos que

Hacer que funcione, que sea justo, que sea rápido. - Kent Beck

Aquí las dos primeras frases dicen es recursiva, es decir después de una iteración. Tengo que admitir recursiva Dafa muy fácil de escribir, pero el método iterativo es más eficiente y rápido.

La programación dinámica, puede sonar extraño, pero en otras palabras, un recursivo llegado a la conclusión preliminar después de la escritura con forma iterativa.

Tomar la clásica secuencia de Fibonacci, por ejemplo,

    largo tiempo de Fibonacci (int n) { 

　　 si (n == 0) { 
        return 1; 
    } 
    Else if (n == 1) { 
        return 1; 
    } 
    Else { 
        retorno de Fibonacci (n - 1) + Fibonacci (n - 2); 
    } 
} // T (n) = pow (2, n - 1) = O (pow (2, n))

De acuerdo con ello queremos dejar rastro recursión:

Podemos ver en este árbol recursivo tiene una gran cantidad de ramas duplicadas, por lo que si podemos cortar duplicar la rama?

Mejora Primero: Memoria de recursiva

largo tiempo de Fibonacci (int n) { 
    mucho, mucho f [100] = {0}; 
    si (n == 0) { 
        retorno f [0] = 0; 
    } 
    Else if (n == 1) { 
        retorno f [1] = 1; 
    } 
    Else if (f [n]) { 
        retorno f [n]; 
    } 
    Else { 
        retorno f [n] = Fibonacci (n - 1) + Fibonacci (n - 2); 
    } 
} // T (n) = pow (2, n - 2) = O (pow (2, n))

A pesar de la eliminación de ramas duplicadas, pero no parece la complejidad a caer mucho

Mejora II: programación dinámica (no recursiva)

largo tiempo de Fibonacci (int n) { 
    mucho, mucho f [100]; 
    f [0] = 0; 
    f [1] = 1; 
    for (int i = 2; i <= n; i ++) { 
        f [i] = f [i - 1] + f [i - 2]; 
    } 
    Retorno f [n]; 
} // T (n) = O (n)

Este cambio de algoritmo de arriba a abajo, dos por encima de las ideas mientras se toma un camino ascendente de pensamiento, pensando que por lo general preferimos resolver el problema (iteración).

Y también debe ser fotografiado dije al comienzo de la programación dinámica es utilizar un recursivo llegado a la conclusión preliminar se convirtió en la forma de iteración.

Mencionada programación dinámica, un ejemplo clásico es:

LCS (común más larga subsecuencia) // subsecuencia común más larga

Secuencia: cadena de caracteres se extrae varias cartas dispuestas en el orden se extrae de una cadena

Más larga subsecuencia común: dos subsecuencia común más larga

por ejemplo: idac d

　 advan

　 Más larga subsecuencia común: da

Frente a este problema, nuestro pensamiento convencional es:

1. Identificar subsecuencia común

2. Y luego averiguar donde la subsecuencia común más larga

idea de la programación dinámica es:

Imagínese todas las sub-problemas en una matriz

Matriz se encuentran:

(1) si (i == 0 || j == 0) A [i] [j] = 0

(2) si (i, j> 0 && Ci == Rj) A [i] [j] = A [i - 1] [j - 1] + 1

(3) si (i, j> 0 && Ci = Rj!) Max (A [i] [j - 1], A [i - 1] [j])

#include <iostream> 
#include <cstdio> 
#include <algoritmo> 
#include <math> 
#include <string> 
using namespace std; 
int main () { 
    string str1 = "didac"; 
    str2 cadena = "Av"; 
    int A [7] [7] = {0}; 
    int más larga = 0; 
    for (int i = 0; i <= str1.length (); i ++) { 
        for (int j = 0; j <= str2.length (); j ++) { 
            si (i == 0 || j == 0 ) { 
                A [i] [j] = 0; 
            } 
            Else if (i> 0 && j> 0 && str1 [i - 1] == str2 [j - 1]) { 
                A [i] [j] = A [i - 1] [j - 1] + 1; 
            Else if (i>
            } 
        } 
    } 
    For (int i = 0; i <= str1.length (); i ++) { 
        for (int j = 0; j <= str2.length (); j ++) { 
            cout << A [i] [j ]; 
        } 
        Cout << endl; 
    } 

    Return 0; 
}

Resumen: Tanto si se trata de la vista de tabla, o desde el punto de Vista de Regla matriz, la longitud de la subsecuencia común que es el elemento más grande en la matriz, y el menor incremento en el número mínimo de primeros elementos de una secuencia común es el número de elemento de columnas y filas.

Categoría: algoritmos numéricos-Mathimatics

Buen texto a la parte superior

    largo tiempo de Fibonacci (int n) { 

　　 si (n == 0) { 
        return 1; 
    } 
    Else if (n == 1) { 
        return 1; 
    } 
    Else { 
        retorno de Fibonacci (n - 1) + Fibonacci (n - 2); 
    } 
} // T (n) = pow (2, n - 1) = O (pow (2, n))