feat: new problem formatted

README.md

@@ -50,9 +50,13 @@ Repositório com a formatação de problemas que exploram variadas técnicas de
 ## Graph 
 
 - [Conversor Fonético Genérico](./conversor-fonetico-generico)
+- [Gatinhos](./gatinhos)
 - [Knight Moves](./knight-moves)
 - [Sliding Puzzle](./sliding-puzzle)
+- [Pique Pega](./pique-pega/)
 - [Lazy Jumping Frog](./ra-preguicosa/)
+- [Rede Anel Estelar](./rede-anel-estelar/)
+- [SMS](./sms)
 
 ---
 

analise-de-dados/analise-de-dados-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: Análise de Dados}
-\author{Leetcode 1223}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

analise-de-dados/analise-de-dados.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{Análise de Dados}{1}{256}{Leetcode 1223}
+\begin{ProblemaAutor}{}{Análise de Dados}{1}{256}{Arthur Andrade D'Olival}
 
 É o seu primeiro dia no \textbf{Departamento de Controle de Qualidade}.
 
@@ -33,6 +33,10 @@ Em seguida, são dados seis inteiros \(d_1, d_2, d_3, d_4, d_5, d_6\), cada um r
 
 A saída consiste em um único inteiro representando o número total de sequências válidas de lançamentos, considerando o resultado módulo \(10^9 + 7\).
 
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/dice-roll-simulation/}{Leetcode 1223}.
+
 \ExemploEntrada
 \begin{Exemplo}
 \texttt{2} & \texttt{34}\\

analise-de-dados/arthur-dolival-analise-de-dados-tutorial.tex

@@ -0,0 +1,45 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: Análise de Dados}
+\author{Arthur Andrade D'Olival}
+\date{}
+\begin{document}
+\maketitle
+O problema pode ser resolvido por meio de uma abordagem de \textbf{programação dinâmica}, onde calculamos o número de sequências válidas de lançamentos de dados até cada posição, levando em consideração qual foi a última face sorteada e quantas vezes ela apareceu consecutivamente.
+
+A principal restrição é que cada face \( i \) (\(1 \le i \le 6\)) só pode aparecer no máximo \( d_i \) vezes seguidas. Assim, ao adicionar um novo lançamento à sequência, precisamos garantir que essa condição nunca seja violada.
+
+Definimos a seguinte estrutura de DP:
+
+\[
+dp[i][j] = \text{número de sequências válidas de comprimento } i \text{ cuja última face lançada é } j
+\]
+
+Para lidar com o número de repetições consecutivas, expandimos a ideia considerando blocos consecutivos de uma mesma face.  
+Para cada face \( k \), podemos adicioná-la de \(1\) até \(d_k\) vezes, desde que a sequência anterior termine com uma face diferente de \(k\).
+
+Assim, a função de transição é dada por:
+\[
+dp[i][k] = \sum_{j \ne k} \sum_{x = 1}^{\min(d_k, i)} dp[i - x][j]
+\]
+onde o termo \(dp[i - x][j]\) representa o número de sequências de comprimento \(i - x\) que terminam com uma face diferente de \(k\), às quais adicionamos \(x\) ocorrências consecutivas da face \(k\).
+
+As condições iniciais são:
+\[
+dp[0][j] = 1, \quad \forall j \in \{1, 2, 3, 4, 5, 6\}
+\]
+representando a sequência vazia inicial, que serve como base para as transições.
+
+A resposta final será a soma de todas as formas possíveis de terminar a sequência de comprimento \(n\):
+\[
+\sum_{j=1}^{6} dp[n][j] \bmod (10^9 + 7)
+\]
+
+A complexidade temporal dessa solução é \(O(n \times 6 \times \text{max}(d_i))\), pois para cada posição e cada face consideramos até \(d_i\) possíveis comprimentos de repetições.\end{document}

analise-de-dados/arthur-dolival-analise-de-dados.tex

@@ -0,0 +1,58 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Análise de Dados}{1}{256}{Arthur Andrade D'Olival}
+
+É o seu primeiro dia no \textbf{Departamento de Controle de Qualidade}.
+
+Você esperava analisar planilhas, gráficos e talvez alguns modelos estatísticos... mas o laboratório te surpreende.
+
+Logo ao entrar, seu gerente te conduz até uma máquina barulhenta, repleta de cabos coloridos e um enorme botão vermelho no topo.
+
+--- “Aqui nós fazemos \textbf{análise de dados}.”,  ele diz, com um sorriso confiante.
+
+Você concorda, achando que entendeu, até perceber que a máquina está literalmente lançando um dado de seis faces a cada segundo.
+
+Sim, você vai analisar \textbf{dados de verdade}.
+
+Mas há um problema: os dados do laboratório sofrem de \textit{fadiga de repetição}.  
+Se uma mesma face aparecer muitas vezes seguidas, o mecanismo emperra e a máquina trava, o que, segundo o manual, “não é recomendável”.
+
+Cada face $i$ ($1 \le i \le 6$) possui um limite $d_i$: o número máximo de vezes que ela pode aparecer consecutivamente antes de causar uma falha.
+
+Sua tarefa é determinar quantas sequências de lançamentos de comprimento $n$ podem ser geradas sem que a máquina quebre.
+
+Como o número de sequências válidas pode ser gigantesco, o gerente exige que o resultado seja dado módulo $10^9 + 7$.
+
+\Entrada
+
+A entrada contém um inteiro \(n\) que representa o número de lançamentos do dado, onde \(1 \leq n \leq 5000\).  
+Em seguida, são dados seis inteiros \(d_1, d_2, d_3, d_4, d_5, d_6\), cada um representando o número máximo de vezes consecutivas que a face correspondente pode aparecer, com \(1 \leq d_i \leq 15\).
+
+\Saida
+
+A saída consiste em um único inteiro representando o número total de sequências válidas de lançamentos, considerando o resultado módulo \(10^9 + 7\).
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/dice-roll-simulation/}{Leetcode 1223}.
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{2} & \texttt{34}\\
+\texttt{1~1~2~2~2~3} & \\
+\rowcolor{gray!20}\texttt{2} & \texttt{30}\\
+\rowcolor{gray!20}\texttt{1~1~1~1~1~1} & \\
+\end{Exemplo}
+
+
+
+\Notas
+
+No primeiro caso de teste, \(n = 2\) e os valores \(d\) são \((1, 1, 2, 2, 2, 3)\).  
+As faces \(1\) e \(2\) não podem aparecer repetidas consecutivamente, enquanto as demais possuem limites mais altos, resultando em \(34\) sequências válidas.  
+Como há \(2\) lançamentos de dado e \(6\) faces, sem restrições haveria \(6 \times 6 = 36\) combinações possíveis.  
+Entretanto, as sequências \((1, 1)\) e \((2, 2)\) são inválidas devido às restrições de \(d_1 = 1\) e \(d_2 = 1\).  
+Logo, o total de combinações válidas é \(36 - 2 = 34\). \end{ProblemaAutor}
+\end{document}

