\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}
