chore: build all pdfs

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

@@ -0,0 +1,44 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: Análise de Dados}
+\author{Leetcode 1223}
+\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/statement/tutorial.tex

@@ -0,0 +1,31 @@
+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.

argus/argus-tutorial.tex

@@ -0,0 +1,24 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: Argus}
+\author{UVA - 1203}
+\date{}
+\begin{document}
+\maketitle
+Para resolver o problema, utilizaremos uma \textbf{fila de prioridade (min-heap)} que armazenará os instantes em que cada medicamento deve ser tomado novamente, juntamente com o nome do medicamento. Dessa forma, sempre poderemos determinar facilmente qual é o próximo medicamento a ser administrado.
+
+Inicialmente, inserimos na fila todos os medicamentos com o tempo de sua \textit{primeira dose}. Em seguida, repetimos o seguinte processo até listar todas as doses necessárias:
+\begin{enumerate}
+    \item Remover da fila o medicamento com o menor tempo de administração (isto é, o que deve ser tomado mais cedo).
+    \item Imprimir o nome do medicamento e o tempo.
+    \item Calcular o próximo instante em que esse medicamento deverá ser tomado, somando o seu intervalo de tempo ao instante atual.
+    \item Inserir novamente o medicamento na fila com o novo instante calculado.
+\end{enumerate}
+
+Esse método garante que os medicamentos sejam listados em ordem cronológica, respeitando os intervalos de cada um e evitando que qualquer dose seja esquecida.\end{document}

breakdown-desastroso/breakdown-desastroso-tutorial.tex

@@ -0,0 +1,31 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: Breakdown Desastroso}
+\author{Kattis - Disastrous Downtime}
+\date{}
+\begin{document}
+\maketitle
+Para resolver o problema, utilizaremos uma \textbf{fila de prioridade (min-heap)} para armazenar o \textbf{instante em que cada servidor ficará livre} para ser utilizado novamente. Além disso, manteremos uma variável para registrar o \textbf{número máximo de servidores ativos} em um dado momento da simulação.
+
+A cada nova requisição, verificamos o elemento no topo da fila, isto é, o servidor que ficará disponível mais cedo.
+\begin{itemize}
+    \item Se o tempo armazenado nesse elemento for \textbf{menor que o instante da requisição atual}, significa que o servidor já está livre e pode ser reutilizado, então o removemos da fila.
+    \item Caso contrário, o servidor ainda está ocupado, e portanto \textbf{precisaremos ativar um novo servidor} para atender à requisição.
+\end{itemize}
+
+Em ambos os casos, inserimos na fila um novo valor correspondente a $(instante\_requisição + 1000)$, indicando que o servidor recém-utilizado permanecerá ocupado pelos próximos $1000$ milissegundos.
+
+Durante o processo, atualizamos continuamente a variável que armazena o \textbf{maior tamanho alcançado pela fila}, representando o pico de servidores simultaneamente ativos.
+
+Ao final da simulação, o número mínimo de servidores necessários será dado por:
+\[
+\left\lceil \frac{n_{\text{máx}}}{K} \right\rceil
+\]
+onde $K$ é o número de requisições que cada servidor consegue processar simultaneamente.
+\end{document}

estouro/estouro-tutorial.tex