analise-de-dados/problem.json

@@ -22,7 +22,7 @@
         }
     },
     "author": {
-        "name": "Leetcode 1223",
+        "name": "Arthur Andrade D'Olival",
         "affiliation": "",
         "country": "",
         "email": ""
@@ -43,7 +43,7 @@
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": [],
+        "alternative-ac": ["test.py"],
         "wrong-answer": [],
         "time-limit": [],
         "time-limit-or-ac": [],
@@ -61,4 +61,4 @@
         "maximum_memory_mb": 512,
         "maximum_output_size_kb": 24096
     }
-}
+}

analise-de-dados/src/test.py

@@ -0,0 +1,58 @@
+import sys
+MOD = 1000000007
+n = 0
+d = []
+
+
+def read_input():
+    global n
+    global d
+    n = int(input())
+    d = list(map(int, input().split()))
+
+
+def compute(dp, i, j, k):
+    global d
+    if dp[i][j][k] != -1:
+        return dp[i][j][k]
+
+    if i == 1:
+        return 1 if k == 1 else 0
+
+    dp[i][j][k] = 0
+
+    if k>1:
+        dp[i][j][k] = compute(dp, i-1, j, k-1) % MOD
+        dp[i][j][k] %= MOD
+
+    else:
+        for x in range(6):
+            if x == j:
+                continue
+            for l in range(1, d[x]+1):
+                dp[i][j][k] += compute(dp, i-1, x, l)
+                dp[i][j][k] %= MOD
+
+
+    return dp[i][j][k]
+
+
+def solve():
+    global n
+    global d
+    dp = [[[-1 for _ in range(d[j]+1)] for j in range(6)] for _ in range(n+1)]
+    ans = 0
+    for j in range(6):
+        for k in range(1,min(d[j]+1,n+1)):
+            ans = (ans + compute(dp, n, j, k)) % MOD
+
+    print(ans)
+
+def main():
+    sys.setrecursionlimit(10000)   
+    read_input()
+    solve()
+
+
+if __name__ == "__main__":
+    main()

analise-de-dados/statement/output.tex

@@ -1 +1,5 @@
 A saída consiste em um único inteiro representando o número total de sequências válidas de lançamentos, considerando o resultado módulo \(10^9 + 7\).
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/dice-roll-simulation/}{Leetcode 1223}.

caching-offline/arthur-dolival-caching-offline-tutorial.tex

@@ -7,7 +7,6 @@
 \usepackage{hyperref}
 \usepackage{graphicx}
 \input{statement/preamble.tex}
-
 \title{ Tutorial: Caching Offline}
 \author{}
 \date{}

decode-ways/arthur-dolival-decode-ways-tutorial.tex

@@ -0,0 +1,73 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: Decodificando Mensagens}
+\author{Arthur Andrade D'Olival}
+\date{}
+\begin{document}
+\maketitle
+O problema pode ser resolvido utilizando uma abordagem de \textbf{programação dinâmica}, na qual calculamos, passo a passo, o número de formas possíveis de decodificar a sequência até cada posição.
+
+\subsection*{Modelagem}
+
+Cada dígito (ou par de dígitos consecutivos) da sequência pode representar uma letra do alfabeto latino, seguindo a regra:
+\[
+1 \rightarrow A, \quad 2 \rightarrow B, \quad \ldots, \quad 26 \rightarrow Z
+\]
+Portanto, precisamos contar todas as maneiras válidas de interpretar a sequência numérica, considerando que apenas combinações entre $1$ e $26$ são válidas.
+
+\subsection*{Definição da DP}
+
+Definimos uma estrutura de DP com dois estados para cada posição $i$:
+\begin{itemize}
+    \item $dp[i][0]$: número de mensagens possíveis terminando no caractere $i$ \textbf{quando o dígito atual não é concatenado} com o anterior;
+    \item $dp[i][1]$: número de mensagens possíveis terminando no caractere $i$ \textbf{quando o dígito atual é concatenado} com o anterior.
+\end{itemize}
+
+\subsection*{Função de Transição}
+
+A função de transição é definida da seguinte forma:
+\[
+dp[i][0] =
+\begin{cases}
+dp[i - 1][0] + dp[i - 1][1], & \text{se } 1 \leq s[i] \leq 9 \\[6pt]
+0, & \text{caso contrário}
+\end{cases}
+\]
+
+\[
+dp[i][1] =
+\begin{cases}
+dp[i - 2][0] + dp[i - 2][1], & \text{se } 10 \leq 10 \cdot s[i-1] + s[i] \leq 26 \\[6pt]
+0, & \text{caso contrário}
+\end{cases}
+\]
+
+\subsection*{Casos Base}
+
+Os casos base são:
+\[
+dp[0][0] = 1, \quad dp[0][1] = 0, \quad dp[1][0] = 1, \quad dp[1][1] = 0
+\]
+Isso ocorre porque, antes de processar qualquer caractere, há exatamente uma maneira “vazia” de formar uma mensagem válida, e o primeiro dígito pode, no máximo, representar uma única letra isolada.
+
+\subsection*{Resposta Final}
+
+O total de formas possíveis de decodificar a sequência é dado por:
+\[
+dp[n][0] + dp[n][1]
+\]
+onde $n$ é o comprimento da sequência de entrada.
+
+\subsection*{Complexidade}
+
+\begin{itemize}
+    \item \textbf{Tempo:} $O(n)$, pois cada caractere é processado uma única vez;
+    \item \textbf{Espaço:} $O(n)$, podendo ser otimizado para $O(1)$ ao armazenar apenas os últimos dois estados.
+\end{itemize}\end{document}

decode-ways/arthur-dolival-decode-ways.tex

@@ -0,0 +1,45 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Decodificando Mensagens}{1}{256}{Arthur Andrade D'Olival}
+
+O problema consiste em determinar o número de maneiras possíveis de decodificar uma sequência numérica, onde cada número ou par de números representa uma letra do alfabeto latino. 
+A correspondência segue a regra \( 1 \rightarrow A, 2 \rightarrow B, \ldots, 26 \rightarrow Z \). 
+Cada dígito ou combinação de dois dígitos consecutivos pode ser convertido em uma letra válida, desde que a sequência resultante obedeça às restrições de decodificação. 
+O objetivo é calcular o total de maneiras diferentes de decodificar a sequência numérica fornecida.
+
+\Entrada
+
+A entrada é composta por duas linhas. 
+A primeira linha contém um inteiro \( n \) (\( 1 \leq n \leq 100 \)), representando o tamanho da sequência numérica. 
+A segunda linha contém uma sequência de digitos de \( s \) de comprimento \( n \).
+
+\Saida
+
+A saída deve conter um único inteiro, representando o número total de maneiras possíveis de decodificar a sequência numérica \( s \) de acordo com o mapeamento \( 1 \rightarrow A, 2 \rightarrow B, \ldots, 26 \rightarrow Z \).
+
+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{2} & \texttt{2}\\
+\texttt{12} & \\
+\rowcolor{gray!20}\texttt{3} & \texttt{3}\\
+\rowcolor{gray!20}\texttt{226} & \\
+\texttt{2} & \texttt{0}\\
+\texttt{06} & \\
+\end{Exemplo}
+
+
+
+\Notas
+
+Para a sequência \( s = "12" \), existem duas decodificações possíveis: "AB" (1, 2) e "L" (12). 
+Para a sequência \( s = "226" \), há três decodificações possíveis: "BZ" (2, 26), "VF" (22, 6) e "BBF" (2, 2, 6). 
+Para a sequência \( s = "06" \), não há nenhuma forma válida de decodificação.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/decode-ways/}{Leetcode 91}.\end{ProblemaAutor}
+\end{document}

