fix: removing duplicated tests and correcting some small solutions

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

@@ -0,0 +1,51 @@
+\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: Caching Offline}
+\author{}
+\date{}
+\begin{document}
+\maketitle
+O problema consiste em simular um gerenciador de cache e determinar o número mínimo de falhas de página. Como a sequência completa de requisições é conhecida previamente, podemos utilizar uma estratégia gulosa para resolver o problema.
+
+\subsection*{Representação do estado}
+
+\begin{itemize}
+    \item A memória principal (cache) é representada por um conjunto (\textit{hash set}), que armazena os identificadores das páginas atualmente carregadas, permitindo consultas em tempo constante.
+    \item O histórico futuro de cada página é mapeado em vetores, registrando todos os índices (momentos no tempo) em que cada página será requisitada.
+    \item Um vetor de ponteiros auxiliares acompanha qual a próxima ocorrência futura correspondente para cada página.
+\end{itemize}
+
+\subsection*{Estratégia de solução usando Algoritmo Guloso}
+
+A estratégia ótima dita que, quando a cache estiver cheia e ocorrer uma falha, a página a ser substituída deve ser aquela que demorará mais tempo para ser referenciada novamente no futuro.
+
+\begin{enumerate}
+    \item Leia a capacidade da cache ($k$) e o tamanho da sequência de requisições ($v$).
+    \item Faça um pré-processamento da sequência de páginas:
+    \begin{itemize}
+        \item Armazene a sequência original em um vetor.
+        \item Para cada página lida, adicione o índice atual à sua respectiva lista de referências futuras.
+    \end{itemize}
+    \item Inicialize a cache vazia, o controle de progresso das referências futuras e o contador de falhas (\textit{misses}).
+    \item Percorra a sequência de requisições passo a passo:
+    \begin{itemize}
+        \item Se a página atual \textbf{não} estiver na cache, ocorreu uma falha de página. Incremente o contador de \textit{misses}.
+        \item Se a cache já estiver cheia (tamanho igual a $k$) no momento da falha, é necessário eleger uma página residente para remoção:
+        \begin{itemize}
+            \item Inspecione todas as páginas atualmente na cache.
+            \item Se alguma página não possuir mais requisições futuras, ela é a candidata ideal e deve ser escolhida para remoção imediata.
+            \item Caso contrário, compare a próxima requisição de todas e encontre aquela que vai demorar mais tempo para aparecer de novo (índice mais distante no futuro), removendo-a.
+        \end{itemize}
+        \item Insira a nova página na cache.
+        \item Ao final de cada iteração, independentemente de ter ocorrido acerto ou falha, avance o ponteiro de ocorrências da página que acabou de ser processada.
+    \end{itemize}
+    \item Ao término da simulação, imprima o total de falhas contabilizadas.
+\end{enumerate}\end{document}

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

@@ -0,0 +1,52 @@
+\documentclass{maratona}
+
+\begin{document}
+\begin{ProblemaAutor}{}{Caching Offline}{1}{256}{}
+
+Dado um sistema com memória principal dividida em \( k \) frames, deseja-se gerenciar uma sequência de requisições de páginas de modo a minimizar falhas de memória (\textit{cache misses}).
+
+Considere que a sequência de páginas referenciadas \( (v_0, v_1, \ldots, v_{n-1}) \) é conhecida a priori, onde cada \( v_i \) representa o identificador de uma página. Inicialmente, a cache (memória principal) encontra-se vazia.
+
+O objetivo é projetar um algoritmo que determine a \textbf{menor quantidade possível de falhas de página} para a sequência dada. Uma falha ocorre sempre que uma página referenciada não está presente em um dos \( k \) frames disponíveis. Se a cache estiver cheia e uma nova página precisar ser carregada, uma das páginas residentes deve ser substituída.
+
+\Entrada
+
+A entrada é composta por duas linhas.
+
+A primeira linha contém dois inteiros: \( k \) (\( 1 \le k \le 1000 \)), representando a quantidade de frames disponíveis na memória, e \( n \) (\( 1 \le n \le 1000 \)), representando o número total de referências na sequência de páginas.
+
+A segunda linha contém \( n \) inteiros positivos \( v_i \) (\( 1 \le v_i \le 1000 \)), representando os identificadores de cada página na sequência de referências.
+
+\Saida
+
+A saída deve conter uma única linha.
+
+Deve ser impresso um único inteiro representando o \textbf{menor número de falhas de página} (\textit{cache misses}) que podem ser obtidos para a sequência e capacidade de memória fornecidas.
+
+\ExemploEntrada
+
+\begin{Exemplo}
+\texttt{1~3} & \texttt{3}\\
+\texttt{1~2~3} & \\
+\rowcolor{gray!20}\texttt{2~5} & \texttt{3}\\
+\rowcolor{gray!20}\texttt{1~2~3~1~1} & \\
+\texttt{5~10} & \texttt{5}\\
+\texttt{1~2~3~4~5~5~4~3~2~1} & \\
+\end{Exemplo}
+
+
+
+\Notas
+
+No primeiro caso de teste, temos \( k=1 \) frame e uma sequência de 3 referências: \((1, 2, 3)\). Como a memória só pode comportar uma página por vez e todas as referências são para páginas diferentes, cada nova requisição resultará em uma falha (\textit{miss}) para carregar a página atual e substituir a anterior. Portanto, o total de falhas é 3.
+
+No segundo caso, a memória possui \( k=2 \) frames e a sequência é \((1, 2, 3, 1, 1)\). 
+\begin{itemize}
+    \item As páginas 1 e 2 são carregadas inicialmente, causando 2 falhas. 
+    \item Quando a página 3 é requisitada, a memória está cheia, com as páginas \{1, 2\}. Substitui-se a página 2 pela 3, \{1, 3\}. 
+    \item As referências subsequentes para a página 1 já estão na memória.
+    \item O número mínimo de falhas é 3.
+\end{itemize}
+
+No terceiro caso, com \( k=5 \) frames e a sequência \((1, 2, 3, 4, 5, 5, 4, 3, 2, 1)\), o número de páginas distintas na sequência é exatamente 5. Como a capacidade da memória é suficiente para manter todas as páginas únicas da sequência simultaneamente, ocorrem apenas as 5 falhas iniciais para o preenchimento da cache. Uma vez que todas as páginas estão carregadas, as referências de volta (\(5, 4, 3, 2, 1\)) resultam todas em acertos (\textit{hits}). O total de falhas é 5.\end{ProblemaAutor}
+\end{document}