diff --git a/flowers/flowers-tutorial.pdf b/flowers/flowers-tutorial.pdf
new file mode 100644
index 0000000..6c580ee
Binary files /dev/null and b/flowers/flowers-tutorial.pdf differ
diff --git a/flowers/flowers-tutorial.tex b/flowers/flowers-tutorial.tex
new file mode 100644
index 0000000..4a704d7
--- /dev/null
+++ b/flowers/flowers-tutorial.tex
@@ -0,0 +1,47 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: O problema das Flores}
+\author{}
+\date{}
+\begin{document}
+\maketitle
+O problema pode ser resolvido utilizando uma abordagem de \textbf{programação dinâmica}, onde calculamos o número de maneiras válidas de preencher o canteiro até cada posição, levando em conta a cor da última flor e o tamanho do bloco atual de flores consecutivas.
+
+A restrição principal é que não podem existir mais do que \(m\) flores consecutivas da mesma cor. Isso significa que, ao adicionar uma nova flor, precisamos garantir que a sequência resultante ainda seja válida, ou seja, o número de flores consecutivas da mesma cor não ultrapasse o limite imposto.
+
+Definimos a DP da seguinte forma:
+
+\[
+dp[i][c] = \text{número de maneiras válidas de formar um arranjo de comprimento } i \text{ cuja última flor tem cor } c
+\]
+onde \(c = 0\) representa a cor \texttt{V} (vermelha) e \(c = 1\) representa a cor \texttt{B} (branca).
+
+Para calcular \(dp[i][c]\), consideramos todos os blocos possíveis de flores consecutivas da mesma cor que terminam na posição \(i\).  
+Ou seja, podemos ter adicionado 1, 2, ..., até \(m\) flores consecutivas da cor \(c\), desde que o arranjo anterior termine com a cor oposta.
+
+A função de transição é dada por:
+
+\[
+dp[i][c] = \sum_{k=1}^{m} dp[i - k][1 - c]
+\]
+para todo \(i \ge k\), pois estamos adicionando um bloco de \(k\) flores da cor \(c\) sobre um arranjo válido de comprimento \(i - k\) que termina com a cor oposta.
+
+As condições base são:
+\[
+dp[0][0] = dp[0][1] = 1
+\]
+representando o caso vazio, que conta como uma configuração válida inicial para permitir as transições.
+
+O resultado final é a soma de todos os arranjos válidos que terminam em qualquer cor:
+\[
+\text{Resposta} = dp[n][0] + dp[n][1]
+\]
+
+Essa solução possui complexidade de tempo \(O(n \times m)\), já que para cada posição \(i\) consideramos até \(m\) comprimentos de blocos consecutivos possíveis.  
+O espaço necessário é \(O(n)\), podendo ser otimizado para \(O(m)\) se apenas os estados recentes forem mantidos.\end{document}
diff --git a/flowers/flowers.pdf b/flowers/flowers.pdf
index 42b880e..06c6e3c 100644
Binary files a/flowers/flowers.pdf and b/flowers/flowers.pdf differ
diff --git a/flowers/flowers.tex b/flowers/flowers.tex
index 8fb9223..5ce60ae 100644
--- a/flowers/flowers.tex
+++ b/flowers/flowers.tex
@@ -3,25 +3,29 @@
 \begin{document}
 \begin{ProblemaAutor}{}{O problema das Flores}{1}{256}{}
 