decode-ways/decode-ways-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: Decodificando Mensagens}
-\author{Leetcode 91}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

decode-ways/decode-ways.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{Decodificando Mensagens}{1}{256}{Leetcode 91}
+\begin{ProblemaAutor}{}{Decodificando Mensagens}{1}{256}{Arthur Andrade D'Olival}
 
 O problema consiste em determinar o número de maneiras possíveis de decodificar uma sequência numérica, onde cada número ou par de números representa uma letra do alfabeto latino. 
 A correspondência segue a regra \( 1 \rightarrow A, 2 \rightarrow B, \ldots, 26 \rightarrow Z \). 
@@ -18,6 +18,8 @@ A segunda linha contém uma sequência de digitos de \( s \) de comprimento \( n
 
 A saída deve conter um único inteiro, representando o número total de maneiras possíveis de decodificar a sequência numérica \( s \) de acordo com o mapeamento \( 1 \rightarrow A, 2 \rightarrow B, \ldots, 26 \rightarrow Z \).
 
+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{2} & \texttt{2}\\
@@ -34,5 +36,9 @@ A saída deve conter um único inteiro, representando o número total de maneira
 
 Para a sequência \( s = "12" \), existem duas decodificações possíveis: "AB" (1, 2) e "L" (12). 
 Para a sequência \( s = "226" \), há três decodificações possíveis: "BZ" (2, 26), "VF" (22, 6) e "BBF" (2, 2, 6). 
-Para a sequência \( s = "06" \), não há nenhuma forma válida de decodificação.\end{ProblemaAutor}
+Para a sequência \( s = "06" \), não há nenhuma forma válida de decodificação.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/decode-ways/}{Leetcode 91}.\end{ProblemaAutor}
 \end{document}

decode-ways/output/109

@@ -1 +1 @@
-1298777728820984005
+782204094

decode-ways/output/6

@@ -1 +1 @@
-1836311903
+836311896

decode-ways/problem.json

@@ -22,7 +22,7 @@
         }
     },
     "author": {
-        "name": "Leetcode 91",
+        "name": "Arthur Andrade D'Olival",
         "affiliation": "",
         "country": "",
         "email": ""
@@ -43,7 +43,7 @@
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": ["alternative_ac.cpp"],
+        "alternative-ac": ["alternative_ac.cpp", "alternative-ac2.py"],
         "wrong-answer": [],
         "time-limit": ["TLE.cpp"],
         "time-limit-or-ac": [],

decode-ways/src/TLE.cpp

@@ -3,7 +3,9 @@
 typedef long long ll;
 using namespace std;
 
-int ways(string &s, int n, int idx = 0)
+const int MOD = 1e9 + 7;
+
+ll ways(string &s, int n, int idx = 0)
 {
     if (idx > n)
         return 1;
@@ -14,11 +16,13 @@ int ways(string &s, int n, int idx = 0)
     if (idx + 1 < n)
     {
         int num = stoi(s.substr(idx, 2));
-        if (num >= 10 && num <= 26)
+        if (num >= 10 && num <= 26){
             count += ways(s, n, idx + 2);
+            count %= MOD;
+        }
     }
 
-    return count;
+    return count % MOD;
 }
 
 vector<bool> used;

decode-ways/src/ac.cpp

@@ -3,6 +3,8 @@
 typedef long long ll;
 using namespace std;
 
+const int MOD = 1e9 + 7;
+
 ll numDecodings(string s)
 {
    if (s[0] == '0')
@@ -36,15 +38,17 @@ ll numDecodings(string s)
       if (current != '0')
       {
          dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
+         dp[i][0] %= MOD;
       }
 
       int code = stoi(aux);
       if (10 <= code && code <= 26)
       {
          dp[i][1] = dp[i - 2][0] + dp[i - 2][1];
+         dp[i][1] %= MOD;
       }
    }
-   return dp[N][0] + dp[N][1];
+   return (dp[N][0] + dp[N][1]) % MOD;
 }
 
 int main()

decode-ways/src/alternative-ac2.py

