• 8 e 12 problemas, cujas categorias e frequência por categoria são:

• A lista apresentada considera os problemas propostos em competições nos últimos anos.

• Com o passar do tempo, a frequência das categorias pode mudar ou até mesmo novos tipos de problemas podem surgir.

• Exemplo: problemas de Programação Dinâmica começaram a ser cobrados apenas no fim dos anos 90 e é um dos tipos mais populares nos dias de hoje.

Sempre que você elaborar a solução de um problema, pergunte:

A solução é capaz de tratar a maior entrada esperada considerando os limites de tempo e memória dispoíveis?

• A maior entrada esperada e os limites de tempo de execução e memória são definidos no enunciado do problema. Muitas vezes existem diversas soluções possíveis, mas algumas delas podem não atender as restrições impostas!


• Regra de ouro: Escolha sempre a solução mais simples que atende a todas as restrições!

• Problema com limite de tempo de um segundo tem tamanho $n=100.000$ e a solução desenvolvida realize na ordem de $n^2$ operações.


• $n^2=10^{10}$ é um número extremamente grande! Provavelmente o limite de tempo do problema não será satisfeito.


• Outra solução correta para o mesmo problema realize na ordem de $n*log_2(n)$ operações. $log_2(10^5) \approx 16$ logo, $n*log_2(n)$ é da ordem de $10^6$.


• Computadores atuais: $10^6$ operações por segundo, suas chances de conseguir passar a solução são muito maiores!

• Solução que efetua na ordem de $n^4$ operações.


• Esta parece ser uma solução muito ruim...


• Mas se a maior entrada for $n\leq10$, o número de operações realizadas pelo algoritmo será da ordem de $n^4=10.000$ que provavelmente será aceita pelo juíz online!


• A sua solução não precisa ser a mais eficiente possível, mas sim ser eficiente o suficiente para ser aceita!

• $2^{10} \approx 10^3$ e $2^{20} \approx 10^6$.


• Inteiro de 32 bits: $2^{31}-1 \approx 2*10^9$. Isto é, um número com até 9 dígitos.


• Inteiro de 64 bits: $2^{63}-1 \approx 2*10^{18}$. Isto é, um número com até 18 dígitos.


• Programa com $k$ laços aninhados, cada um com $n$ iterações executam na ordem de $n^k$ operações.


• Algoritmos de ordenação: ordem de $n*log_2(n)$ operações. Algoritmos com a ordem de $n*log_2(n)$ operações são aceitos pelos juízes online.

• Depois de elaborar e analizar uma solução, vc precisa testa-la antes de submetê-la para o juíz online!


• Crie o hábito de desenvolver os algoritmos no papel e de fazer o teste de mesa. Os recursos computacionais podem ser limitados durante a competição!


• Aprenda a depurar o seu código!


• Não basta testar a sua solução usando as entradas fornecidas no enunciado do problema! Você deve criar novas entradas!

O que testar?

• Se sua solução consegue tratar entradas do tamanho máximo permitido considerando as restrições impostas no enunciado.


• Se ao rodar casos testes idênticos em sequência, seu programa produz o mesmo resultado.


• Casos teste capiciosos, que ficam "escondidos" nas entrelinhas enunciado do problema.

Várias linguagens são aceitas pelos juízes online. Em qual delas eu devo focar os meus estudos?

• Apesar de C/C++ ser a liguagem mais eficiente, dominar as liguagens Java e Python é importante pois estas oferecem funcionalidades que não existem em C/C++.

Exemplo: o cálculo de 25! (fatorial de 25)

• 25! = 15.511.210.043.330.985.984.000.000, isto é um número inteiro de 26 dígitos!


• Para realizar essa operação, você pode:
  • Usar a classe BigInteger da biblioteca padrão do Java.
  • Escrever o código em Python, que tem suporte nativo para a representação de inteiros muito grandes!

Código em Java:

        
import java.util.*;
import java.math.*;

class Main { // Nome padrão de uma classe no UVA e no URI
public static void main(String[] args) {
  // Criação da variável do tipo BigInteger
  BigInteger fac = new BigInteger.valueOf(1); 
    for (int i = 2; i <= 25; i++)
      // Multiplicação. fac *= i :) 
      fac = fac.multiply(BigInteger.valueOf(i)); 
    }
    System.out.println(fac);
}
        
      

Código em Python:

        
fac = 1
for i in range(2,26):
  fac*= i
print(fac)
        
      

Leitura:

• Capítulo 1 do livro texto Competitive Programming 1
  Halim, S. e Halim, F.

Exercícios:

• Lista de exercícios, de problemas de aquecimento.