Updating lazy-frog files

longest-increasing-subsequence/arthur-dolival-longest-increasing-subsequence-tutorial.tex

@@ -0,0 +1,50 @@
+\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: Maior subsequência Crescente}
+\author{}
+\date{}
+\begin{document}
+\maketitle
+\section{Solução do Problema}
+
+O problema de encontrar a maior subsequência crescente (\textit{Longest Increasing Subsequence} - LIS) é um clássico que pode ser resolvido de forma eficiente por meio de \textbf{programação dinâmica}. A ideia central é focar no final da subsequência: para cada elemento da sequência original, calculamos qual é a maior subsequência crescente que termina exatamente nele.
+
+\subsection{Definição do Subproblema}
+
+Seja $a$ o nosso vetor de números inteiros com $N$ elementos, indexado de $0$ a $N-1$. 
+Definimos o nosso estado da programação dinâmica como:
+
+$$d[i] = \text{o comprimento da maior subsequência crescente que termina obrigatoriamente no índice } i.$$
+
+A resposta final para o tamanho da maior subsequência não será necessariamente $d[N-1]$, mas sim o maior valor alcançado em todo o vetor $d$, ou seja, $\max(d[i])$ para $0 \le i < N$.
+
+\subsection{Função de Transição}
+
+Para determinar o valor de $d[i]$, precisamos olhar para todos os elementos anteriores à posição $i$, ou seja, um índice $j$ tal que $0 \le j < i$. 
+
+Se encontrarmos um elemento anterior que seja estritamente menor que o elemento atual ($a[j] < a[i]$), isso significa que podemos estender a subsequência que terminava em $j$ anexando o elemento $a[i]$ ao final dela. O novo comprimento seria $d[j] + 1$. 
+Avaliamos todos os possíveis índices $j$ válidos e mantemos o que gera o maior comprimento:
+
+$$d[i] = \max_{\substack{0 \le j < i \\ a[j] < a[i]}} \big( d[j] + 1 \big)$$
+
+\subsection{Casos Base}
+
+O caso base é bastante intuitivo: na pior das hipóteses, qualquer elemento isolado forma, por si só, uma subsequência válida de comprimento $1$. Portanto, a nossa inicialização padrão para todos os estados é:
+
+$$d[i] = 1 \quad \text{para todo } 0 \le i < N$$
+
+\subsection{Recuperação da Decomposição (Elementos da subsequência)}
+
+Como o problema exige a impressão dos elementos que formam a subsequência, precisamos reconstruir o caminho ótimo. Para isso, utilizamos um vetor auxiliar $p[i]$ (de \textit{parent} ou predecessor), inicializado com $-1$.
+
+Durante a transição, sempre que atualizamos $d[i]$ com um valor maior proveniente de um $d[j] + 1$, registramos o índice de origem definindo $p[i] = j$. 
+
+Após calcularmos todo o vetor $d$, localizamos o índice \texttt{pos} que contém o valor máximo absoluto de $d$. A partir de \texttt{pos}, recuperamos os elementos da subsequência percorrendo o caminho reverso: adicionamos $a[\texttt{pos}]$ à nossa lista de resposta e saltamos para o predecessor atualizando $\texttt{pos} = p[\texttt{pos}]$. Repetimos o processo até que $\texttt{pos}$ seja $-1$. Como resgatamos os elementos do final para o começo, basta inverter a lista resultante para apresentar a subsequência na ordem crescente original.\end{document}

longest-increasing-subsequence/arthur-dolival-longest-increasing-subsequence.tex

@@ -0,0 +1,42 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Maior subsequência Crescente}{1}{256}{}
+
+O problema consiste em determinar a maior subsequência crescente de uma sequência de números inteiros. 
+Uma subsequência é formada ao remover zero ou mais elementos da sequência original, sem alterar a ordem relativa dos elementos restantes. 
+A subsequência procurada deve conter pelo menos um elemento, e seus valores devem estar em ordem estritamente crescente, isto é, para todos os índices válidos \( i \) e \( j \) pertencentes à subsequência, se \( i < j \) então \( a_i < a_j \). 
+O objetivo é identificar essa subsequência de tamanho máximo e apresentar tanto o seu comprimento quanto os próprios elementos.
+
+\Entrada
+
+A entrada é composta por duas linhas. 
+A primeira linha contém um inteiro \( N \) (\( 1 \leq N \leq 1000 \)), representando o número de elementos da sequência. 
+A segunda linha contém \( N \) inteiros \( a_1, a_2, \ldots, a_N \) (\( -10^4 \leq a_i \leq 10^4 \)), separados por espaços, correspondentes aos elementos da sequência.
+
+\Saida
+
+A saída deve conter duas linhas. 
+A primeira linha deve conter um único inteiro representando o tamanho \( L \) da maior subsequência crescente. 
+A segunda linha deve conter \( L \) inteiros \( b_1, b_2, \ldots, b_L \), correspondentes aos elementos dessa subsequência, na mesma ordem em que aparecem na sequência original, separados por um espaço.
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{5} & \texttt{5}\\
+\texttt{1~2~3~4~5} & \texttt{1~2~3~4~5}\\
+\rowcolor{gray!20}\texttt{4} & \texttt{3}\\
+\rowcolor{gray!20}\texttt{2~3~-1~4} & \texttt{2~3~4}\\
+\texttt{1} & \texttt{1}\\
+\texttt{0} & \texttt{0}\\
+\end{Exemplo}
+
+
+
+\Notas
+
+Para a sequência \( (1, 2, 3, 4, 5) \), toda a sequência já é estritamente crescente, portanto o tamanho da subsequência é \( L = 5 \) e ela contém os mesmos elementos. 
+Para a sequência \( (2, 3, -1, 4) \), uma das maiores subsequências crescentes possíveis é \( (2, 3, 4) \), com tamanho \( L = 3 \). 
+Para a sequência \( (0) \), há apenas um elemento, então a maior subsequência crescente é o próprio número \( 0 \), com tamanho \( L = 1 \).
+\end{ProblemaAutor}
+\end{document}