@@ -0,0 +1,16 @@
+n = int(input())
+s = input().strip()
+
+dp = [0] * (n + 1)
+dp[0] = 1
+
+for i in range(1, n + 1):
+    if s[i - 1] != '0':
+        dp[i] += dp[i - 1]
+    
+    if i > 1:
+        two_digit = int(s[i - 2:i])
+        if 10 <= two_digit <= 26:
+            dp[i] += dp[i - 2]
+
+print(dp[n] % 1000000007)

decode-ways/src/alternative_ac.cpp

@@ -3,6 +3,8 @@
 typedef long long ll;
 using namespace std;
 
+const int MOD = 1e9 + 7;
+
 ll numDecodings(string s)
 {
     if (s[0] == '0')
@@ -20,12 +22,14 @@ ll numDecodings(string s)
         if (current != '0')
         {
             next = dp2;
+            next %= MOD;
         }
 
         int code = stoi(aux);
         if (10 <= code && code <= 26)
         {
             next += dp1;
+            next %= MOD;
         }
         swap(dp1, dp2);
         swap(dp2, next);

decode-ways/statement/notes.tex

@@ -1,3 +1,7 @@
 Para a sequência \( s = "12" \), existem duas decodificações possíveis: "AB" (1, 2) e "L" (12). 
 Para a sequência \( s = "226" \), há três decodificações possíveis: "BZ" (2, 26), "VF" (22, 6) e "BBF" (2, 2, 6). 
-Para a sequência \( s = "06" \), não há nenhuma forma válida de decodificação.
+Para a sequência \( s = "06" \), não há nenhuma forma válida de decodificação.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/decode-ways/}{Leetcode 91}.

decode-ways/statement/output.tex

@@ -1 +1,3 @@
 A saída deve conter um único inteiro, representando o número total de maneiras possíveis de decodificar a sequência numérica \( s \) de acordo com o mapeamento \( 1 \rightarrow A, 2 \rightarrow B, \ldots, 26 \rightarrow Z \).
+
+Como este número pode ser extremamente grande, sua resposta deve ser calculada e impressa \textbf{módulo \(10^9 + 7\)}.

delete-and-earn/arthur-dolival-delete-and-earn-tutorial.tex

@@ -0,0 +1,65 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: Deletar e Ganhar}
+\author{Arthur Andrade D'Olival}
+\date{}
+\begin{document}
+\maketitle
+O problema pode ser resolvido utilizando uma abordagem clássica de \textbf{programação dinâmica}.  
+A ideia central é que, ao escolher um número \( x \), ganhamos uma certa quantidade de pontos, mas perdemos a possibilidade de escolher os números \( x - 1 \) e \( x + 1 \), já que eles devem ser removidos da sequência.
+
+\subsection*{Modelagem}
+
+Primeiro, agrupamos os números iguais da sequência e calculamos o total de pontos que seria obtido caso escolhêssemos todos os elementos de valor \( i \):
+\[
+\text{points}[i] = (\text{quantidade de vezes que } i \text{ aparece}) \times i
+\]
+Assim, o problema passa a ser equivalente a escolher quais valores \( i \) maximizarão a soma total de pontos, respeitando a restrição de que, ao escolher \( i \), não podemos escolher \( i-1 \) nem \( i+1 \).
+
+\subsection*{Definição da DP}
+
+Definimos:
+\[
+dp[i] = \text{pontuação máxima possível utilizando apenas os números de } 1 \text{ até } i
+\]
+
+\subsection*{Função de Transição}
+
+A cada passo, temos duas escolhas:
+\begin{itemize}
+    \item \textbf{Não escolher} o número \( i \): nesse caso, o resultado é o mesmo que \( dp[i - 1] \);
+    \item \textbf{Escolher} o número \( i \): ganhamos \( \text{points}[i] \), mas não podemos utilizar \( i - 1 \), então somamos com \( dp[i - 2] \).
+\end{itemize}
+
+A função de transição é, portanto:
+\[
+dp[i] = \max(dp[i - 1], \, dp[i - 2] + \text{points}[i])
+\]
+
+\subsection*{Casos Base}
+
+\[
+dp[0] = 0, \quad dp[1] = \text{points}[1]
+\]
+
+\subsection*{Resposta Final}
+
+A pontuação máxima possível é:
+\[
+dp[m]
+\]
+onde \( m \) é o maior valor presente na sequência original.
+
+\subsection*{Complexidade}
+
+\begin{itemize}
+    \item \textbf{Tempo:} \( O(m) \), onde \( m \) é o valor máximo na sequência;
+    \item \textbf{Espaço:} \( O(m) \), podendo ser otimizado para \( O(1) \) se armazenarmos apenas os dois últimos estados da DP.
+\end{itemize}\end{document}

delete-and-earn/arthur-dolival-delete-and-earn.tex

@@ -0,0 +1,45 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Deletar e Ganhar}{1}{256}{Arthur Andrade D'Olival}
+
+O problema consiste em determinar a pontuação máxima que pode ser obtida ao realizar uma série de operações sobre uma sequência de números inteiros. 
+Em cada operação, é possível escolher um número \( x \) da sequência, somar \( x \) pontos ao total e, em seguida, remover \textbf{todos} os elementos iguais a \( x - 1 \) e \( x + 1 \) da sequência. 
+O processo pode ser repetido até que não existam mais números disponíveis. 
+O objetivo é maximizar a pontuação total obtida ao final das operações.
+
+\Entrada
+
+A entrada é composta por duas linhas. 
+A primeira linha contém um inteiro \( n \) (\( 1 \leq n \leq 20000 \)), representando o número de elementos da sequência. 
+A segunda linha contém \( n \) inteiros \( a_1, a_2, \ldots, a_n \) (\( 1 \leq a_i \leq 10000 \)), separados por espaços, correspondentes aos valores da sequência.
+
+\Saida
+
+A saída deve conter um único inteiro, representando a pontuação máxima possível obtida após realizar as operações descritas.
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{3} & \texttt{8}\\
+\texttt{3~4~5} & \\
+\rowcolor{gray!20}\texttt{6} & \texttt{9}\\
+\rowcolor{gray!20}\texttt{2~2~3~3~3~4} & \\
+\texttt{5} & \texttt{9}\\
+\texttt{1~2~3~4~5} & \\
+\end{Exemplo}
+
+
+
+\Notas
+
+Para o primeiro caso de teste:  \( (3, 4, 5) \), a melhor escolha é remover \( 3 \), o que concede 3 pontos e remove o número \( 4 \). Em seguida, remove-se o número \( 5 \), totalizando \( 3 + 5 = 8 \) pontos. 
+
+Para o segundo caso de teste:  \( (2, 2, 3, 3, 3, 4) \), a melhor estratégia é escolher o número \( 3 \), que concede \( 3 \times 3 = 9 \) pontos, removendo todos os \( 2 \) e \( 4 \); o total máximo é \( 9 \). 
+
+Para o terceiro caso de teste:  \( (1, 2, 3, 4, 5) \), a estratégia ótima é escolher \( 1 \), \( 3 \) e \( 5 \), obtendo \( 1 + 3 + 5 = 9 \) pontos no total.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/delete-and-earn/description/}{Leetcode 740}.\end{ProblemaAutor}
+\end{document}