-O problema consiste em determinar o número total de sequências de flores vermelhas e brancas de comprimento \(n\) tais que nunca existam mais de \(m\) flores consecutivas do mesmo tipo.  
-Cada posição da sequência contém exatamente uma flor, que pode ser vermelha ou branca.  
-O objetivo é contar quantas sequências distintas satisfazem a restrição de que o comprimento de qualquer bloco consecutivo de flores da mesma cor seja no máximo \(m\).
+O Jardineiro Bino é conhecido por seus canteiros de flores meticulosamente planejados. Este ano, ele decidiu criar um canteiro linear de comprimento \(n\). Para cada uma das \(n\) posições no canteiro, Bino plantará exatamente uma flor, que pode ser ou vermelha (V) ou branca (B).
+
+Bino é um artista, e a estética é sua principal preocupação. Ele acredita que a beleza surge da variação, mas também da harmonia. Após muita deliberação, ele estabeleceu uma regra de ouro para seu jardim: \textbf{nunca devem existir mais do que \(m\) flores consecutivas da mesma cor}.
+
+Por exemplo, se \(n=5\) e \(m=2\), uma sequência como \texttt{V V B V V} é perfeitamente válida. No entanto, uma sequência como \texttt{V B B B V} é \emph{inválida}, pois contém um bloco de 3 flores brancas (\texttt{B B B}), o que excede o limite \(m=2\). Da mesma forma, \texttt{V V V V B} também é inválida por conter 4 flores vermelhas consecutivas.
+
+Bino está planejando o jardim e quer saber quantas opções de design ele realmente tem. Seu desafio é ajudar Bino a determinar o número total de arranjos distintos que ele pode criar para seu canteiro de comprimento \(n\), respeitando estritamente sua regra de monotonia (o limite de \(m\)).
 
 \Entrada
 
-A entrada contém dois inteiros separados por espaço: \(n\) e \(m\).  
-\(n\) (\(1 \leq n \leq 10^4\)) é o comprimento da sequência de flores.  
-\(m\) (\(1 \leq m \leq 1000\)) é o número máximo permitido de flores iguais consecutivas.
+A entrada contém dois inteiros separados por espaço, \(n\) e \(m\), onde \(n\) (\(1 \leq n \leq 10\,000\)) é o comprimento da sequência de flores e  \(m\) (\(1 \leq m \leq 1\,000\)) é o número máximo permitido de flores iguais consecutivas.
 
 \Saida
 
-A saída deve conter um único inteiro, que representa o número total de sequências válidas de comprimento \(n\) sobre o alfabeto {vermelha, branca} que satisfazem a restrição de máximo \(m\) flores consecutivas do mesmo tipo.
+Imprima um único número inteiro: o número total de sequências de flores válidas de comprimento \(n\) que satisfazem a restrição de Bino.
+
+Como este número pode ser extremamente grande, sua resposta deve ser calculada e impressa \textbf{módulo \(10^9 + 7\)}.
 
 \ExemploEntrada
 \begin{Exemplo}
 \texttt{1~1} & \texttt{2}\\
 \rowcolor{gray!20}\texttt{2~2} & \texttt{4}\\
-\texttt{2~3} & \texttt{4}\\
+\texttt{2~1} & \texttt{2}\\
 \end{Exemplo}
 
 
diff --git a/flowers/problem.json b/flowers/problem.json
index f2144ef..28de581 100644
--- a/flowers/problem.json
+++ b/flowers/problem.json
@@ -43,9 +43,9 @@
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": [],
+        "alternative-ac": ["alternative_ac.cpp"],
         "wrong-answer": [],
-        "time-limit": [],
+        "time-limit": ["TLE.cpp"],
         "time-limit-or-ac": [],
         "time-limit-or-memory-limit": [],
         "memory-limit": [],