@@ -0,0 +1,52 @@
+\documentclass[10pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{amsmath,amsthm,amssymb}
+\usepackage{fullpage}
+\usepackage{url}
+\pagenumbering{gobble}
+\usepackage{hyperref}
+
+\title{ Tutorial: Estouro}
+\author{Leetcode 312}
+\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/statement/tutorial.tex

@@ -0,0 +1,39 @@
+\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.

min-sum-path-2d/min-sum-path-2d.tex

@@ -33,61 +33,5 @@ Imprima um único inteiro representando o menor custo total para ir da célula s
 
 
 
-\Notas
-
-\begin{itemize}
-
-    \item \textbf{Exemplo 1}  
-    \[
-    n = 1,\quad m = 1,\quad
-    C = 
-    \begin{bmatrix}
-        5
-    \end{bmatrix}
-    \]
-    Como há apenas uma célula, o caminho consiste apenas nela.  
-    O menor custo é:
-    \[
-    5
-    \]
-
-    \item \textbf{Exemplo 2}  
-    \[
-    n = 2,\quad m = 2,\quad
-    C =
-    \begin{bmatrix}
-        1 & 3 \\
-        2 & 4
-    \end{bmatrix}
-    \]
-    Os caminhos possíveis são:
-    \begin{itemize}
-        \item Direita → Baixo: \( 1 + 3 + 4 = 8 \)
-        \item Baixo → Direita: \( 1 + 2 + 4 = 7 \)
-    \end{itemize}
-    Logo, o menor custo é:
-    \[
-    7
-    \]
-
-    \item \textbf{Exemplo 3}
-    \[
-    n = 3,\quad m = 3,\quad
-    C =
-    \begin{bmatrix}
-        1 & 2 & 3 \\
-        4 & 5 & 6 \\
-        7 & 8 & 9
-    \end{bmatrix}
-    \]
-    O movimento sempre aumenta o custo, portanto o caminho ótimo é seguir pela primeira linha e depois descer:
-    \[
-    1 + 2 + 3 + 6 + 9 = 21
-    \]
-    Assim, o menor custo para ir de \((0,0)\) a \((2,2)\) é:
-    \[
-    21
-    \]
-
-\end{itemize}\end{ProblemaAutor}
+\end{ProblemaAutor}
 \end{document}

o-problema-dos-pacotes-viajantes/o-problema-dos-pacotes-viajantes.tex

@@ -13,7 +13,7 @@ Cada estação possui duas plataformas de operação:
 \item \textbf{Plataforma B}: mantém uma fila de encomendas que ainda precisam ser enviadas para outras estações.
 \end{itemize}
 
-O carrinho possui uma pilha interna com capacidade limitada, utilizada para armazenar as encomendas em trânsito. Como se trata de uma pilha, apenas a encomenda localizada no topo pode ser retirada. Ao chegar a uma estação, o carrinho inicia o processo de \textbf{descarregamento}: ele retira do topo da pilha todas as encomendas destinadas àquela estação, uma a uma, depositando-as na plataforma A. Se encontrar uma encomenda destinada a outra estação, ele tenta colocá-la na fila da plataforma B, caso haja espaço disponível. Se a fila estiver cheia, o descarregamento é interrompido.
+O carrinho possui uma pilha interna com capacidade limitada, utilizada para armazenar as encomendas em trânsito. Como se trata de uma pilha, apenas a encomenda localizada no topo pode ser retirada. Ao chegar a uma estação, o carrinho inicia o processo de \textbf{descarregamento}, retirando do topo da pilha as encomendas uma a uma. Cada encomenda é depositada na plataforma A da estação caso seu destino corresponda à estação atual; caso contrário, o carrinho tenta colocá-la na fila da plataforma B, desde que haja espaço disponível. Se a fila estiver cheia e o destino da encomenda no topo da pilha não corresponder à estação atual, o processo de descarregamento é interrompido.
 
 Em seguida, ocorre o \textbf{carregamento}: o carrinho pega, na ordem da fila da plataforma B, as encomendas que aguardam envio e as adiciona ao topo da pilha, até que esta atinja sua capacidade máxima ou a fila fique vazia.
 

unconventional-pairs/unconventional-pairs.tex

@@ -13,7 +13,7 @@ Determine o menor valor possível para essa diferença máxima.
 
 \Entrada
 
-Cada teste consiste em vários casos de teste. A primeira linha contém um único inteiro \( t \) (\( 1 \le t \le 10^4 \)), indicando o número de casos de teste.
+A entrada consiste em vários casos de teste. A primeira linha contém um único inteiro \( t \) (\( 1 \le t \le 10^4 \)), indicando o número de casos de teste.
 
 Para cada caso de teste:
 \begin{itemize}