delete-and-earn/delete-and-earn-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: Deletar e Ganhar}
-\author{Leetcode 740}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

delete-and-earn/delete-and-earn.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{Deletar e Ganhar}{1}{256}{Leetcode 740}
+\begin{ProblemaAutor}{}{Deletar e Ganhar}{1}{256}{Arthur Andrade D'Olival}
 
 O problema consiste em determinar a pontuação máxima que pode ser obtida ao realizar uma série de operações sobre uma sequência de números inteiros. 
 Em cada operação, é possível escolher um número \( x \) da sequência, somar \( x \) pontos ao total e, em seguida, remover \textbf{todos} os elementos iguais a \( x - 1 \) e \( x + 1 \) da sequência. 
@@ -37,5 +37,8 @@ Para o primeiro caso de teste:  \( (3, 4, 5) \), a melhor escolha é remover \(
 Para o segundo caso de teste:  \( (2, 2, 3, 3, 3, 4) \), a melhor estratégia é escolher o número \( 3 \), que concede \( 3 \times 3 = 9 \) pontos, removendo todos os \( 2 \) e \( 4 \); o total máximo é \( 9 \). 
 
 Para o terceiro caso de teste:  \( (1, 2, 3, 4, 5) \), a estratégia ótima é escolher \( 1 \), \( 3 \) e \( 5 \), obtendo \( 1 + 3 + 5 = 9 \) pontos no total.
-\end{ProblemaAutor}
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/delete-and-earn/description/}{Leetcode 740}.\end{ProblemaAutor}
 \end{document}

delete-and-earn/problem.json

@@ -22,7 +22,7 @@
         }
     },
     "author": {
-        "name": "Leetcode 740",
+        "name": "Arthur Andrade D'Olival",
         "affiliation": "",
         "country": "",
         "email": ""
@@ -36,14 +36,14 @@
         "run_specific_solution": "",
         "generate_io_only": false,
         "generate_pdf_only": false,
-        "cpu_count": 1,
+        "cpu_count": 0,
         "build_pdf": true,
         "pdf_format": "ds",
         "io_samples": 3
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": [],
+        "alternative-ac": ["saad.py"],
         "wrong-answer": ["WA.cpp"],
         "time-limit": ["TLE.cpp"],
         "time-limit-or-ac": [],

delete-and-earn/src/saad.py

@@ -0,0 +1,36 @@
+
+class Solver:
+
+    def __init__(self):
+        self.n_ = 0
+        self.v_ = []
+        self.freq_ = []
+
+    def read_input(self) -> None:
+        self.n_ = int(input())
+        self.v_ = list(map(int, input().split()))
+
+    def process_freq(self) -> None:
+        self.freq_ = [0] * (max(self.v_) + 1)
+
+        for i in self.v_:
+            self.freq_[i] += 1
+
+    def solve(self):
+        self.process_freq()
+        dp = [0] * (max(self.v_)+1)
+        dp[1] = self.freq_[1]
+        for i in range(2, len(dp)):
+            dp[i] = max(dp[i-1], dp[i-2] + i * self.freq_[i])
+        
+        print(dp[-1])
+
+
+def main():
+    solver = Solver()
+    solver.read_input()
+    solver.solve()
+
+
+if __name__ == "__main__":
+    main()

delete-and-earn/statement/notes.tex

@@ -3,3 +3,7 @@ Para o primeiro caso de teste:  \( (3, 4, 5) \), a melhor escolha é remover \(
 Para o segundo caso de teste:  \( (2, 2, 3, 3, 3, 4) \), a melhor estratégia é escolher o número \( 3 \), que concede \( 3 \times 3 = 9 \) pontos, removendo todos os \( 2 \) e \( 4 \); o total máximo é \( 9 \). 
 
 Para o terceiro caso de teste:  \( (1, 2, 3, 4, 5) \), a estratégia ótima é escolher \( 1 \), \( 3 \) e \( 5 \), obtendo \( 1 + 3 + 5 = 9 \) pontos no total.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/delete-and-earn/description/}{Leetcode 740}.

edit-distance/arthur-dolival-edit-distance-tutorial.tex

@@ -0,0 +1,52 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: Distância de Edição}
+\author{Arthur Andrade D'Olival}
+\date{}
+\begin{document}
+\maketitle
+\section{Solução do Problema}
+
+O problema de encontrar o menor número de operações para transformar uma string em outra, classicamente conhecido como Distância de Edição (\textit{Edit Distance}), pode ser resolvido de forma eficiente por meio de \textbf{programação dinâmica}.
+
+\subsection{Definição do Subproblema}
+
+Sejam $w_1$ e $w_2$ as duas strings de tamanhos $N$ e $M$, respectivamente.
+Definimos o nosso estado da programação dinâmica como:
+
+$$dp[i][j] = \text{número mínimo de operações para transformar o sufixo } w_1[i \dots N-1] \text{ no sufixo } w_2[j \dots M-1].$$
+
+Assim, $dp[0][0]$ representará a resposta final para as duas strings inteiras.
+
+\subsection{Função de Transição}
+
+Para determinar $dp[i][j]$, olhamos para os caracteres atuais $w_1[i]$ e $w_2[j]$ e tomamos uma decisão. 
+
+Se os caracteres forem iguais ($w_1[i] == w_2[j]$), não precisamos realizar nenhuma operação. Apenas avançamos na análise de ambas as strings:
+
+$$dp[i][j] = dp[i+1][j+1]$$
+
+Se os caracteres forem diferentes ($w_1[i] \neq w_2[j]$), temos três opções de edição. Avaliamos o resultado de aplicar cada uma delas e escolhemos a que produz o menor custo final. Cada operação tem um custo de $1$:
+
+$$dp[i][j] = 1 + \min \begin{cases} 
+      dp[i+1][j] & \text{(Remoção do caractere } w_1[i]\text{)} \\
+      dp[i+1][j+1] & \text{(Substituição de } w_1[i] \text{ por } w_2[j]\text{)} \\
+      dp[i][j+1] & \text{(Inserção do caractere } w_2[j] \text{ em } w_1\text{)} 
+   \end{cases}$$
+
+\subsection{Casos Base}
+
+Os casos base ocorrem quando esgotamos os caracteres de uma das strings (ou seja, quando $i$ ou $j$ ultrapassam os limites):
+
+Se consumirmos toda a string $w_1$ ($i \ge N$), mas ainda restarem caracteres em $w_2$, a única forma de igualá-las é \textbf{inserir} todos os $M - j$ caracteres restantes:
+$$dp[N][j] = M - j$$
+
+Da mesma forma, se consumirmos toda a string $w_2$ ($j \ge M$), mas ainda restarem caracteres em $w_1$, a única forma de igualá-las é \textbf{remover} todos os $N - i$ caracteres que sobraram:
+$$dp[i][M] = N - i$$\end{document}

edit-distance/arthur-dolival-edit-distance.tex

@@ -0,0 +1,43 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Distância de Edição}{1}{256}{Arthur Andrade D'Olival}
+
+O problema consiste em determinar o \textbf{menor número de operações} necessárias para transformar uma string em outra.
+
+As operações permitidas são as seguintes:
+
+\begin{itemize}
+    \item \textbf{Inserção}: inserir um caractere em qualquer posição;
+    \item \textbf{Remoção}: remover um caractere de qualquer posição;
+    \item \textbf{Substituição}: substituir um caractere por outro.
+\end{itemize}
+
+O objetivo é calcular o menor custo possível para converter completamente uma dada string inicial em uma string final, utilizando apenas essas operações.
+
+\Entrada
+
+A entrada consiste de duas linhas:
+
+\begin{itemize}
+    \item A primeira linha contém dois inteiros \( n \) e \( m \) (\( 1 \leq n, m \leq 500 \)), representando os tamanhos das strings.
+    \item A segunda linha contém duas strings \( s_1 \) e \( s_2 \), ambas compostas apenas por letras minúsculas e com tamanhos exatos \( n \) e \( m \), respectivamente.
+\end{itemize}
+
+\Saida
+
+Imprima um único inteiro representando o \textbf{menor número de operações} necessárias para transformar \( s_1 \) em \( s_2 \).
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{7~7} & \texttt{3}\\
+\texttt{estouro~calouro} & \\
+\rowcolor{gray!20}\texttt{11~8} & \texttt{7}\\
+\rowcolor{gray!20}\texttt{aniquilacao~intencao} & \\
+\end{Exemplo}
+
+
+
+\end{ProblemaAutor}
+\end{document}

edit-distance/edit-distance-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: Distância de Edição}
-\author{}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