diff --git a/flowers/src/TLE.cpp b/flowers/src/TLE.cpp
new file mode 100644
index 0000000..2a11ccd
--- /dev/null
+++ b/flowers/src/TLE.cpp
@@ -0,0 +1,38 @@
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+int N, M;
+
+const int MOD = 1e9 + 7;
+
+ll flowers(int last, int count = 1, int size = 1) {
+    if (size == N) return 1;
+
+    ll ans = 0;
+    /*
+        if sequences ends with X we have to cases:
+            if count(X) < M we can continue the sequence by appending another X in its end
+            we can also start and entirely new sequence starting with Y.
+    */
+
+    if (last == 0) {
+        if (count < M)
+            ans += flowers(0, count + 1, size + 1);
+        ans += flowers(1, 1, size + 1);
+    } else {
+        if (count < M)
+            ans += flowers(1, count + 1, size + 1);
+        ans += flowers(0, 1, size + 1);
+    }
+
+    return ans % MOD;
+}
+
+int main(){
+   cin >> N >> M;
+
+   cout << (flowers(0) + flowers(1)) % MOD << endl;
+
+   return 0;
+}
\ No newline at end of file
diff --git a/flowers/src/alternative_ac.cpp b/flowers/src/alternative_ac.cpp
new file mode 100644
index 0000000..362580e
--- /dev/null
+++ b/flowers/src/alternative_ac.cpp
@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+int N, M;
+
+const int MOD = 1e9 + 7;
+
+ll memo[10001][1001][2];
+
+ll flowers(int last, int count = 1, int size = 1) {
+    if (size == N) return 1;
+    /*
+        if sequences ends with X we have to cases:
+            if count(X) < M we can continue the sequence by appending another X in its end
+            we can also start and entirely new sequence starting with Y.
+    */
+   if (memo[size][count][last] == 0) {
+       if (last == 0) {
+           if (count < M)
+               memo[size][count][0] += flowers(0, count + 1, size + 1);
+           memo[size][count][0] += flowers(1, 1, size + 1);
+       } else {
+           if (count < M)
+               memo[size][count][1] += flowers(1, count + 1, size + 1);
+           memo[size][count][1] += flowers(0, 1, size + 1);     
+       }
+   }
+
+    return memo[size][count][last] %= MOD;
+}
+
+int main(){
+   cin >> N >> M;
+
+    for (int i = 0; i <= 10000; i++) {
+        for (int j = 0; j <= 1000; j++) {
+            memo[i][j][0] = memo[i][j][1] = 0;
+        }
+    }
+
+    cout << (flowers(0) + flowers(1)) % MOD << endl;
+
+   return 0;
+}
\ No newline at end of file
diff --git a/flowers/src/generator.cpp b/flowers/src/generator.cpp
index 06bc849..4680709 100644
--- a/flowers/src/generator.cpp
+++ b/flowers/src/generator.cpp
@@ -24,7 +24,7 @@ vector<string> generate_sample_tests() {
 	vector<string> tests;
     tests.push_back(output_tc(1, 1));
     tests.push_back(output_tc(2, 2));
-    tests.push_back(output_tc(2, 3));
+    tests.push_back(output_tc(2, 1));
 	return tests;
 }
 
