[Apprentissage de la programmation dynamique] Le nième numéro Taibonacci (1)

Table des matières

Comment apprendre la programmation dynamique ?

1. Analyse du sujet

2. Principe de l'algorithme

1. Représentation du statut

2. Équation de transition d'état

3. Initialisation

4. Remplir la commande

5. Valeur de retour

3. Rédaction de code

4. Optimisation de l'espace

écrire à la fin


Comment apprendre la programmation dynamique ?

Il n'y a pas de raccourci pour apprendre un algorithme, encore moins apprendre la programmation dynamique,

Brossez les questions d'algorithme de programmation dynamique avec moi et apprenez la programmation dynamique ensemble !

1. Analyse du sujet

Lien vers le sujet : 1137. Le nième nombre de Tibonacci - Leetcode

Selon les conditions données par le sujet :

Tn+3 = Tn + Tn+1 + Tn + 2, soit : Tn = Tn - 1 + Tn - 2 + Tn - 3

On peut savoir que le nième nombre de Taibonacci est en fait la somme de ses trois premiers nombres. 

2. Principe de l'algorithme

1. Représentation du statut

D'une manière générale, nous allons d'abord créer un tableau sous forme de table dp,

Remplissez ce tableau dp, et la réponse est dans une certaine position sur ce tableau,

La signification de la représentation d'état est la signification représentée par une valeur sur la table.

Sans parler de ces choses imaginaires, comment obtient-on la représentation de l'État ?

1. Selon les exigences du sujet

2. Basé sur notre expérience + les exigences du sujet

3. Dans le processus d'analyse du problème, des sous-problèmes en double sont trouvés

Cependant, ce sujet est relativement simple, et on peut directement obtenir la représentation de l'état selon les exigences du sujet :

dp[ i ] signifie : le i-ème nombre de Taibonacci.

2. Équation de transition d'état

Quelle est l'équation de transition d'état ?

En fait c'est :

dp[ i ] est égal à quelque chose.

Cette question est relativement simple, la question nous donne directement la formule de l'équation de transition d'état.

Donc dp[ i ] est égal à :

dp[ je ] = dp[ je - 1 ] + dp[ je - 2 ] + dp[ je - 3 ] 

3. Initialisation

Les fonctions d'initialisation sont :

Assurez-vous de ne pas franchir les limites lorsque vous remplissez le formulaire.

Et cette question est aussi très intime pour nous :

Il nous dit : T0 = 0, T1 = 1, T2 = 1,

Ensuite, il suffit d'initialiser : dp[ 0 ] = 0, dp[ 1 ] = 1, dp[ 2 ] = 1, c'est tout. 

4. Remplir la commande

L'ordre de remplissage du formulaire est le suivant : lors du remplissage de l'état actuel, l'état requis a déjà été calculé,

 Par conséquent, l'ordre dans lequel nous remplissons cette question est de gauche à droite.

5. Valeur de retour

En fait, la valeur de retour est de retourner la valeur requise par la question. Ce que cette question retourne est : dp[ n ]

3. Rédaction de code

Regardez d'abord l'interface du sujet :

class Solution {
public:
    int tribonacci(int n) {
        
    }
};

Écrivons le code dans l'ordre dans lequel nous venons d'apprendre le principe de l'algorithme :

class Solution {
public:
    int tribonacci(int n) {
        // 1. 创建 dp 表
        // 2. 初始化
        // 3. 填表
        // 4. 返回值

        // 处理边界问题
        if(n == 0) return 0;
        if(n == 1 || n == 2) return 1;

        vector<int> dp(n + 1);
        dp[0] = 0, dp[1] = 1, dp[2] = 1; 
        for(int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }
        return dp[n];
    }
};

Selon nos quatre étapes, nous avons traité le problème de frontière et l'avons réussi :

4. Optimisation de l'espace

Lorsque nous avons commencé à apprendre la programmation dynamique, le plus important était de savoir comment résoudre ce problème,

Au lieu de réfléchir à la façon d'optimiser, donc je ne m'attarderai pas là-dessus plus tard,

Mais maintenant, profitant de la simplicité de cette question, optimisons-la et intimidons cette question.

Généralement, l'optimisation spatiale de la programmation dynamique est optimisée par des tableaux roulants.

Lorsque nous remplissons une table dp, nous n'avons besoin d'utiliser que les premiers états, et lorsque les autres états ne sont plus nécessaires,

Nous pouvons ensuite optimiser en utilisant des tableaux roulants :

class Solution {
public:
    int tribonacci(int n) {
        //空间优化

        // 处理边界问题
        if(n == 0) return 0;
        if(n == 1 || n == 2) return 1;

        int a = 0, b = 1, c = 1, d = 0;
        for(int i = 3; i <= n; i++) {
            d = a + b + c;
            //滚动操作:
            a = b; b = c; c = d;
        }
        return d;
    }
};

 De cette manière, la consommation d'espace passe de O(N) à O(1).

Écrivez à la fin :

Ce qui précède est le contenu de cet article, merci de votre lecture.

Si vous sentez que vous avez gagné quelque chose, vous pouvez donner un like au blogueur .

S'il y a des omissions ou des erreurs dans le contenu de l'article, veuillez envoyer un message privé au blogueur ou le signaler dans la zone de commentaire ~

Je suppose que tu aimes

Origine blog.csdn.net/Locky136/article/details/131513453
conseillé
Classement