edit-distance/edit-distance.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{Distância de Edição}{1}{256}{}
+\begin{ProblemaAutor}{}{Distância de Edição}{1}{256}{Arthur Andrade D'Olival}
 
 O problema consiste em determinar o \textbf{menor número de operações} necessárias para transformar uma string em outra.
 

edit-distance/problem.json

@@ -22,7 +22,7 @@
         }
     },
     "author": {
-        "name": "",
+        "name": "Arthur Andrade D'Olival",
         "affiliation": "",
         "country": "",
         "email": ""
@@ -43,7 +43,7 @@
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": [],
+        "alternative-ac": ["saad.py"],
         "wrong-answer": [],
         "time-limit": ["TLE.cpp"],
         "time-limit-or-ac": [],

edit-distance/src/saad.py

@@ -0,0 +1,35 @@
+class Solver:
+    def __init__(self) -> None:
+        self.s1 = ""
+        self.s2 = ""
+        self.n = 0
+        self.m = 0
+
+    def read_input(self) -> None:
+        (self.n,self.m) = map(int, input().split())
+        (self.s1,self.s2) = input().split()
+
+    def solve(self) -> None:
+        dp: list[list[int]] = [[0] * (self.m + 1) for _ in range(self.n + 1)]
+        for i in range(self.n + 1):
+            dp[i][0] = i
+        for j in range(self.m + 1):
+            dp[0][j] = j
+        for i in range(1, self.n + 1):
+            for j in range(1, self.m + 1):
+                if self.s1[i - 1] == self.s2[j - 1]:
+                    dp[i][j] = dp[i - 1][j - 1]
+                else:
+                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i]
+                                   [j - 1] + 1, dp[i - 1][j - 1] + 1)
+        print(dp[self.n][self.m])
+
+
+def main():
+    solver = Solver()
+    solver.read_input()
+    solver.solve()
+
+
+if __name__ == "__main__":
+    main()

estouro/arthur-dolival-estouro-tutorial.tex

