Updating lazy-frog files

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

@@ -0,0 +1,59 @@
+\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 II}
+\author{}
+\date{}
+\begin{document}
+\maketitle
+\section{Solução do Problema}
+
+O problema de encontrar a maior subsequência crescente (\textit{Longest Increasing Subsequence} - LIS) possui uma solução clássica em $O(N^2)$, mas quando $N$ é grande, podemos otimizá-la para \textbf{$O(N \log N)$} combinando \textbf{programação dinâmica com busca binária}. A grande sacada dessa otimização é mudar a perspectiva: em vez de guardar o tamanho da maior subsequência que termina em um índice, guardamos o \textbf{menor valor final} possível para uma subsequência de um determinado comprimento.
+
+\subsection{Definição do Subproblema}
+
+Seja $a$ o nosso vetor de números inteiros de tamanho $N$.
+Definimos o nosso estado da programação dinâmica como:
+
+$$d[l] = \text{o menor valor que encerra uma subsequência crescente de comprimento exato } l.$$
+
+O vetor $d$ terá uma propriedade muito importante: ele estará sempre rigorosamente ordenado de forma crescente. A resposta final será o maior $l$ tal que $d[l] \neq \infty$.
+
+\subsection{Função de Transição}
+
+Para calcular $d[l]$, iteramos sobre cada elemento $a[i]$ da nossa sequência original. Como queremos que os elementos finais de cada comprimento sejam os menores possíveis, tentamos usar $a[i]$ para melhorar o nosso vetor $d$.
+
+Como $d$ está ordenado, podemos usar \textbf{busca binária} (\texttt{upper\_bound} ou \texttt{lower\_bound}) para encontrar rapidamente a posição $l$ onde $a[i]$ deve ser inserido. Se $a[i]$ for maior que o final de uma subsequência de tamanho $l-1$ ($d[l-1] < a[i]$) e, ao mesmo tempo, puder substituir um final pior de tamanho $l$ ($a[i] < d[l]$), nós o atualizamos:
+
+$$d[l] = a[i]$$
+
+Isso significa que encontramos uma subsequência crescente de comprimento $l$ que termina em $a[i]$, e esse final é melhor (menor) do que o que tínhamos registrado anteriormente.
+
+\subsection{Casos Base}
+
+Para que a lógica de busca e as comparações iniciais funcionem sem estourar os limites, inicializamos o vetor $d$ de tamanho $N+1$ da seguinte forma:
+
+$$d[0] = -\infty$$
+$$d[l] = \infty \quad \text{para todo } 1 \le l \le N$$
+
+Isso representa que uma subsequência de tamanho $0$ termina em um valor infinitamente pequeno, enquanto os outros comprimentos ainda não foram alcançados.
+
+\subsection{Recuperação da Decomposição (Elementos da subsequência)}
+
+Para recuperar os elementos exatos da LIS nesta abordagem otimizada, o vetor $d$ sozinho não basta (pois ele pode conter uma mistura de elementos de diferentes subsequências válidas ao longo do tempo). Precisamos de duas estruturas de rastreamento:
+\begin{itemize}
+    \item $pos[l]$: armazena o \textbf{índice original} do elemento que atualmente ocupa $d[l]$.
+    \item $p[i]$: armazena o predecessor do elemento de índice $i$, assim como na versão $O(N^2)$.
+\end{itemize}
+
+Durante a transição, sempre que atualizamos $d[l] = a[i]$, nós também registramos que esse elemento se encontra no índice $i$ original fazendo $pos[l] = i$. 
+Ao mesmo tempo, sabemos que o elemento imediatamente anterior a ele na subsequência é o elemento que termina o comprimento $l-1$. Logo, conectamos o predecessor: $p[i] = pos[l-1]$.
+
+Ao final de todas as iterações, sabemos que \texttt{ans} é o comprimento máximo alcançado. O índice do último elemento dessa subsequência estará em $cur = pos[\texttt{ans}]$. A partir desse $cur$, reconstruímos a sequência retrocedendo $cur = p[cur]$ até atingir $-1$, e por fim invertemos a lista para exibi-la na ordem correta.\end{document}

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

@@ -0,0 +1,42 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Maior subsequência Crescente II}{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 10^5 \)), 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}