diff --git a/flowers/statement/description.tex b/flowers/statement/description.tex
index ad98558..aac1269 100644
--- a/flowers/statement/description.tex
+++ b/flowers/statement/description.tex
@@ -1,3 +1,7 @@
-O problema consiste em determinar o número total de sequências de flores vermelhas e brancas de comprimento \(n\) tais que nunca existam mais de \(m\) flores consecutivas do mesmo tipo.  
-Cada posição da sequência contém exatamente uma flor, que pode ser vermelha ou branca.  
-O objetivo é contar quantas sequências distintas satisfazem a restrição de que o comprimento de qualquer bloco consecutivo de flores da mesma cor seja no máximo \(m\).
+O Jardineiro Bino é conhecido por seus canteiros de flores meticulosamente planejados. Este ano, ele decidiu criar um canteiro linear de comprimento \(n\). Para cada uma das \(n\) posições no canteiro, Bino plantará exatamente uma flor, que pode ser ou vermelha (V) ou branca (B).
+
+Bino é um artista, e a estética é sua principal preocupação. Ele acredita que a beleza surge da variação, mas também da harmonia. Após muita deliberação, ele estabeleceu uma regra de ouro para seu jardim: \textbf{nunca devem existir mais do que \(m\) flores consecutivas da mesma cor}.
+
+Por exemplo, se \(n=5\) e \(m=2\), uma sequência como \texttt{V V B V V} é perfeitamente válida. No entanto, uma sequência como \texttt{V B B B V} é \emph{inválida}, pois contém um bloco de 3 flores brancas (\texttt{B B B}), o que excede o limite \(m=2\). Da mesma forma, \texttt{V V V V B} também é inválida por conter 4 flores vermelhas consecutivas.
+
+Bino está planejando o jardim e quer saber quantas opções de design ele realmente tem. Seu desafio é ajudar Bino a determinar o número total de arranjos distintos que ele pode criar para seu canteiro de comprimento \(n\), respeitando estritamente sua regra de monotonia (o limite de \(m\)).
\ No newline at end of file
diff --git a/flowers/statement/input.tex b/flowers/statement/input.tex
index 36163b9..effff2a 100644
--- a/flowers/statement/input.tex
+++ b/flowers/statement/input.tex
@@ -1,3 +1 @@
-A entrada contém dois inteiros separados por espaço: \(n\) e \(m\).  
-\(n\) (\(1 \leq n \leq 10^4\)) é o comprimento da sequência de flores.  
-\(m\) (\(1 \leq m \leq 1000\)) é o número máximo permitido de flores iguais consecutivas.
+A entrada contém dois inteiros separados por espaço, \(n\) e \(m\), onde \(n\) (\(1 \leq n \leq 10\,000\)) é o comprimento da sequência de flores e  \(m\) (\(1 \leq m \leq 1\,000\)) é o número máximo permitido de flores iguais consecutivas.
\ No newline at end of file
diff --git a/flowers/statement/output.tex b/flowers/statement/output.tex
index cd1bada..da57786 100644
--- a/flowers/statement/output.tex
+++ b/flowers/statement/output.tex
@@ -1 +1,3 @@
-A saída deve conter um único inteiro, que representa o número total de sequências válidas de comprimento \(n\) sobre o alfabeto {vermelha, branca} que satisfazem a restrição de máximo \(m\) flores consecutivas do mesmo tipo.
+Imprima um único número inteiro: o número total de sequências de flores válidas de comprimento \(n\) que satisfazem a restrição de Bino.
+
+Como este número pode ser extremamente grande, sua resposta deve ser calculada e impressa \textbf{módulo \(10^9 + 7\)}.
\ No newline at end of file
diff --git a/flowers/statement/tutorial.tex b/flowers/statement/tutorial.tex
index e69de29..f1a94dd 100644
--- a/flowers/statement/tutorial.tex
+++ b/flowers/statement/tutorial.tex
@@ -0,0 +1,34 @@
+O problema pode ser resolvido utilizando uma abordagem de \textbf{programação dinâmica}, onde calculamos o número de maneiras válidas de preencher o canteiro até cada posição, levando em conta a cor da última flor e o tamanho do bloco atual de flores consecutivas.
+
+A restrição principal é que não podem existir mais do que \(m\) flores consecutivas da mesma cor. Isso significa que, ao adicionar uma nova flor, precisamos garantir que a sequência resultante ainda seja válida, ou seja, o número de flores consecutivas da mesma cor não ultrapasse o limite imposto.
+
+Definimos a DP da seguinte forma:
+
+\[
+dp[i][c] = \text{número de maneiras válidas de formar um arranjo de comprimento } i \text{ cuja última flor tem cor } c
+\]
+onde \(c = 0\) representa a cor \texttt{V} (vermelha) e \(c = 1\) representa a cor \texttt{B} (branca).
+
+Para calcular \(dp[i][c]\), consideramos todos os blocos possíveis de flores consecutivas da mesma cor que terminam na posição \(i\).  
+Ou seja, podemos ter adicionado 1, 2, ..., até \(m\) flores consecutivas da cor \(c\), desde que o arranjo anterior termine com a cor oposta.
+
+A função de transição é dada por:
+
+\[
+dp[i][c] = \sum_{k=1}^{m} dp[i - k][1 - c]
+\]
+para todo \(i \ge k\), pois estamos adicionando um bloco de \(k\) flores da cor \(c\) sobre um arranjo válido de comprimento \(i - k\) que termina com a cor oposta.
+
+As condições base são:
+\[
+dp[0][0] = dp[0][1] = 1
+\]
+representando o caso vazio, que conta como uma configuração válida inicial para permitir as transições.
+
+O resultado final é a soma de todos os arranjos válidos que terminam em qualquer cor:
+\[
+\text{Resposta} = dp[n][0] + dp[n][1]
+\]
+
+Essa solução possui complexidade de tempo \(O(n \times m)\), já que para cada posição \(i\) consideramos até \(m\) comprimentos de blocos consecutivos possíveis.  
+O espaço necessário é \(O(n)\), podendo ser otimizado para \(O(m)\) se apenas os estados recentes forem mantidos.
\ No newline at end of file