@@ -0,0 +1,53 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: Estouro}
+\author{Arthur Andrade D'Olival}
+\date{}
+\begin{document}
+\maketitle
+\section{Solução do Problema}
+
+O problema de maximizar a energia ao estourar balões pode ser resolvido de forma eficiente por meio de \textbf{programação dinâmica em intervalos}. A grande sacada para modelar este problema é pensar no processo de trás para frente: em vez de tentar adivinhar qual balão estourar primeiro, o que muda constantemente os vizinhos dos balões restantes, escolhemos qual será o \textbf{último balão} a ser estourado em um determinado subintervalo. 
+
+Para lidar com as bordas da fileira sem precisar de múltiplos \texttt{if}s, adicionamos balões virtuais com valor $1$ nas extremidades.
+
+\subsection{Definição do Subproblema}
+
+Seja a nossa fileira de balões original de tamanho $N$. Criamos um novo vetor $B$ de tamanho $N+2$, onde $B[0] = 1$, $B[N+1] = 1$, e as posições de $1$ a $N$ recebem os valores fornecidos.
+	
+Definimos o nosso estado da programação dinâmica como:
+
+$$dp[i][j] = \text{a quantidade máxima de energia obtida ao estourar todos os balões no intervalo } [i, j].$$
+
+Assim, $dp[1][N]$ representará a nossa resposta ótima, correspondente ao intervalo que engloba todos os balões reais.
+
+\subsection{Função de Transição}
+
+Para calcular $dp[i][j]$, vamos iterar por um pivô $k$ (com $i \le k \le j$) que representa o \textbf{último balão} a ser estourado dentro desse subintervalo. 
+	
+Como $k$ é o último a sobreviver entre $i$ e $j$, todos os outros balões internos já foram estourados. Consequentemente, no exato momento da explosão de $k$, seus vizinhos diretos garantidamente serão $B[i-1]$ e $B[j+1]$. A energia liberada por esse estopim final será $B[i-1] \times B[k] \times B[j+1]$.
+	
+O valor total do intervalo será a soma da energia desse balão $k$ com as energias máximas dos subproblemas que o antecederam na ordem cronológica de explosão: o intervalo à esquerda ($i$ até $k-1$) e o intervalo à direita ($k+1$ até $j$). Portanto:
+
+$$dp[i][j] = \max_{i \le k \le j} \big( dp[i][k-1] + B[i-1] \cdot B[k] \cdot B[j+1] + dp[k+1][j] \big)$$
+
+\subsection{Casos Base}
+
+Os casos base da nossa recursão (ou inicialização da matriz) ocorrem para intervalos vazios, ou seja, quando o índice de início ultrapassa o índice de fim ($i > j$). Nesses casos, como não há balões para estourar, a energia liberada é naturalmante nula:
+
+$$dp[i][j] = 0 \quad \text{para todo } i > j$$
+
+Como a implementação iterativa inicializa a matriz completa com zeros, essa condição já é suprida por padrão.
+
+\subsection{Recuperação da Decomposição (Ordem das explosões)}
+
+Para além da energia máxima $dp[1][N]$, frequentemente queremos também a sequência de explosões que atinge esse valor. Para isso, mantemos uma matriz auxiliar \texttt{cut[i][j]} durante a computação, que armazena o índice $k$ responsável pelo maior ganho em $dp[i][j]$. 
+
+Após preencher $dp$ e \texttt{cut}, criamos uma função recursiva para reconstruir a resposta. Ao chamarmos a função para o intervalo $[1, N]$, descobrimos o pivô $k = \texttt{cut}[1][N]$. Sabemos que $k$ é o \textit{último} balão estourado. Em seguida, chamamos recursivamente para os subintervalos $[1, k-1]$ e $[k+1, N]$. Ao empilharmos esses balões, obtemos a sequência cronológica invertida; basta inverter a lista no final para obtermos a sequência exata das explosões.\end{document}

estouro/arthur-dolival-estouro.tex

@@ -0,0 +1,54 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Estouro}{1}{256}{Arthur Andrade D'Olival}
+
+No laboratório de experimentos caóticos da \textbf{Fábrica de Balões Numéricos}, um cientista excêntrico te entrega uma fileira de balões, cada um pintado com um número inteiro positivo.
+
+A regra do experimento é simples, ou pelo menos parece: você deve estourar todos os balões.  
+Porém, o nível de energia liberado em cada explosão depende dos balões que ainda restam ao redor.
+
+Ao estourar o balão $i$, o experimento libera uma quantidade de energia igual a  
+\texttt{valor\_do\_balão[i-1] * valor\_do\_balão[i] * valor\_do\_balão[i+1]}.  
+Se algum dos vizinhos ($i-1$ ou $i+1$) não existir, imagine que há um balão virtual com o número $1$ nas extremidades.
+
+Cada explosão altera completamente o arranjo restante, tornando o resultado imprevisível, a ordem em que você estoura os balões é crucial.
+
+Sua missão é descobrir a \textbf{máxima quantidade total de energia} que pode ser liberada, escolhendo com sabedoria a sequência das explosões.
+
+\Entrada
+
+A primeira linha contém um inteiro $n$ ($1 \leq n \leq 300$), o número de balões.
+
+A segunda linha contém $n$ inteiros $b_1, b_2, \ldots, b_n$ ($0 \leq b_i \leq 100$),  
+onde $b_i$ representa o número pintado no $i$-ésimo balão.
+
+\Saida
+
+Imprima um único inteiro, a \textbf{quantidade máxima total de energia} que pode ser liberada  
+ao estourar todos os balões na melhor ordem possível.
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{4} & \texttt{167}\\
+\texttt{3~1~5~8} & \\
+\rowcolor{gray!20}\texttt{2} & \texttt{10}\\
+\rowcolor{gray!20}\texttt{1~5} & \\
+\end{Exemplo}
+
+
+
+\Notas
+
+No primeiro exemplo, ao estourar os balões na ordem ótima, a sequência de energias liberadas é:
+$3 \times 1 \times 5 + 3 \times 5 \times 8 + 1 \times 3 \times 8 + 1 \times 8 \times 1 = 167$.
+Portanto, o total máximo de energia é $167$.
+
+No segundo exemplo, independentemente da ordem escolhida, a energia total liberada é
+$1 \times 1 \times 5 + 1 \times 5 \times 1 = 10$.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/burst-balloons/description/}{Leetcode 312}.\end{ProblemaAutor}
+\end{document}

estouro/estouro-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: Estouro}
-\author{Leetcode 312}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

estouro/estouro.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{Estouro}{1}{256}{Leetcode 312}
+\begin{ProblemaAutor}{}{Estouro}{1}{256}{Arthur Andrade D'Olival}
 
 No laboratório de experimentos caóticos da \textbf{Fábrica de Balões Numéricos}, um cientista excêntrico te entrega uma fileira de balões, cada um pintado com um número inteiro positivo.
 
@@ -45,5 +45,9 @@ $3 \times 1 \times 5 + 3 \times 5 \times 8 + 1 \times 3 \times 8 + 1 \times 8 \t
 Portanto, o total máximo de energia é $167$.
 
 No segundo exemplo, independentemente da ordem escolhida, a energia total liberada é
-$1 \times 1 \times 5 + 1 \times 5 \times 1 = 10$.\end{ProblemaAutor}
+$1 \times 1 \times 5 + 1 \times 5 \times 1 = 10$.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/burst-balloons/description/}{Leetcode 312}.\end{ProblemaAutor}
 \end{document}

estouro/problem.json

@@ -22,7 +22,7 @@
         }
     },
     "author": {
-        "name": "Leetcode 312",
+        "name": "Arthur Andrade D'Olival",
         "affiliation": "",
         "country": "",
         "email": ""
@@ -43,7 +43,7 @@
     },
     "solutions": {
         "main-ac": "ac.cpp",
-        "alternative-ac": [],
+        "alternative-ac": ["alternative-ac.py"],
         "wrong-answer": [],
         "time-limit": [],
         "time-limit-or-ac": [],

estouro/src/alternative-ac.py

@@ -0,0 +1,14 @@
+n = int(input())
+nums = list(map(int, input().split()))
+
+nums = [1] + nums + [1]
+
+dp = [[0] * len(nums) for _ in range(len(nums))]
+
+for length in range(3, len(nums) + 1):
+    for i in range(len(nums) - length + 1):
+        j = i + length - 1
+        for k in range(i + 1, j):
+            dp[i][j] = max(dp[i][j], dp[i][k] + dp[k][j] + nums[i] * nums[k] * nums[j])
+
+print(dp[0][len(nums) - 1])

estouro/statement/notes.tex

@@ -3,4 +3,8 @@ $3 \times 1 \times 5 + 3 \times 5 \times 8 + 1 \times 3 \times 8 + 1 \times 8 \t
 Portanto, o total máximo de energia é $167$.
 
 No segundo exemplo, independentemente da ordem escolhida, a energia total liberada é
-$1 \times 1 \times 5 + 1 \times 5 \times 1 = 10$.
+$1 \times 1 \times 5 + 1 \times 5 \times 1 = 10$.
+
+\section*{Observações}
+
+Problema adaptado de \href{https://leetcode.com/problems/burst-balloons/description/}{Leetcode 312}.

flowers/arthur-dolival-flowers-tutorial.tex

@@ -0,0 +1,48 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+\usepackage{graphicx}
+\input{statement/preamble.tex}
+\title{ Tutorial: O problema das Flores}
+\author{Arthur Andrade D'Olival}
+\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}

flowers/arthur-dolival-flowers.tex

@@ -0,0 +1,41 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{O problema das Flores}{1}{256}{Arthur Andrade D'Olival}
+
+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\), onde \(n\) (\(1 \leq n \leq 1\,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
+
+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~1} & \texttt{2}\\
+\end{Exemplo}
+
+
+
+\Notas
+
+Caso de teste 1: \(n=1, m=1\).  
+Para uma sequência de comprimento 1 existem duas opções: {vermelha} ou {branca}. Portanto, o número de sequências válidas é 2.
+
+Caso de teste 2: \(n=2, m=2\).  
+Como \(m \ge 2\), não há restrição efetiva para \(n=2\) além de que cada posição pode ser vermelha ou branca. Assim todas as \(2^2 = 4\) sequências são válidas.\end{ProblemaAutor}
+\end{document}

flowers/flowers-tutorial.tex

@@ -7,7 +7,7 @@
 \usepackage{hyperref}
 
 \title{ Tutorial: O problema das Flores}
-\author{}
+\author{Arthur Andrade D'Olival}
 \date{}
 \begin{document}
 \maketitle

flowers/flowers.tex

@@ -1,7 +1,7 @@
 \documentclass{maratona}
 
 \begin{document}
-\begin{ProblemaAutor}{}{O problema das Flores}{1}{256}{}
+\begin{ProblemaAutor}{}{O problema das Flores}{1}{256}{Arthur Andrade D'Olival}
 
 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).
 
@@ -13,7 +13,7 @@ Bino está planejando o jardim e quer saber quantas opções de design ele realm
 
 \Entrada
 
-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.
+A entrada contém dois inteiros separados por espaço, \(n\) e \(m\), onde \(n\) (\(1 \leq n \leq 1\,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
 

flowers/input/10

@@ -1 +1 @@
-1497 202
+97 202

flowers/input/100

@@ -1 +1 @@
-7455 217
+455 217

flowers/input/101

@@ -1 +1 @@
-3590 343
+590 343

flowers/input/102

@@ -1 +1 @@
-4427 220
+427 220

flowers/input/103

@@ -1 +1 @@
-1342 584
+342 584

flowers/input/104

@@ -1 +1 @@
-4239 496
+239 496

flowers/input/105

@@ -1 +1 @@
-5875 601
+875 601

flowers/input/106

@@ -1 +1 @@
-10000 1
+1000 1

flowers/input/107

@@ -1 +1 @@
-10000 1000
+1000 1000

flowers/input/11

@@ -1 +1 @@
-1775 325
+175 325

flowers/input/12

@@ -1 +1 @@
-1982 784
+182 784

flowers/input/13

@@ -1 +1 @@
-417 156
+17 156

flowers/input/14

@@ -1 +1 @@
-1932 902
+132 902

flowers/input/15

@@ -1 +1 @@
-1728 537
+128 537

flowers/input/16

@@ -1 +1 @@
-1857 739
+57 739

flowers/input/17

@@ -1 +1 @@
-918 211
+118 211

flowers/input/18

@@ -1 +1 @@
-1679 506
+79 506

flowers/input/19

@@ -1 +1 @@
-1340 568
+140 568

flowers/input/20

@@ -1 +1 @@
-1868 16
+68 16

flowers/input/21

@@ -1 +1 @@
-1940 263
+140 263

flowers/input/22

@@ -1 +1 @@
-593 449
+193 449

flowers/input/23

@@ -1 +1 @@
-991 310
+191 310

flowers/input/24

@@ -1 +1 @@
-1355 68
+155 68

flowers/input/25

@@ -1 +1 @@
-1431 580
+31 580

flowers/input/26

@@ -1 +1 @@
-1757 218
+157 218

flowers/input/27

@@ -1 +1 @@
-934 328
+134 328

flowers/input/28

@@ -1 +1 @@
-1676 355
+76 355

flowers/input/29

@@ -1 +1 @@
-221 80
+21 80