Unnamed: 0 int64 0 3.55k | id stringlengths 1 13 | title stringlengths 2 50 | difficulty stringclasses 6 values | category stringclasses 15 values | text stringlengths 226 7.79k |
|---|---|---|---|---|---|
3,300 | 244 | Estratégia Gulosa | Fácil | Tecnicas | **Tarefa:** Dado um conjunto de moedas $S$ com valores diferentes. Qual é a quantidade mínima de moedas necessárias para representar o valor $V$?
Neste exercício sempre consideraremos $S = \{1, 5, 10, 25, 50, 100\}$.
**Exemplo:** Para $S$ dado e $V = 235$, precisamos de 4 moedas. 2 moedas com valor 100, 1 moeda com valor 25 e 1 moeda com valor 10.
#### Entrada
A entrada contém um único número representando $V$.
#### Saída
Seu programa deve imprimir o menor número de moedas necessárias para representar $V$.
#### Restrições
* 1 $\leq$ $N$ $\leq$ $1000000$ |
3,301 | 253 | Times | Médio | Tecnicas | As aulas de educação física, em muitas escolas, acontecem da seguinte maneira: O professor entrega uma bola ao alunos (geralmente de futebol) e estes se dividem em times, onde jogam partidas alternadamente.
A maneira como os times são escolhidos também é semelhante em todas as escolas: decide-se quantos times serão formados, e uma pessoa para montar cada um dos times. Cada pessoa vai escolher, alternadamente, um dos alunos restantes para fazer parte de sua equipe. Como todos querem ter uma boa equipe, a pessoa que vai escolher o próximo membro do time escolhe aquele, dentre os ainda disponíveis, que possui o melhor nível de habilidade. Assim, os times acabam ficando relativamente equilibrados na soma do nível de habilidade dos jogadores.
Dada uma lista de alunos que serão escolhidos e seus respectivos níveis de habilidade para os times e a quantidade de times que serão formados, mostre como ficarão os times ao final do processo de montagem dos mesmos.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $T$, representando respectivamente a quantidade de alunos e o número de times a serem formados, sendo $T$ $\leq$ $N$. As $N$ linhas seguintes descrevem, cada uma, um aluno disponível para escolha de times. Cada uma dessas linhas possui o nome do aluno (composto apenas por letras minúsculas) e um inteiro $H$ descrevendo seu nível de habilidade).
Não existem dois alunos com o mesmo nível de habilidade, e todos eles possuem nomes diferentes. É possível que alguns times acabem ficando com menos jogadores do que os outros.
#### Saída
Seu programa deve imprimir a lista de times que será formada ao final do processo de seleção. Para cada time, você deverá mostrar o termo "Time $N$", onde $N$ é o número do time (1 para o primeiro, 2 para o segundo, e assim por diante) seguido de $K$ linhas, onde $K$ é a quantidade de jogadores do time, mostrando o nome de cada um dos jogadores do time, em ordem alfabética. Imprima uma linha em branco após cada descrição de time (inclusive do último).
Os times serão escolhidos pelo computador, então não é necessário considerar o aluno que irá fazer a escolha dos times.
#### Restrições
* $2 \leq N \leq 10000$
* $2 \leq T \leq 1000$
* $0 \leq H \leq 1000000$
|
3,302 | 255 | Soma de Casas | Médio | Tecnicas | Joãozinho mora em uma rua que tem $N$ casas. Marquinhos é o melhor amigo dele, mas sempre gosta de pregar peças em Joãozinho. Desta vez, ele pegou os dois brinquedos prediletos de Joãozinho e os escondeu em duas casas distintas da rua. Em compensação, Marquinhos deu uma dica importante para Joãozinho:
A soma dos números das casas em que escondi teus brinquedos é igual a $K$. Além disso, escolhi as casas de tal forma que não existe outro par de casas cuja soma tenha esse mesmo valor.
Sabendo disto, encontre qual é o par de casas em que se encontram os brinquedos de Joãozinho. Para auxiliar seu amigo, Marquinhos entregou a Joãozinho uma lista com o número das casas já em ordem crescente (isto é, do menor para o maior número).
#### Entrada
A primeira primeira linha da entrada contém um número inteiro $N$, que representa o número de casas que existem na rua. Cada uma das $N$ linhas seguintes contém um número inteiro, representando o número de uma casa. Note que esses $N$ números estão ordenados, do menor para o maior.
A última linha da entrada contém um inteiro $K$, que é a soma dos números das duas casas onde os brinquedos estão escondidos.
#### Saída
Se programa deve imprimir uma única linha, contendo dois inteiros, $A$ e $B$, $A < B$, que representam os números das casas em que estão escondidos os brinquedos. Os dois números devem ser separados por um espaço em branco.
#### Restrições
* $2 \leq N \leq 10^5$
* $0 \leq C_i \leq 10^9$ |
3,303 | 248 | Dentista | Médio | Tecnicas | Os dentistas são extremamente meticulosos em seu trabalho, tendo que agir com muita precisão em todas as suas atividades. Pedro é um dentista meticuloso como todos os outros. Infelizmente sua secretária não é muito organizada e, com o intuito de ajudar sempre os pacientes, aceita que eles marquem consultas no horário que quiserem, sem se preocupar com os demais horários marcados, ocasionando vários conflitos de horários que muito incomodaram Pedro e os pacientes. Por exemplo, se uma consulta começar às 9 horas e durar 2 horas, nenhuma outra consulta deveria ser marcada para iniciar as 10 horas.
Ao perceber que sua agenda tinha conflito de horários, Pedro pediu sua ajuda para descobrir a maior quantidade de consultas que podem ser atendidas sem sobreposição.
Você deve escrever um programa que, dados os horários de início e término das consultas agendadas pela secretária, responda a quantidade máxima de consultas que podem ser atendidas sem sobreposição.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ que indica quantas consultas a secretária marcou. Cada uma das $N$ linhas seguintes contém um par de inteiros $X$ e $Y$ separados por um espaço em branco que representam, respectivamente, o horário de início e de término da consulta. Considere que se uma consulta inicia no exato instante em que outra termina não há sobreposição. Os horários de início são fornecidos em ordem, podendo haver mais de uma consulta que inicie no mesmo horário.
#### Saída
Seu programa deve imprimir uma única linha, contendo um inteiro que representa a quantidade máxima de consultas que podem ser atendidas sem que haja qualquer sobreposição.
#### Pontuação
#### Subtask 1 (40 pontos)
* $1 \leq N \leq 10^4$
* $1 \leq X < Y \leq 10^3$
#### Subtask 2 (60 pontos)
* $1 \leq N \leq 10^4$
* $1 \leq X < Y \leq 10^6$
|
3,304 | 261 | Ogros | Médio | Tecnicas | Ogros marcianos, como todos sabem, são extremamente fortes.
Numa feira de circo marciano, ogros são chamados para bater um martelo num aparelho que mede sua força. O ogro ganha um determinado prêmio dependendo da faixa de força que alcançou (por exemplo, se a força alcançada foi entre 0 e 5, ganha 10 pontos. Se for entre 6 e 10, ganha 30). São possíveis $N$ premiações, para $N$ faixas de força alcançadas.
Você deve escrever um programa que recebe quais são as faixas de forças e suas respectivas premiações. Em seguida, o programa recebe a força alcançada por $M$ ogros, e deve calcular quanto cada ogro recebeu de premiação.
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado).
A primeira linha contém dois inteiros $N$ e $M$, representando respectivamente o número de faixas de premiações e o número de ogros cuja força foi medida.
A segunda linha de um caso de teste contém $N-1$ inteiros $A_i$ . A primeira faixa de premiação é dada por forças menores que $A_1$. A i-ésima faixa de premiação é composta das forças que são maiores ou iguais a $A_{i-1}$ e menores que $A_i$ . A n-ésima pontuação é composta das forças maiores ou iguais a $A_{N-1}$.
A terceira linha contém $N$ inteiros $F_i$ em ordem crescente, representando a premiação de cada faixa de premiação, nesta ordem.
A quarta e última linha de um caso de teste contém $M$ inteiros $O_i$, um para cada ogro, representando qual força cada ogro alcançou.
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo $M$ inteiros, um para cada ogro, na ordem dada pela entrada, representando qual premiação cada ogro recebeu pela sua força alcançada.
#### Restrições
* $2 \leq$ $N$ $\leq$ $10^5$
* $1 \leq$ $M$ $\leq$ $10000$
* $1 \leq A_i \leq 10^9$
* $A_{i-1} < A_i < A_{i+1}$
* $1 \leq F_i \leq 1.000.000.000$
* $F_{i-1} < F_i < F_{i+1}$
* $1 \leq O_i \leq 1.000.000.000$
|
3,305 | 4 | Caverna de Ordinskaya | Difícil | Tecnicas | Alguns de seus amigos decidiram viajar até a Russia para explorar Ordinskaya, a caverna subaquática mais comprida do país. Apesar da boa visibilidade das águas da caverna sempre é possível encontrar novas passagens e túneis que levam para longe da gruta principal, o que poderia fazer com que alguém se perdesse e provavelmente congelasse nas frias temperaturas observadas ali. Para evitar que algo assim ocorresse durante os mergulhos, o grupo usou uma fita métrica para marcar o caminho feito e garantir um retorno seguro. Além disso aproveitaram para medir quanto haviam explorado, sempre que retornavam à superfície alguém do grupo anotava num caderno o quão longe haviam ido.
O único problema com essa estratégia é que a cada mergulho pessoas diferentes ficavam responsáveis por verificar a fita métrica e anotar quanto havia sido explorado. Assim, se o comprimento da fita era 10 metros, após um mergulho em que o grupo explorou 3 metros da caverna, um dos amigos poderia ter desenrolado a fita do começo para o fim e anotar que 3 metros foram explorados, enquanto outromais desatento, sem perceber que havia desenrolado a fita no sentido contrário, poderia anotar que 7 metros foram explorados.
Apenas no final da viagem seus amigos perceberam a bagunça feita e agora pediram sua ajuda para reconstruir as distâncias de fato exploradas. Você foi informado que antes da viagem o grupo comprou uma fita com $M$ metros e que no total eles fizeram $N$ mergulhos. Outra informação importante é que a cada novo mergulho pelo menos a mesma distância do mergulho anterior era explorada, então se o comprimento da fita fosse de 10 metros e as anotações feitas fossem 3 e 8 metros, nessa ordem, os únicos cenários que realmente poderiam ter acontecido são:
* 3 metros no primeiro mergulho e 8 no segundo;
* 7 metros no primeiro mergulho e 8 no segundo.
Mas se os valores anotados foram 2 e 8, existem três possibilidades:
* 2 metros no primeiro mergulho e 8 no segundo;
* 2 metros no primeiro mergulho e 2 no segundo;
* 8 metros no primeiro mergulho e 8 no segundo.
Como pode ter ocorrido algum engano nas anotações, pode ser impossível reconstruir a sequência
original, não se preocupe, todos vão entender caso isso aconteça.
#### Entrada
A primeira linha contém dois inteiros $N$ e $M$, representando respectivamente a quantidade de mergulhos que o grupo fez e o comprimento em metros da fita que levaram para a exploração. A segunda linha contém $N$ inteiros $A_1, A_2, \ldots, A_N$ representando as medições feitas a cada mergulho, na ordem em que foram anotadas.
#### Saída
Seu programa deve produzir uma única linha, contendo apenas um inteiro, que representa a soma das distâncias exploradas. Caso exista mais de uma sequência possível, imprima a menor soma das sequencias possíveis. Se não existir nenhuma sequência compatível com os dados, imprima apenas o inteiro -1.
#### Restrições
* $1 \leq N \leq 10^4$
* $1 \leq M \leq 5 * 10^5$
* $0 \leq A_i \leq M$ |
3,306 | 245 | Fórmula 1 | Difícil | Tecnicas | A temporada de Fórmula 1 consiste de uma série de corridas, conhecidas como Grandes Prêmios, organizados pela Federação Internacional de Automobilismo (FIA). Os resultados de cada Grande Prêmio são combinados para determinar o Campeonato Mundial de Pilotos. Mais especificamente, a cada Grande Prêmio são distribuídos pontos para os pilotos, dependendo da classificação na corrida. Ao final da temporada, o piloto que tiver somado o maior número de pontos é declarado Campeão Mundial de Pilotos.
Os organizadores da Fórmula 1 mudam constantemente as regras da competição, com o objetivo de dar mais emoção às disputas. Uma regra modificada para a temporada de 2010 foi justamente a distribuição de pontos em cada Grande Prêmio. Desde 2003 a regra de pontuação premiava os oito primeiros colocados, obedecendo a seguinte tabela:
Ou seja, o piloto vencedor ganhava 10 pontos, o segundo colocado ganhava 8 pontos, e assim por diante.
Na temporada de 2010 os dez primeiros colocados receberão pontos, obedecendo a seguinte tabela:
A mudança no sistema de pontuação provocou muita especulação sobre qual teria sido o efeito nos Campeonatos Mundiais passados se a nova pontuação tivesse sido utilizada nas temporadas anteriores. Por exemplo, teria Lewis Hamilton sido campeão em 2008, já que a diferença de sua pontuação total para Felipe Massa foi de apenas um ponto? Para acabar com as especulações, a FIA contratou você para escrever um programa que, dados os resultados de cada corrida de uma temporada determine Campeão Mundial de Pilotos para sistemas de pontuações diferentes.
#### Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros $G$ e $P$ separados por um espaço em branco, indicando respectivamente o número de Grandes Prêmios e o número de pilotos. Os pilotos são identificados por inteiros de 1 a $P$. Cada uma das $G$ linhas seguintes indica o resultado de uma corrida, e contém $P$ inteiros separados por espaços em branco. Em cada linha, o i-ésimo número indica a ordem de chegada do piloto i na corrida (o primeiro número indica a ordem de chegada do piloto 1 naquela corrida, o segundo número indica a ordem de chegada do piloto 2 na corrida, e assim por diante). A linha seguinte contém um único número inteiro $S$ indicando o número de sistemas de pontuação , e após, cada uma das $S$ linhas seguintes contém a descrição de um sistema de pontuação. A descrição de um sistema de pontuação inicia com um inteiro $K$, indicando a última ordem de chegada que receberá pontos, seguido de um espaço em branco, seguido de $K$ inteiros $k_0, k_1, \ldots, k_{K-1}$ separados por espaços em branco, indicando os pontos a serem atribuídos (o primeiro inteiro indica os pontos do primeiro colocado, o segundo inteiro indica os pontos do segundo colocado, e assim por diante).
O último caso de teste é seguido por uma linha que contém apenas dois números zero separados por um espaço em branco.
#### Saída
Para cada caso de sistema de pontuação da entrada seu programa deve imprimir uma linha, que deve conter o identificador do Campeão Mundial de Pilotos. Se houver mais de um Campeão Mundial Pilotos (ou seja, se houver empate), a linha deve conter todos os Campeões Mundiais de Pilotos, em ordem crescente de identificador, separados por um espaço em branco.
#### Restrições
* $1 \leq G \leq 100$
* $1 \leq P \leq 100$
* $1 \leq S \leq 10$
* $1 \leq K \leq P$
* $1 \leq k_i \leq 100$
|
3,307 | 400 | Ordenação Simples | Fácil | Tecnicas | Faça um programa que leia 10 números inteiros como entrada e imprima duas linhas de saída, a primeira linha deve conter os 10 números em ordem crescente e a segunda linha deve conter os dez números em ordem decrescente.
#### Entrada
A entrada consiste de dez linhas, cada linha contém um número inteiro.
#### Saída
A saída consiste de duas linhas, a primeira linha contém os 10 inteiros lidos em ordem crescente separados por espaço e a segunda linha contém os 10 inteiros lidos em ordem decrescente separados por um espaço
#### Restrições
Os valores fornecidos não terão valor absoluto maior que 100.
|
3,308 | 165 | Escadinha | Médio | Tecnicas | Dizemos que uma sequência de números é uma escadinha, se a diferença entre números consecutivos é sempre a mesma. Por exemplo, “2, 3, 4, 5” e “10, 7, 4” são escadinhas. Note que qualquer sequência com apenas um ou dois números também é uma escadinha!
Neste problema estamos procurando escadinhas em uma sequência maior de números. Dada uma sequência de números, queremos determinar quantas escadinhas existem. Mas só estamos interessados em escadinhas tão longas quanto possível. Por isso, se uma escadinha é um pedaço de outra, consideramos somente a maior. Por exemplo, na sequência “1, 1, 1, 3, 5, 4, 8, 12” temos 4 escadinhas diferentes: “1, 1, 1”, “1, 3, 5”, “5, 4” e “4, 8, 12”.
#### Entrada
A primeira linha da entra contém um inteiro $N$ indicando o tamanho da sequência de números. A segunda linha contém $N$ inteiros definindo a sequência.
#### Saída
Imprima uma linha contendo um inteiro representando quantas escadinhas existem na sequência
#### Restrições
* $1 \leq N \leq 1000$
* O valor dos números da sequência está entre $-10^6$ e $10^6$ inclusive. |
3,309 | 287 | Eu Aprendi o MergeSort | Médio | Tecnicas | Nessa questão você deve implementar o algoritmo MergeSort, só para mostrar quem é que manda. Resista a tentação de usar funções prontas do <b>C++</b> como a <b>sort</b>, por exemplo.
Como você já aprendeu, o MergeSort serve para ordenar uma sequencia de dados, dessa forma, é exatamente isso que você irá fazer. Dada uma sequência de números inteiros, imprima os números ordenados em ordem descrescente.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando o número de elementos da sequência.
A segunda linha contém $N$ inteiros: os $N$ números da sequência
#### Saída
Seu programa deve gerar uma única linha: os $N$ números da entrada, em ordem descrescente.
#### Restrições
* $1 \leq N \leq 10^5$
* para cada número $a_i$ da sequência, temos $-10^9 \leq a_i \leq 10^9$
|
3,310 | 306 | Corredor | Médio | Tecnicas | Bruninho está programando um personagem virtual para o próximo desafio de um jogo de aventura em que, numa das fases, o personagem tem que entrar em um corredor, percorrer algumas salas e depois sair do corredor. Ele pode entrar apenas uma vez, e passar por cada sala apenas uma vez. Todas as salas possuem uma porta de entrada e uma de saída, como ilustra a parte (a) da figura abaixo. Ao passar por uma sala o jogador ganha um certo número de vidas (que pode ser negativo!). O objetivo é passar pelo corredor coletando a maior quantidade possível de vidas! Por sorte, sempre existe ao menos uma sala onde se ganha um número positivo de vidas.
No exemplo acima, o personagem de Bruninho pode ganhar, no máximo, 12 vidas, por exemplo, entrando pela sala 2 e saindo pela sala 4, como mostrado na parte (b) da figura. Nesta tarefa, você deve escrever um programa que, dados os números de vidas correspondentes a cada sala do corredor, calcule a quantidade máxima de vidas que será possível ganhar.
#### Entrada
A entrada é composta por duas linhas. A primeira linha contém um inteiro $N$, o número de salas no corredor. A segunda linha contém $N$ números inteiros, positivos ou negativos, indicando a quantidade de vidas que se ganha em cada sala.
#### Saída
Seu programa deve imprimir uma linha, com o número máximo de vidas que é possível ganhar.
#### Restrições
* $1 < N < 50000$; e o número de vidas nas salas está entre -100 e 100
#### Informações sobre a Pontuação
* Em um conjunto de casos de teste totalizando 30 pontos, $N < 1000$
|
3,311 | 1479 | Idade de Camila | Fácil | Tecnicas | Cibele, Camila e Celeste são três irmãs inseparáveis. Estão sempre juntas e adoram fazer esportes, ler, cozinhar, jogar no computador... Agora estão aprendendo a programar computadores para desenvolverem seus próprios jogos.
Mas nada disso interessa para esta tarefa: estamos interessados apenas nas suas idades. Sabemos que Cibele nasceu antes de Camila e Celeste nasceu depois de Camila.
Dados três números inteiros indicando as idades das irmãs, escreva um programa para determinar a idade de Camila.
#### Entrada
A entrada é composta por três linhas, cada linha contendo um número inteiro $N$, a idade de uma das irmãs.
#### Saída
Seu programa deve produzir uma única linha, contendo um único número inteiro, a idade de Camila.
#### Restrições
* $5 \leq N \leq 100$ |
3,312 | 60 | Sanduíche | Difícil | Tecnicas | Você está na Seletiva para a IOI e depois de um dia cansativo de provas, chegou a hora do jantar. Hoje, trouxeram um sanduíche muito longo cortado em N pedaços de diversos tamanhos diferentes. Você gostaria de comer uma quantidade total de sanduíche de comprimento $D$, porém há uma regra: para evitar bagunça, você só pode ou pegar uma sequência contínua de pedaços, ou pegar pedaços das extremidades. Você sabe a sequência $C_1, C_2, ..., C_N$ dos comprimentos dos pedaços na ordem em que estão posicionados no sanduíche. Agora, para otimizar o seu jantar, quer fazer um programa que com esses dados responda de quantas formas você pode escolher os pedaços do sanduíche que vai comer. Em outras palavras, deve contar quantos pares $(i, j)$, $1 \leq i \leq j \leq N$, existem tais que o somatório $C_i + C_{i+1} + ... + C_j$ seja igual a $D$ e quantos pares $(i, j)$, $1 \leq i < j \leq N$, existem tais que o somatório $C_1 + C_2 + ... + C_i + C_j + C_{j+1} + ... + C_N$ seja igual a $D$.
#### Entrada
A primeira linha contém dois inteiros $N$ e $D$, representando respectivamente o número de pedaços e a quantidade de sanduíche que você quer comer. A segunda linha contém $N$ inteiros $C_1, C_2, ..., C_N$, onde $C_i$ é o tamanho do i-ésimo pedaço
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número de maneiras de comer pedaços de sanduíche com soma $D$.
#### Restrições
* $2 \leq N \leq 1 \cdot 10^6$
* $2 \leq D \leq 1 \cdot 10^9$
* $1 \leq C_i \leq 10^3$
|
3,313 | 315 | Fila de 1's | Fácil | Tecnicas | Ana está estudando números binários na escola, enquanto ela brincava com eles notou que realmente gosta
muito dos números que são simplesmente uma fila de 1's, por exemplo:
$3_{10}$ = $11_{2}$
$7_{10}$ = $111_{2}$
$15_{10}$ = $1111_{2}$
Ajude Ana a saber se ela gosta de um dado número
#### Entrada
A entrada consiste em um inteiro $N$, a escrito na base 10
#### Saída
Imprima S, caso Ana goste do número e N caso contrário.
#### Restrições
* $0 \leq N \leq 10^{18}$
|
3,314 | 279 | Febre de Recursões | Difícil | Tecnicas | Zenzo é um aluno de matemática promissor e está encantado com a mais recente aula de recursões de seu professor. Ele está em busca de maneiras de aproximar recursões e, para isso, precisa da sua ajuda para calcular seus valores exatos, para poder comparar os resultados.
De maneira geral, uma recursão de ordem $n$ pode ser escrita na forma $f_k=\sum\limits_{i=1}^{n} a_i \cdot f_{k-i}$. Dados os valores de $n$, $k$ e $m$, bem como os valores de $a_1, a_2, ..., a_n$, descubra o valor de $f_k \ mod \ m$.
#### Entrada
A primeira linha da entrada contém três inteiros: $n$, $k$ e $m$. A segunda linha contém $n$ inteiros: $a_1, a_2, ..., a_n$. A terceira linha contém os $n$ valores base da recursão: $f_1, f_2,..., f_n$ ($mod \ m$).
#### Saida
Seu programa deve imprimir um único inteiro: o valor de $f_k \ mod \ m$.
#### Subtask 1 (20 pontos)
* $n=2$
* $1 \leq k \leq 10^3$
* $1 \leq m \leq 10^6$
* $-10^6 \leq a_1, a_2 \leq 10^6$
#### Subtask 2 (40 pontos)
* $1\le n\leq 10$
* $1 \leq k \leq 10$
* $1 \leq m \leq 10^6$
* $0 \leq a_i \leq 10^6 \ \forall i, \ 1\leq i \leq n$
#### Subtask 3 (40 pontos)
* $1\le n\leq 10^3$
* $1 \leq k \leq 10^3$
* $1 \leq m \leq 10^6$
* $0 \leq a_i \leq 10^6 \ \forall i, \ 1\leq i \leq n$
|
3,315 | 63 | Linhas Cruzadas | Médio | Tecnicas | Uma das atividades de recreação preferidas de Letícia é compor desenhos com linhas coloridas esticadas entre preguinhos numa base de madeira. Quanto mais cruzamentos entre pares de linhas, mais interessante fica a figura. Neste problema temos $N$ pregos na vertical e $N$ pregos na horizontal, como na figura abaixo. Os pregos na vertical possuem uma numeração fixa, de 1 a $N$, de baixo para cima. Os pregos na horizontal também são numerados de 1 a $N$, mas a ordem pode ser qualquer uma.
Letícia vai sempre esticar uma linha entre cada par de pregos que tiverem o mesmo número. Dada a ordem dos pregos horizontais, seu programa deve computar o número total de cruzamentos entre pares de linhas no desenho de Letícia. Por exemplo, os três desenhos da figura possuem, respectivamente, 0, 6 e 15 cruzamentos.
#### Entrada
A primeira linha da entrada contém um número natural $N$. A segunda linha contém $N$ números naturais distintos de 1 a $N$, representando a ordem dos pregos na horizontal.
#### Saida
Seu programa deve escrever uma linha na saída, contendo o número de cruzamentos entre pares de linhas, conforme a descrição anterior.
#### Restrições
* $2 \le N \le 60000$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 60 pontos, $N \leq 30000$
|
3,316 | 34 | Fase | Médio | Tecnicas | Em diversas competições acadêmicas, como a Olimpíada Brasileira de Informática (OBI), uma certa quantidade de competidores se classifica de uma fase para a fase seguinte, garantindo uma das vagas disponíveis. Entretanto, normalmente essa quantidade é variável, pois dada uma certa quantidade mínima de classificados, é frequente que haja empate na última vaga de classificação. Neste caso, é comum que todos os competidores empatados na última colocação se classifiquem.
Sua tarefa é ajuda a calcular o número de competidores classificados para a próxima fase. Você receberá uma lista de pontuações obtidas pelos competidores e o número mínimo de vagas para a fase seguinte e você deve decidir quantos competidores de fato vão se classificar.
#### Entrada
A primeira linha da entrada contém um número inteiro $N$, $1 \leq N \leq 1000$, representando o número de competidores. A segunda linha conterá um inteiro $K$, $1 \leq K \leq N$, indicando o número mínimo de competidores que devem se classificar para a próxima fase. Em seguida, $N$ linhas conterão, cada uma um número entre 1 e 1000, inclusive, correspondente à pontuação de um competidor.
#### Saída
Seu programa deve imprimir uma linha, contendo o número de classificados para a próxima fase.
|
3,317 | 209 | Elevador (OBI 2018) | Fácil | Tecnicas | Uma fábrica instalou um elevador composto de duas cabines ligadas por uma roldana, como na figura. Quando uma cabine sobe, a outra desce. No primeiro andar da fábrica existem algumas caixas de pesos diversos e precisamos levar todas as caixas para o segundo andar, usando o elevador. Apenas uma caixa pode ser colocada por vez dentro de uma cabine. Além disso, existe uma restrição de segurança importante: durante uma viagem do elevador, a diferença de peso entre as cabines pode ser no máximo de 8 unidades.
De forma mais rigorosa, $P - Q \leq 8$, onde $P$ é o peso da cabine mais pesada e $Q$, o peso da cabine mais leve. O gerente da fábrica não está preocupado com o número de viagens que o elevador vai fazer. Ele apenas precisa saber se é possível ou não levar todas as caixas para o segundo andar. No exemplo da figura, podemos levar todas as três caixas usando a seguinte sequência de seis viagens do elevador:
1. Sobe a caixa de peso 4, desce a outra cabine vazia; (diferença de 4)
2. Sobe a caixa de peso 10, desce a caixa de peso 4; (diferença de 6)
3. Sobe a caixa de peso 15, desce a caixa de peso 10; (diferença de 5)
4. Sobe a caixa de peso 4, desce a outra cabine vazia; (diferença de 4)
5. Sobe a caixa de peso 10, desce a caixa de peso 4; (diferença de 6)
6. Sobe a caixa de peso 4, desce a outra cabine vazia. (diferença de 4)
Dados os pesos de $N$ caixas no primeiro andar, seu programa deve dizer se é possível ou não levar todas as $N$ caixas para o segundo andar.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ indicando o número de caixas. A segunda linha da entrada contém $N$ inteiros representando os pesos das caixas.
#### Saída
Imprima uma linha na saída. A linha deve conter o caracter S caso seja possível, ou N caso não seja possível levar todas as caixas até o segundo andar da fábrica.
#### Restrições
* $1 \leq N \leq 10^4$
* O peso das caixas está entre 1 e $10^5$, inclusive |
3,318 | 362 | Batalha | Fácil | Tecnicas | Todo mundo está jogando um novo game de realidade aumentada no celular, com batalhas entre monstrinhos! Nas primeiras fases do jogo as batalhas são bem simples, mas ainda assim bastante divertidas. Dois jogadores vão escolher um monstrinho cada, na sua coleção de monstrinhos. Cada monstrinho tem um tipo de ataque e um tipo de defesa, que são identificados por números naturais.
A regra da batalha, que consiste em cada monstrinho usar seu respectivo ataque ao mesmo tempo, é que se o número da defesa de um monstrinho é igual ao número do ataque do seu oponente, então ele não sofre nenhum dano; caso contrário, se o número da defesa dele é diferente do ataque do oponente, então ele sofre dano total e desmaia!
Por exemplo, o monstrinho do primeiro jogador tem o ataque 21 e a defesa 7; enquanto que o monstrinho do segundo jogador tem o ataque 7 e a defesa 12. Nesse caso, o primeiro jogador vence, pois não desmaiou, enquanto que o segundo jogador desmaiou.
Assim, o resultado da batalha, que seu programa deve determinar, pode ser:
* Jogador 1 vence: se o jogador 1 não desmaia e o jogador 2 desmaia;
* Jogador 2 vence: se o jogador 2 não desmaia e o jogador 1 desmaia;
* Empate: em qualquer caso contrário; quer dizer, os dois desmaiam, ou nenhum desmaia
#### Entrada
A primeira linha da entrada contém um inteiro $A_1$ indicando o ataque do primeiro jogador. A segunda linha contém um inteiro $D_1$ indicando a defesa do primeiro jogador. A terceira linha contém um inteiro $A_2$ representando o ataque do segundo jogador. A quarta, e última linha, contém um inteiro $D_2$ representando a defesa do segundo jogador.
#### Saída
Imprima uma linha contendo um inteiro, 1 ou 2, indicando qual jogador ganhou a batalha. Se a batalha resultou em empate, imprima -1.
#### Restrições
* $1 \leq A_1 \leq 100$
* $1 \leq D_1 \leq 100$
* $1 \leq A_2 \leq 100$
* $1 \leq D_2 \leq 100$
|
3,319 | 464 | Sequência Secreta | Fácil | Tecnicas |
Na calçada em frente ao Palácio Imperial, não se sabe a razão, existe uma sequência de N números desenhados no chão. A sequência tem a seguinte forma: ela começa e termina com o número 1; apenas os números 1 e 2 aparecem nela; e o número 2 aparece pelo menos uma vez. Veja um exemplo na coluna (a) da figura ao lado.
Ninguém sabe o significado da sequência e, justamente por isso, várias teorias malucas surgiram. Uma delas diz que a sequência representa, na verdade, apenas um valor que estaria relacionado a um segredo dos imperadores. Esse valor é a quantidade máxima de números da sequência que poderiam ser marcados com um círculo, de modo que a sequência de números marcados não contenha dois números iguais consecutivos.
A coluna (b) da figura ao lado ilustra uma sequência de 4 números marcados que obedece a restrição acima. Só que é possível marcar 7 números, como mostra a coluna (c) da figura.
Neste problema, dada a sequência original de números desenhados no chão da calçada, seu programa deve computar e imprimir a quantidade máxima de números da sequência que poderiam ser marcados com um círculo sem que haja dois números iguais consecutivos na sequência marcada.
#### Entrada
A primeira linha da entrada contém um inteiro N representando o tamanho da sequência. As N linhas seguintes contêm, cada uma, um inteiro Vi, para $1 \leq i \leq N$, definindo a sequência de números desenhados no chão da calçada imperial.
#### Saída
Seu programa deve imprimir uma linha contendo um número inteiro representando a quantidade máxima de números da sequência que poderiam ser marcados com um círculo sem que haja dois números iguais consecutivos na sequência marcada.
#### Restrições
* $3 \leq N \leq 500$
* $V_i$ é igual a 1 ou 2, para $1 \leq i \leq N$ |
3,320 | 71 | O Banco Inteligente | Difícil | Tecnicas | Caixas automáticos nos bancos são uma invenção ótima mas, às vezes, a gente precisa de dinheiro trocado e a máquina entrega notas de 100,00 reais. Outras vezes, a gente quer sacar um valor um pouco maior e por questões de segurança gostaria de receber tudo em notas de 100,00 reais, mas a máquina entrega um monte de notas de 20,00 reais. O Banco Inteligente está tentando minimizar esse problema dando aos clientes a possibilidade de escolher o valor das notas na hora do saque. Para isso, eles precisam da sua ajuda para saber, dado o valor S do saque e quantas notas de cada valor a máquina tem, quantas formas distintas existem de entregar o valor S. O banco disponibiliza notas de 2, 5, 10, 20, 50 e 100.
Por exemplo, se $S = 22$ e o número de notas de cada valor é $N_2 = 5$, $N_5 = 4$, $N_{10} = 3$, $N_{20} = 10$, $N_{50} = 0$ e $N_{100} = 10$, então há 4 formas distintas da máquina entregar o valor do saque: 20 + 2, 10 + 10 + 2, 10 + 5 + 5 + 2 e 5 + 5 + 5 + 5 + 2.
#### Entrada
A primeira linha da entrada contém um inteiro $S$, o valor do saque. A segunda linha contém seis inteiros $N_2$, $N_5$, $N_{10}$, $N_{20}$, $N_{50}$ e $N_{100}$, respectivamente, o número de notas de valores 2, 5, 10, 20, 50 e 100, disponíveis na máquina.
#### Saída
Seu programa deve imprimir um inteiro, o número de formas distintas da máquina entregar o saque.
#### Restrições
* $0 \leq S \leq 5000$
* $0 \leq N_i \leq 500$ |
3,321 | 291 | Pedido de Desculpas | Médio | Tecnicas | Cuca saiu para jogar futebol com os amigos e esqueceu do encontro que tinha com a namorada. Ciente da mancada, Cuca deseja elaborar um pedido especial de desculpas. Resolveu então enviar flores e usar o cartão da floricultura para escrever um pedido especial de desculpas.
Cuca buscou na internet um conjunto de frases bonitas contendo a palavra 'desculpe' (que pode ocorrer mais de uma vez na mesma frase). No entanto, o cartão da floricultura é pequeno, e nem todas as frases que Cuca colecionou poderão ser aproveitadas.
Cuca quer aproveitar o espaço do cartão, onde cabe um número limitado de caracteres, para escrever um sub-conjunto das frases coletadas de modo que apareça o máximo de vezes possível a palavra 'desculpe'.
Escreva um programa que, dados o número de caracteres que cabem no cartão e a quantidade de frases coletadas (com os respectivos comprimentos e os números de ocorrências da palavra 'desculpe'), determine o número máximo de vezes que a palavra aparece, utilizando apenas as frases colecionadas, sem repetí-las
#### Entrada
A entrada é constituída de vários casos de teste. A primeira linha de um caso de teste contém dois números inteiros $C$ e $F$ indicando respectivamente o comprimento do cartão em caracteres e o número de frases coletadas. Cada uma das $F$ linhas seguintes descreve uma frase coletada. A descrição é composta por dois inteiros $N$ e $D$ que indicam respectivamente o número de caracteres na frase e quantas vezes a palavra 'desculpe' ocorre na frase. O final da entrada é indicado por $C$ = $F$ = 0.
#### Saída
Para cada caso de teste seu programa deve produzir três linhas na saída. A primeira identifica o conjunto de teste no formato "Teste n", onde $n$ é numerado a partir de 1. A segunda linha deve conter o máximo número de vezes que a palavra 'desculpe' pode aparecer no cartão, considerando que apenas frases coletadas podem ser utilizadas, e cada frase não é utilizada mais de uma vez. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $8 \leq C \leq 1000$ ($C = 0$ apenas para indicar o fim da entrada)
* $1 \leq F \leq 50$ ($S = 0$ apenas para indicar o fim da entrada)
* $8 \leq N \leq 200$
* $1 \leq D \leq 25$
|
3,322 | 281 | Em Busca do Corpo Perfeito | Médio | Tecnicas | Kakariús é um jovem físico que busca equilíbrio de corpo e mente. Quando não está resolvendo grandes paradigmas da física moderna, gosta de cuidar da sua saúde. Ele é um grande fã de academias, e faz de tudo para aumentar ainda mais seus músculos. Todos sabemos, é claro, que academia não vale nada se não estiver acompanhada de uma dieta condizente com os objetivos que queremos alcançar.
Procurando ficar grandão, Kakariús precisa do máximo possível de proteínas e, por isso, vai almoçar em um rodízio de carnes. Nesse rodízio, existem $N$ pedaços de carne, cada um com um determinado peso e valor proteico, que é a quantidade de gramas de proteína no pedaço. Ele adoraria comer toda a comida, mas como sabemos, tudo em excesso faz mal, e ele sabe que suporta apenas $P$ gramas da carne.
Os valores proteicos dos pedaços variam muito (podem ser até zero se for apenas gordura) e é uma terrível falta de educação pedir um pedaço e não comê-lo todo. Dados o valor de $P$ e os $N$ pedaços, com seus respectivos pesos e valores proteicos, determine a maior quantidade de gramas de proteína que Kakariús consegue ingerir, comendo apenas pedaços inteiros.
#### Entrada
A primeira linha da entrada contêm dois inteiros, $P$ e $N$, com ($1 \le P , N \le 2000$) que representam, respectivamente, quantos gramas de carne Kakariús consegue comer e a quantidade de pedaços no rodízio. As próximas $N$ linhas representam os pedaços e contêm, cada uma, dois inteiros menores que $10^9$. O primeiro é o peso, em gramas, do pedaço, e o segundo é o seu valor proteico.
#### Saida
O seu programa deve imprimir um valor inteiro que determina a maior quantidade de gramas de proteína que Kakariús consegue ingerir, seguido de uma quebra de linha.
|
3,323 | 61 | Letras | Médio | Tecnicas | Uma cadeia de caracteres é uma sequência de letras do alfabeto. Uma cadeia de caracteres crescente é uma sequência de letras onde a próxima letra (da esquerda para a direita) nunca ocorre antes no alfabeto do que a letra anterior. Por exemplo ABBD é crescente, enquanto ABBAD não é crescente.
Uma subsequência de uma cadeia de caracteres é uma cadeia de caracteres que pode ser obtida a partir da remoção de zero ou mais caracteres da cadeia de caracteres original. Por exemplo ANNA é uma subsequência de BANANAS. Outro exemplo seria ANNS, que é uma subsequência crescente de BANANAS.
Dada uma cadeia de caracteres S, escreva um programa para determinar o tamanho da maior subsequência de $S$ que é uma cadeia de caracteres crescente.
#### Entrada
A entrada consiste em uma única linha, contendo uma cadeia de caracteres $S$.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o tamanho da maior subsequência de $S$ que é uma cadeia de caracteres crescente.
#### Restrições
* A cadeia de caracteres de entrada contém letras maiúsculas do alfabeto, de A até Z.
* $1 \leq$ comprimento($S$) $\leq 3 * 10^5$ |
3,324 | 365 | Troca | Difícil | Tecnicas | Um cientista especializado em bioinformática está estudando formas de simular alguns fenômenos, que ocorrem dentro das células, relacionados ao funcionamento de proteínas. Parece muito complicado, não? Só que o problema computacional básico que ele precisa resolver eficientemente é fácil de entender. Existe uma sequência de $N$ cartas, indexadas de 1 a $N$, e cada carta contém dois números impressos, um de cada lado. As cartas são colocadas na mesa, na sequência, com um dos lados virado para cima. Dados dois inteiros $i$ e $j$, com $i \leq j$, a operação <b>troca(i, j)</b> consiste em virar todas as cartas da posição $i$ até a posição $j$, inclusive. Por exemplo, considere a sequência de cartas abaixo.
A operação de **troca(5, 11)** resultaria na seguinte sequência de cartas:
O problema do cientista é que a sequência de cartas pode ser muito grande e podem ser feitas muitas operações de troca. Ele precisa saber a sequência dos números que estarão virados para cima ao final de todas as operações. Você pode ajudá-lo?
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $T$, indicando respectivamente a quantidade de cartas e a quantidade de operações de troca. A segunda linha contém $N$ inteiros, indicando os números virados para cima inicialmente. A terceira linha contém $N$ números, indicando os virados para baixo inicialmente. As $T$ linhas seguintes contém, cada uma, dois inteiros $I$ e $J$, indicando os limites de uma operação de troca.
#### Saída
Imprima uma linha contendo $N$ inteiros representando os números que estarão virados para cima após todas as operações.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq T \leq 10^5$
* $1 \leq I \leq J \leq N$
* O valor dos elementos dos vetores está entre $0$ e $10^9$, inclusive.
#### Informações sobre a pontuação
* Para um conjunto de casos de teste valendo 10 pontos, $I = J$ para todas as operações;
* Para um conjunto de casos de teste valendo 20 pontos, $N \leq 10^4$ e $T \leq 10^4$. |
3,325 | 16 | Segredo do Cofre | Difícil | Tecnicas | O sistema de segredo para abrir esse cofre é bastante complexo. Ao invés de girar um botão várias vezes, como a gente vê normalmente nos filmes, o dono do cofre tem que deslizar um controle para a esquerda e para a direita, em cima de uma barra, várias vezes, parando em determinadas posições. A barra possui $N$ posições e cada posição contém um número inteiro entre 0 e 9, inclusive. No exemplo da figura, a barra tem 14 posições e o controle está na posição 1.
O segredo vai depender de quantas vezes cada um dos dez inteiros entre 0 e 9 vai aparecer dentro do controle. Por exemplo, suponha que o dono deslize o controle da posição inicial 1 até a posição 9, depois para a posição 4, depois para a posição 11 e por fim até a posição 13. Veja que o inteiro 1, por exemplo, vai aparecer seis vezes dentro do controle; e o inteiro 9 vai aparecer quatro vezes. Dada a sequência de inteiros na barra e a sequência de posições entre as quais o dono desliza o controle, começando da posição inicial 1, seu programa deve contar quantas vezes cada inteiro, entre 0 e 9, vai aparecer dentro do controle.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$, representando o número de posições na barra do cofre e o número de posições na sequência que o dono vai seguir para deslizar o controle. A segunda linha contém $N$ inteiros entre 0 e 9, definindo a barra do cofre. A terceira linha contém $M$ inteiros representando a sequência de posições que o dono vai seguir. A primeira posição nessa sequência é sempre 1 e não há duas posições consecutivas iguais.
#### Saída
Seu programa deve imprimir uma linha contendo 10 inteiros, representando o número de vezes que cada inteiro, entre 0 e 9, vai aparecer no controle da barra.
#### Restrições
* $2 \leq N \leq 10^5$
* $2 \leq M \leq 10^5$
#### Informações sobre Pontuação
* Em um conjunto de testes somando 40 pontos, $N \leq 1000$ e $M \leq 1000$
|
3,326 | 262 | Maior Ancestral Comum | Médio | Tecnicas | Há muitos anos, cientistas usam da genética para estudar a evolução das espécies. Dr. Mustavo está estudando uma nova teoria evolutiva. Nela, a evolução ocorre quando um novo gene é inserido no DNA de uma espécie. Deste modo, a sequência genética $(1,3,7,5)$ é uma evolução da sequência $(1,3,5)$, em que o $7$ foi o gene inserido entre os genes $3$ e $5$. Ainda mais, $(2,1,3,7,5)$ é uma evolução de $(1,3,7,5)$.
Para testar sua teoria, Dr. Mustavo precisa analisar ancestrais comuns entre duas espécies distintas. Para isso, ele precisa descobrir qual a maior sequência genética que pode representar o DNA de um ancestral comum a duas espécies e analisar o grau de semelhança entre o ancestral e os descendentes. Ao analisar, por exemplo, as espécies $(1, 7, 2, 5, 2)$ e $(3, 7, 1, 5, 2, 2)$ a maior sequência genética possível para um ancestral comum das duas tem tamanho $3$, podendo ser $(1,2,2)$ ou $(1,5,2)$, por exemplo. No caso $(1,2,2)$, este pode ser ancestral da primeira sequência através da seguinte ordem evolutiva: $(1,2,2), (1,7,2,2), (1,7,2,5,2)$, e da segunda através da ordem $(1,2,2), (3,1,2,2), (3,7,1,2,2), (3,7,1,2,5,2)$.
O que realmente interessa a Mustavo é a distância entre as espécies e seus ancestrais. Essa distância é medida pelo número de evoluções que a espécie teve que fazer para chegar em uma determinada outra. Note, por exemplo, que a distância de $(1,2,2)$ para $(3, 7, 1, 5, 2, 2)$ são 3 evoluções. Dadas duas sequências de DNA, diga a distância de cada uma delas para o maior ancestral comum possível das duas. Note que se duas sequências não têm ancestral comum, as distâncias são seus próprios tamanhos, pois consideraremos a sequência vazia como o ancestral.
#### Entrada
A primeira linha da entrada tem dois inteiros $N$ e $M$ ($1\le N,M \leq 1000)$, o tamanho de cada uma das duas sequências. A segunda linha contêm $N$ inteiros: os genes da primeira sequência genética e a terceira contêm outros $M$ inteiros: os genes da segunda sequência. Cada gene é um número entre $0$ e $100$, inclusive.
#### Saida
Seu programa deve imprimir dois inteiros: as distâncias genéticas da primeira e da segunda sequencia para o ancestral comum delas, respectivamente.
|
3,327 | 6 | Arco e flecha | Difícil | Tecnicas | O comitê olímpico está testando uma nova forma de pontuar as competições de arco e flecha, baseada em penalidades. O atleta vai atirar $N$ flechas no alvo, em sequência. A penalidade da K-ésima flecha atirada é computada imediatamente após ela atingir o alvo, antes do próximo lançamento, e é igual ao número de flechas que estão no alvo naquele momento cuja distância ao centro do alvo é menor ou igual à distância da K-ésima flecha ao centro, excluindo a própria K-ésima flecha. Quer dizer, a penalidade é o número das $K - 1$ flechas lançadas antes da K-ésima flecha que estão mais próximas ou à mesma distância do centro do alvo, comparadas com a K-ésima flecha. A penalidade total é a soma das penalidades das $N$ flechas.
Ganha o atleta que tiver a menor penalidade total ao final. Veja que a penalidade total pode ser zero, se o atleta for bom o bastante para acertar numa sequência estritamente decrescente de distâncias ao centro do alvo.
Neste problema, o centro do alvo está na origem (0, 0). Dada a sequência de coordenadas dos pontos em que as sucessivas flechas atingiram o alvo, seu programa deve computar a penalidade total final do atleta.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando a quantidade de flechas lançadas. Cada uma das $N$ linhas seguintes contém dois inteiros, $X$ e $Y$ , indicando as coordenadas do ponto em que cada flecha atingiu o alvo, definindo a sequência de lançamentos.
#### Saída
Imprima uma linha contendo um inteiro representando a penalidade total do atleta.
#### Restrições
* $1 \leq N \leq 10^5$
* $-10^6 \leq X$, $Y \leq 10^6$
|
3,328 | 975 | Três por Dois | Nível Desconhecido | Tecnicas | Uma loja de chocolates está fazendo uma promoção do tipo "leve três pague dois". Mais precisamente, você pode escolher quaisquer três chocolates da loja e paga apenas pelos dois mais caros que escolher, levando o mais barato gratuitamente. Se você levar mais do que três chocolates, você pode agrupá-los em grupos de três e levar o chocolate mais barato de cada grupo gratuitamente.
Por exemplo, se você escolher chocolates de preços (em reais) 8, 5, 10, 2, 5, 10 e 4, você pode agrupá-los como (8,5,10), (2,5,10) e (4), pagará um total de (10+8) + (10+5) + 4, ou seja, 37 reais. Mas você pode agrupá-los de uma forma melhor e assim conseguir pagar menos. Você consegue ver como?
Dados os preços dos chocolates escolhidos, escreva um programa para determinar o menor preço a pagar.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de chocolates escolhidos. Cada uma das $N$ linhas seguintes contém um número inteiro $P$, o preço de um chocolate escolhido.
#### Saída
Seu programa deve produzir uma única linha, contendo um único número inteiro, o menor preço a pagar pelos chocolates escolhidos.
#### Restrições
* $1 \leq N \leq 100000$
* $1 \leq P \leq 1000$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 50 pontos, $N \leq 1000$. |
3,329 | 546 | Lista de Chamada | Fácil | Tecnicas | Tia Joana é uma respeitada professora e tem vários alunos. Em sua última aula, ela prometeu que iria sortear um aluno para ganhar um bônus especial na nota final: ela colocou $N$ pedaços de papel numerados de 1 a $N$ em um saquinho e sorteou um determinado número $K$; o aluno premiado foi o $K$-ésimo aluno na lista de chamada.
O problema é que a Tia Joana esqueceu o diário de classe, então ela não tem como saber qual número corresponde a qual aluno. Ela sabe os nomes de todos os alunos, e que os números deles, de 1 até $N$, são atribuídos de acordo com a ordem alfabética, mas os alunos dela estão muito ansiosos e querem logo saber quem foi o vencedor.
Dado os nomes dos alunos da Tia Joana e o número sorteado, determine o nome do aluno que deve receber o bônus.
#### Entrada
A primeira linha contém dois inteiros $N$ e $K$ separados por um espaço em branco ($1 \leq K \leq N \leq 100$). Cada uma das $N$ linhas seguintes contém uma cadeia de caracteres de tamanho mínimo 1 e máximo 20 representando os nomes dos alunos. Os nomes são compostos apenas por letras minúsculas de ‘a’ a ‘z’.
#### Saída
Seu programa deve imprimir uma única linha, contendo o nome do aluno que deve receber o bônus.
#### Informações sobre a pontuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 3$. |
3,330 | 373 | Bolas | Fácil | Tecnicas | Temos oito bolas, colocadas lado a lado em uma sequência. Cada bola tem um número impresso, que pode ter valor de 0 até 9. Queremos trocar algumas bolas de posição na sequência de modo que nenhum par de bolas vizinhas na sequência tenha o mesmo número. Quer dizer, não pode haver duas bolas, uma ao lado da outra, com o mesmo número. A figura ao lado mostra um exemplo para o qual isso foi possível. Mas será que sempre é possível? Seu programa deve decidir se é ou não possível obter uma sequência em que não haja bolas vizinhas com o mesmo número.
#### Entrada
A única linha da entrada contém uma sequência de oito inteiros $B_i$, para $1 \leq i \leq 8$, representando os números impressos em cada bola da sequência.
#### Saída
Imprima uma linha contendo o caractere “S” se for possível trocar bolas de posição e obter a sequência sem bolas vizinhas com o mesmo número; ou o caractere “N” se não for possível.
#### Restrições
* $B_i$ é um inteiro entre 0 e 9, inclusive.
|
3,331 | 367 | Recibo de Compra | Médio | Tecnicas | Flavinho acabou de chegar do supermercado com $K$ produtos na sacola, mas perdeu o recibo da compra. Ele está tentando lembrar dos preços de cada um dos produtos e precisa da sua ajuda. Por enquanto ele consegue se lembrar das seguintes informações:
* O valor total da compra foi de $R$ reais;
* Os valores dos produtos eram números inteiros distintos.
Por exemplo, se $R = 12$ e $K = 3$, temos as seguintes possíveis combinações de preços para os três produtos: $\{1, 2, 9\}, \{1, 3, 8\}, \{1, 4, 7\}, \{1, 5, 6\}, \{2, 3, 7\}, \{2, 4, 6\}$ ou $\{3, 4, 5\}$.
Seu programa deve computar a quantidade de possíveis combinações de preços para os $K$ produtos.
#### Entrada
A primeira linha da entrada contém dois inteiros $R$ e $K$, indicando respectivamente o valor total do recibo e o número de produtos comprados.
#### Saída
Imprima uma linha contendo um inteiro representando a quantidade de possíveis combinações de preços para os $K$ produtos.
#### Restrições
* $1 \leq R \leq 100$
* $1 \leq K \leq 20$
#### Informações sobre a pontuação
* Para um conjunto de casos de teste valendo 10 pontos, $R \leq 6$
* Para um conjunto de casos de teste valendo 20 pontos, $R \leq 16$
|
3,332 | 308 | Véi, Dá Meu Troco! | Médio | Tecnicas | "Ô mano, cadê meu troco?"
"Desculpe-me senhor, mas não é possível. Não existem moedas que formem seu troco. O senhor aceita balinhas?"
"Que bala o quê, maluco?! Véi, dá meu troco!"
E aí, dá pra dar o troco?
#### Entrada
A primeira linha da entrada contém dois inteiros: $N$ e $M$: o número de tipos de moedas que existem e o valor do troco desejado. A segunda linha contém $N$ inteiros: os valores de cada um dos tipos de moeda
#### Saída
Seu programa deve gerar um único carctere: 'S', se for possível formar o troco com as moedas dadas, ou 'N', caso contrário.
#### Restrições
* $1 \leq N,M \leq 1000$
* Os valores das moedas são inteiros menores que $10^9$
|
3,333 | 205 | Cápsulas | Difícil | Tecnicas | O discípulo Fan Chi’ih retornou recentemente da China com algumas cápsulas mágicas, que são capazes de produzir moedas de ouro! Uma cápsula possui um certo ciclo de produção, que é um número $C$ de dias. A cada $C$ dias a cápsula produz uma nova moeda; a moeda é sempre produzida no último dia do ciclo. Fan Chi’ih vai ativar todas as cápsulas ao mesmo tempo e quer acumular uma fortuna de pelo menos $F$ moedas. Ele precisa da sua ajuda para computar o número mínimo de dias para que as cápsulas produzam, no total, pelo menos $F$ moedas. Na tabela abaixo, por exemplo, existem três cápsulas com ciclos de 3, 7 e 2 dias. Se Fan Chi’ih quiser acumular pelo menos 12 moedas, ele vai ter que esperar pelo menos 14 dias.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $F$, indicando o número de cápsulas e o número de moedas que Fan Chi’ih quer produzir, respectivamente. A segunda linha contém $N$ inteiros $C_i$, para $1 \leq i \leq N$, representando os ciclos de cada cápsula.
#### Saída
Imprima um inteiro, representando o número mínimo de dias para que as cápsulas produzam, no total, pelo menos $F$ moedas.
#### Restrições
* $1 \leq N \leq 10^5$; $1 \leq F \leq 10^9$
* $1 \leq C_i \leq 10^6$
* Em todos os casos de teste, a resposta é sempre menor ou igual a $10^8$ dias;
* Em todos os casos de teste, o número de moedas produzido, no total, após $10^8$ dias, é sempre menor ou igual a $10^9$.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, os ciclos $C_i$ são todos iguais (ou seja $C_i = C_j$ para todo $1 \leq i \leq N$ e $1 \leq j \leq N$).
* Para um conjunto de casos de testes valendo 20 pontos, $N \leq 10^3$, $F \leq 10^3$ e $C_i \leq 10^3$. |
3,334 | 391 | Fechadura | Médio | Tecnicas | Joãozinho estava um dia chegando em casa quando percebeu que havia perdido a chave da porta. Desesperado, ele resolveu pedir ajuda a seu amigo Roberto, que em poucos segundos conseguiu abrir a porta usando suas ferramentas.
Admirado com a velocidade em que seu amigo conseguiu abrir a porta de sua casa sem a chave, ele decidiu perguntar como ele tinha conseguido aquilo. Roberto explicou que a fechadura da casa de Joãozinho é baseada em um sistema de pinos de tamanhos diferentes que, uma vez alinhados na mesma altura $M$, possibilitam a abertura da porta.
Uma fechadura é um conjunto de N pinos dispostos horizontalmente que podem ser movimentados para cima ou para baixo com o auxílio de uma chave de metal que, ao ser inserida dentro da fechadura, pode aumentar ou diminuir em 1mm, simultaneamente, a altura de quaisquer dois pinos consecutivos.
Joãozinho como um exemplar perfeccionista decidiu desbloquear sua fechadura na menor quantidade de movimentos, onde cada movimento consiste em escolher dois pinos consecutivos da fechadura e aumentar ou diminuir a altura dos dois pinos em 1mm. Após todos os pinos possuírem altura exatamente igual a $M$, a fechadura é desbloqueada.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$ representando, respectivamente, a quantidade de pinos da fechadura e a altura em que eles devem ficar para a fechadura ser desbloqueada.
A segunda linha da entrada contém $N$ inteiros, representando as alturas dos pinos da fechadura.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando a quantidade mínima de movimentos para desbloquear a fechadura.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq M \leq 100$
* Cada altura dos pinos está entre 1 e 100.
* É garantido que os casos de testes sempre possuem uma solução.
|
3,335 | 267 | Maior Subsequência Quase Crescente | Médio | Tecnicas | Dada uma sequência, descubra o tamanho de sua maior subsequência não decrescente. O tamanho da maior sequência não decrescente de $(3,1,1,5,2,6)$, por exemplo é $4$ ($(1,1,5,6)$ ou $(1,1,2,6)$).
#### Entrada
A primeira linha da entrada contém um inteiro $N$ ($1\le N \le 1000$): o número de elementos na sequência. A segunda linha da entrada contém os $N$ elementos, todos inteiros compreendidos entre $0$ e $10^9$.
#### Saída
Seu programa deve gerar um único inteiro: comprimento da maior subsequência não decrescente da sequência dada na entrada. |
3,336 | 64 | Arquivos | Médio | Tecnicas | Aldo tem $N$ arquivos em seu computador, cada um com um tamanho em bytes. Ele quer dividir estes arquivos em pastas, porém o sistema do computador é velho e só aceita pastas com as duas seguintes limitações:
* Uma pasta pode ter no máximo dois arquivos
* A soma dos tamanhos dos arquivos na pasta não pode exceder $B$ bytes
Como ele tem muitos arquivos ele prefere não criar muitas pastas. Dado o tamanho dos arquivos, calcule o número mínimo possível de pastas.
Vamos supor um exemplo que temos os arquivos de tamanho 1, 2 e 3, e que o limite de bytes seja 3. A solução é colocar os dois primeiros arquivos juntos, totalizando apenas 2 pastas.
#### Entrada
A entrada consiste de duas linhas. A primeira linha contém os números inteiros $N$ e $B$. A segunda linha contém $N$ inteiros indicando o tamanho de cada arquivo.
#### Saída
Seu programa deve escrever uma única linha na saída, contendo um único número inteiro, a quantidade mínima possível de pastas.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq B \leq 10^9$
* Os arquivos terão tamanho entre 1 e $B$, inclusive
|
3,337 | 468 | Soma (OBI 2019) | Difícil | Tecnicas |
Temos uma sequência de $N$ quadrados desenhados lado a lado. Cada quadrado possui um número natural anotado dentro dele. Dados a sequência dos $N$ quadrados e um valor $K$, quantos retângulos distintos existem cuja soma dos números dentro do retângulo é exatamente igual a $K$? Por exemplo, a figura mostra uma sequência de $N = 10$ quadrados para a qual existem 5 retângulos cuja soma dos números é igual a $K = 4$.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $K$ representando o número de quadrados na sequência e o valor da soma desejada. A segunda linha da entrada contém $N$ números naturais $X_i$ , para $1 \leq i \leq N$, indicando a sequência de números anotados dentro dos quadrados.
#### Saída
Seu programa deve imprimir uma linha contendo um número inteiro representando quantos retângulos existem na sequência cuja soma é igual a $K$.
#### Restrições
* $1 \leq N \leq 500000 (5 * 10^5)$
* $0 \leq K \leq 10^6$
* $0 \leq X_i \leq 100$ para $1 \leq i \leq N$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 10 pontos, $N \leq 500$.
* Em um conjunto de casos de teste somando 20 pontos, $N \leq 10^4$.
* Em um conjunto de casos de teste somando 30 pontos, $K > 0$ e $X_i > 0$ para $1 \leq i \leq N$.
* Em um conjunto de casos de teste somando 40 pontos, nenhuma restrição adicional (note que para esta subtarefa o inteiro da saída pode não caber em 32 bits.) |
3,338 | 524 | Soma das Casas | Médio | Tecnicas | Joãozinho mora em uma rua que tem $N$ casas. Marquinhos é o melhor amigo dele, mas sempre gosta de pregar peças em Joãozinho. Desta vez, ele pegou os dois brinquedos prediletos de Joãozinho e os escondeu em duas casas distintas da rua. Em compensação, Marquinhos deu uma dica importante para Joãozinho:
*A soma dos números das casas em que escondi teus brinquedos é igual a $K$. Além disso, escolhi as casas de tal forma que não existe outro par de casas cuja soma tenha esse mesmo valor.*
Sabendo disto, encontre qual é o par de casas em que se encontram os brinquedos de Joãozinho. Para auxiliar seu amigo, Marquinhos entregou a Joãozinho uma lista com o número das casas já em ordem crescente (isto é, do menor para o maior número).
#### Entrada
A primeira primeira linha da entrada contém um número inteiro $N$, que representa o número de casas que existem na rua. Cada uma das $N$ linhas seguintes contém um número inteiro, representando o número de uma casa. Note que esses $N$ números estão ordenados, do menor para o maior. A última linha da entrada contém um inteiro $K$, que é a soma dos números das duas casas onde os brinquedos estão escondidos.
#### Saída
Seu programa deve imprimir uma única linha, contendo dois inteiros, $A$ e $B$, $A < B$, que representam os números das casas em que estão escondidos os brinquedos. Os dois números devem ser separados por um espaço em branco.
#### Restrições
* $2 \leq N \leq 10^5$
* Para cada casa $C_i$, $0 \leq Ci \leq 10^9$, $i = 1, 2, \ldots, N$
* Os números das casas estão em ordem crescente, do menor para o maior número, e casas distintas têm números distintos.
#### Informações sobre a pontuação
* Em um conjunto de casos que totaliza 30 pontos, $N \leq 10^3$ |
3,339 | 1021 | Fotografia | Médio | Tecnicas | Chegou o final do ano, e os alunos resolveram dar um presente para a profa. Vilma: um quadro com a fotografia dos alunos classe. João está pesquisando os preços de molduras em um site da internet, e precisa de sua ajuda. Ele quer encontrar uma moldura tal que
* a fotografia seja inteiramente contida dentro na moldura; e
* a área da moldura que a fotografia não ocupa seja a menor possível; e
* uma moldura pode ser rotacionada para acomodar a fotografia, mas a fotografia deve ser acomodada de forma que seus lados sejam paralelos aos lados da moldura.
Dada as dimensões da fotografia e das molduras disponíveis, escreva um programa para ajudar João a escolher a melhor moldura, segundo os critérios acima.
#### Entrada
A primeira linha da entrada contém dois inteiros $A$ e $L$ indicando respectivamente a altura e largura da fotografia, em centímetros. A segunda linha da entrada contém um inteiro $N$, a quantidade de molduras disponíveis. As molduras são identificadas por números de 1 a $N$. Cada uma das $N$ linhas seguintes contém dois inteiros $X_i$ e $Y_i$ indicando as dimensões em centímetros da moldura de número $i$, para $1\ \leq\ i\ \leq\ N$.
#### Saída
Seu programa deve produzir uma única linha na saída, contendo um único número inteiro, o identificador da melhor moldura de acordo com os critérios acima. Se houver mais de uma moldura que satisfaz os critérios, o programa deve produzir o menor identificador entre as molduras que satisfazem os critérios. Se nenhuma moldura satisfaz os critérios, a linha deve conter −1.
#### Restrições
* $1\ \leq\ A\ \leq\ 100$
* $1\ \leq\ L\ \leq\ 100$
* $1\ \leq\ N\ \leq\ 100$
* $1\ \leq\ X_i\ \leq\ 200$ para $1\ \leq\ i\ \leq\ N$
* $1\ \leq\ Y_i\ \leq\ 200$ para $1\ \leq\ i\ \leq N$
* não há duas molduras com as mesmas dimensões |
3,340 | 565 | Pares de Números | Fácil | Tecnicas | Temos um vetor de $N$ inteiros distintos e dois inteiros $I$ e $F$. Precisamos computar quantos pares desses inteiros do vetor somam pelo menos $I$ e no máximo $F$.
Por exemplo, se o vetor for [45, 12, 11, 7, 83, 29, 5] e $I = 19$ e $F = 52$, temos exatamente 8 pares cuja soma está entre 19 e 52: {5, 29}, {5, 45}, {7, 12}, {7, 29}, {7, 45}, {11, 12}, {11, 29} e {12, 29}.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $I$ e $F$, indicando respectivamente o tamanho do vetor e o valor mínimo da soma e o valor máximo da soma.
#### Saída
Seu programa deve imprimir uma única linha contendo um inteiro indicando quantos pares de inteiros no vetor somam pelo menos $I$ e no máximo $F$.
#### Restrições
* $2 \leq N \leq 1000$
* $-2000 \leq I, F \leq 2000$
* O valor de cada inteiro no vetor está entre -1000 e 1000
* Os inteiros no vetor são distintos |
3,341 | 466 | Distância Entre Amigos | Difícil | Tecnicas | Ao longo da rua existem N prédios de largura igual, mas com número de andares diferentes. Quase toda a turma do colégio mora em algum apartamento desses prédios e eles resolveram definir a distância entre dois apartamentos quaisquer da rua para saber, ao final, qual par de colegas da turma mora mais longe um do outro.
Funciona assim: para um colega A visitar um colega B, que mora num prédio diferente, ele deve descer a andares até o térreo do seu prédio; depois andar para a esquerda ou direita, dependendo do lado para o qual seu colega mora, por $p$ prédios; depois subir $b$ andares até o apartamento do colega B. A distância entre A e B, então, será $a+p+b$. A figura mostra um exemplo, para N = 14, onde estão marcados dois andares de prédios diferentes para os quais a distância é 12.
Dado um número de andares de cada prédio ao longo da rua, seu programa deve computar a distância máxima possível entre dois apartamentos quaisquer na rua.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ representando o número de prédios na rua. A segunda linha contém $N$ inteiros $A_i$, $1 \leq i \leq N$, representando o número de andares de cada prédio, sem contar o térreo. Quer dizer, por exemplo, se $A_i = 19$, então quem mora no último andar precisa descer 19 andares até o térreo. Veja a figura, que corresponde ao primeiro exemplo de entrada abaixo.
#### Saída
Seu programa deve imprimir uma linha contendo um número inteiro representando a distância máxima possível entre dois apartamentos na rua.
#### Restrições
* $2 \leq N \leq 200000(2 * 10^5)$
* $1 \leq A_i \leq 10^9$ para todo $1 \leq i \leq N$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 25 pontos, $N \leq 10^4$ e $A_i \leq 10^4$
* Em um conjunto de casos de teste somando 25 pontos, $A_i \leq 100$
* Em um conjunto de casos de teste somando 50 pontos, nenhuma restrição adicional
|
3,342 | 314 | Mano, tu me dá esse troco com menos de dez moedas! | Médio | Tecnicas | "Mano, é claro que dá pra me dar esse troco!"
"Senhor, eu realmente não vejo como."
"É tão óbvio! Mano, tu me dá esse troco com menos de dez moedas!"
E aí, dá pra dar o troco com menos de 10 moedas?
#### Entrada
A primeira linha da entrada contém dois inteiros: $N$ e $M$: o número de tipos de moedas que existem e o valor do troco desejado, respectivamente.
A segunda linha contém N inteiros: os valores de cada um dos tipos de moeda
#### Saída
Seu programa deve gerar um único carctere: 'S', se for possível formar o troco com menos de dez das moedas dadas, ou 'N', caso contrário.
#### Restrições
* $1 \leq N,M \leq 1000$
* Os valores das moedas são inteiros menores que $10^4$
|
3,343 | 370 | Muro | Médio | Tecnicas | Nós temos dois tipos de tijolos, como mostrado na parte esquerda da figura abaixo. A ideia é construir uma mureta de altura 2 e comprimento $N$. A parte direita da figura ilustra uma forma de usar os dois tipos de tijolos para construir uma mureta de comprimento $N = 12$.
Precisamos saber quantas formas distintas existem de construir a mureta com esses dois tipos de tijolos. Para isso, já temos duas observações: qualquer mureta de comprimento $N$ vai terminar de uma das sete maneiras ilustradas abaixo e; o número de formas distintas de construir uma mureta de comprimento 2, 1 e 0 é, respectivamente, 5, 1 e 1 (Sim! Existe uma forma de construir a mureta de comprimento 0: usar nenhum tijolo).
Dado $N$, seu programa deve computar o número de formas distintas de construir uma mureta de comprimento $N$. Como esse número pode ser muito grande, seu programa deve imprimir o resto da divisão dele por $10^9 + 7$.
#### Entrada
A única linha da entrada contém um inteiro $N$, representando o comprimento da mureta.
#### Saída
Imprima uma linha contendo um inteiro, o número de formas distintas de construir a mureta com os dois tipos de tijolos. Imprima o resto da divisão desse número por $10^9 + 7$.
#### Restrições
* $0 \leq N \leq 10^4$
#### Informações sobre a pontuação
* Para um conjunto de casos de teste valendo 20 pontos, $N \leq 16$.
|
3,344 | 366 | Pulo do Gato (PJ) | Médio | Tecnicas | O gato Obinho gosta de brincar no pátio do colégio, no qual há uma sequência de $C$ lajotas, que podem ser brancas ou pretas. Obinho está na lajota inicial da sequência (a mais à esquerda), e quer ir pulando até a lajota final da sequência (a mais à direita). Mas ele só gosta de pular de uma lajota preta para outra lajota preta, nunca pisando numa lajota branca. Além disso, ele não consegue pular muito longe. A parte esquerda da figura mostra as lajotas que o Obinho pode alcançar com um pulo: uma distância máxima de duas lajotas.
Obinho quer chegar na lajota final com o número mínimo de pulos possível. Por exemplo, na parte direita da figura, para $C = 14$, o menor número de pulos possível é 8. Seu programa deve computar o número mínimo de pulos para o Obinho chegar na lajota final.
#### Entrada
A primeira linha da entrada contém um inteiro $C$, representando o número de lajotas do pátio. A segunda linha contém $C$ inteiros indicando a cor das lajotas, da inicial (mais à esquerda) à final (mais à direita): o valor 1 indica uma lajota preta, o valor 0 indica uma lajota branca.
#### Saída
Imprima uma linha contendo o número mínimo de pulos que o gato Obinho precisa dar para ir da lajota inicial até a lajota final. Se não for possível pular até a lajota final, imprima -1.
#### Restrições
* $1 \leq C \leq 10^4$;
* As lajotas inicial e final são sempre pretas.
#### Informações sobre a pontuação
* Para um conjunto de casos de teste valendo 10 pontos, todas as lajotas são pretas;
* Para um conjunto de casos de teste valendo 20 pontos, $C \leq 1000$. |
3,345 | 1724 | Cálculo rápido | Fácil | Tecnicas | Algumas pessoas conseguem fazer cálculos matemáticos com uma velocidade impressionante. Laurinha tem essa habilidade! Um cálculo que ela consegue fazer muito rapidamente é, dados três números inteiros $S$, $A$, e $B$, determinar quantos números do intervalo $[A, B]$ têm a soma de seus dígitos igual a $S$.
Por exemplo, se $S = 3$, $A = 10$ e $B = 30$, então a reposta é 3, pois existem três números no intervalo $[10, 30]$ cuja soma dos dígitos é igual a três: 12, 21 e 30.
Sua tarefa é escrever um programa de computador para, dados os três números, tentar calcular a resposta mais rapidamente do que Laurinha consegue.
#### Entrada
A primeira linha da entrada contém um número inteiro $S$, o valor da soma dos dígitos. A segunda e a terceira linhas contêm respectivamente os inteiros $A$ e $B$.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, quantos números no intervalo dado têm a soma de dígitos indicada.
#### Restrições
* $1 ≤ S ≤ 36$
* $1 ≤ A ≤ 10000$
* $1 ≤ B ≤ 10000$
* $A ≤ B$
|
3,346 | 892 | Escher | Fácil | Tecnicas |
M. C. Escher foi um artista gráfico holandês que fazia incríveis ilustrações onde preenchia a tela com objetos auto-similares, cujos contornos encaixam neles próprios, criando simetrias geométricas muito impressionantes. Veja um exemplo dessa ideia na figura, que mostra um objeto que é um perfil ortogonal definido por uma sequência de números naturais representando a sequência de alturas. Podemos pegar uma cópia do objeto, rotacionar 180 graus e encaixar perfeitamente no objeto original, formando um retângulo.
Em termos mais gerais, se uma sequência de N números naturais representando a sequência de alturas for $A_1, A_2, A_3, \ldots , A_{N-2}, A_{N-1}, A_N$ , o perfil definido será chamado de perfil Escher se tivermos $A_1 + A_N$ igual a $A_2 + A_{N-1}$ igual a $A_3 + A_{N-2}$, e assim por diante. Neste problema, será dada a sequência de alturas que definem o perfil e seu programa deve decidir se o perfil é Escher, ou não.
#### Entrada
A primeira linha da entrada contém um número $N$, indicando quantos números tem a sequência. A segunda linha da entrada contém $N$ números naturais, $A_i$, para $1 \leq i \leq N$, definindo a sequência de alturas do perfil.
#### Saída
Seu programa deve imprimir uma linha contendo o caractere $S$, se o perfil for Escher; ou $N$, senão.
#### Restrições
* $3 \leq N \leq 10000$.
* $1 \leq A_i \leq 1000$, para todo $1 \leq i \leq N$.
#### Informações sobre a pontuação
• Em um conjunto de casos de teste somando 20 pontos, $N=3$.
• Em um conjunto de casos de teste somando 80 pontos, nenhuma restrição adicional. |
3,347 | 285 | Bolhas e Baldes | Difícil | Tecnicas | Andrea, Carlos e Marcelo são muito amigos e passam todos os finais de semana à beira da piscina. Enquanto Andrea se bronzeia ao sol, os dois ficam jogando Bolhas. Andrea, uma cientista da computação muito esperta, já disse a eles que não entende por que passam tanto tempo jogando um jogo tão primário.
Usando o computador portátil dela, os dois geram um inteiro aleatório N e uma seqüência de inteiros, também aleatória, que é uma permutação de $1, 2, \ldots,N$.
O jogo então começa, cada jogador faz um movimento, e a jogada passa para o outro jogador. Marcelo é sempre o primeiro a começar a jogar. Um movimento de um jogador consiste na escolha de um par de elementos consecutivos da seqüência que estejam fora de ordem e em inverter a ordem dos dois elementos. Por exemplo, dada a seqüência 1, 5, 3, 4, 2, o jogador pode inverter as posições de 5 e 3 ou de 4 e 2, mas não pode inverter as posições de 3 e 4, nem de 5 e 2. Continuando com o exemplo, se o jogador decide inverter as posições de 5 e 3 então a nova seqüência será 1, 3, 5, 4, 2.
Mais cedo ou mais tarde, a seqüência ficará ordenada. Perde o jogador impossibilitado de fazer um movimento. Andrea, com algum desdém, sempre diz que seria mais simples jogar cara ou coroa, com o mesmo efeito. Sua missão, caso decida aceitá-la, é determinar quem ganha o jogo, dada a seqüência inicial.
#### Entrada
A entrada contém vários casos de teste. Os dados de cada caso de teste estão numa única linha, e são inteiros separados por um espaço em branco. Cada linha contém um inteiro $N$, seguido da seqüência inicial $P$ = ($X_1, X_2, \ldots,X_N$) de $N$ inteiros distintos dois a dois.
O final da entrada é indicado por uma linha que contém apenas o número zero.
#### Saída
Para cada caso de teste da entrada seu programa deve imprimir uma única linha, com o nome do vencedor, igual a "Carlos" ou "Marcelo".
#### Restrições
* 2 $\leq$ $N$ $\leq$ $10^5$
* 1 $\leq$ $X_i$ $\leq$ $N$. para 1 $\leq$ $i$ $\leq$ $N$
|
3,348 | 39 | Bits | Difícil | Tecnicas | Duas sequências de $N$ bits são distintas se, para alguma posição $i$, $1 \leq i \leq N$, o bit na posição $i$ de uma sequência é distinto do bit na posição $i$ da outra sequência. As duas sequências de $N=10$ bits abaixo são distintas pois, por exemplo, os bits na posição 7, da esquerda para a direita, são distintos:
Mas veja que as duas sequências acima, apesar de distintas, têm uma característica em comum: não há três bits 1 consecutivos nelas. Neste problema, dado o número de bits $N$ e um $K$, seu programa deve computar quantas sequências distintas de $N$ bits existem, nas quais não há $K$ bits 1 consecutivos.
#### Entrada
A entrada consiste de uma linha contendo os dois inteiros $N$ e $K$.
#### Saída
Imprima uma linha contendo um inteiro, representando o número de sequências distintas de $N$ bits,nas quais não há $K$ bits 1 consecutivos. Porque esse número pode ser muito grande, você deveimprimir o resto da divisão dele por $10^9 + 7$.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq K \leq N + 1$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 20 pontos, $N \leq 20$
|
3,349 | 299 | Pizza | Difícil | Tecnicas | Rodrigo pediu uma pizza de mussarela de <i>N</i> fatias, uma parte somente com cebola e o resto somente com azeitonas. Entretanto, ao receber a pizza em casa, notou que o motoqueiro que a entregou não foi cuidadoso o suficiente, pois tanto as tiras de cebola quanto as azeitonas estavam espalhadas por toda a pizza. Para piorar, como a pizza era de mussarela, as tiras de cebola e as azeitonas estavam grudadas na pizza.
Como gosta mais de cebola do que de azeitona, Rodrigo deseja pegar fatias consecutivas da pizza de tal forma que estas contenham a maior diferença possível entre tiras de cebola e azeitonas. Para isso, ele contou quantas tiras e quantas azeitonas tinham em cada fatia e subtraiu os dois valores, nessa ordem. Assim, sempre que uma fatia contiver mais cebolas que azeitonas, ela recebe um número positivo, e caso contrário, um número negativo. Uma fatia cujo número seja zero contém o mesmo número de tiras de cebolas e azeitonas.
Por exemplo, supondo que as fatias contenham as seguintes diferenças: 5,-3,-3, 2,-1, 3, pode-se pegar uma fatia consecutiva com 9 cebolas a mais que azeitonas, utilizando as fatias com as diferenças 2,-1, 3, 5 (lembre-se de que estamos tratando de um círculo e, portanto, a fatia com diferença 5 é vizinha da fatia com diferença 3 e vice-versa).
Como Rodrigo não entende de programação, ele resolveu contar com seus serviços. _OBS_: repare que é melhor não escolher nenhuma fatia caso somente seja possível escolher fatias consecutivas com mais azeitonas que cebolas.
Escreva um programa que, dados as diferenças entre as quantidades de cebolas e azeitonas em cada fatia de pizza, retorne a maior quantidade possível de cebolas que Rodrigo pode comer a mais do que a quantidade de azeitonas utilizando somente fatias consecutivas de pizza. (lembrando que a primeira fatia é adjacente à última e vice-versa).
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do <i>dispositivo de entrada padrão</i> (normalmente o teclado). A primeira linha da entrada contém um inteiro $N$ que indica o número de fatias de pizza ($1 < N < 10^5$). A segunda linha contém $N$ inteiros $K$ ($-100 < K < 100$) separados por um espaço em branco com as diferenças entre as quantidades de cebolas e de azeitonas.
#### Saída
Seu programa deve imprimir, na <i>saída padrão</i>, uma única linha, contendo a maior quantidade de cebolas que Rodrigo pode comer a mais do que azeitonas.
|
3,350 | 390 | PacMan | Médio | Tecnicas | Pacman é um jogo muito conhecido, onde o personagem tenta comer a maior quantidade possível de bolinhas, tendo ao mesmo tempo que fugir de vários fantasmas. Dessa vez, nosso personagem quer carregar a comida coletada para casa, mas o encontro com um fantasma, ao invés de terminar o jogo, faz com que toda a comida coletada seja roubada.
Neste problema os fantasmas não se movem, e o jogador sempre faz o Pacman percorrer o seguinte caminho:
1. O Pacman começa no canto superior esquerdo do tabuleiro.
2. O Pacman percorre toda a linha, da esquerda para direita, até chegar ao lado direito do tabuleiro.
3. O jogador desce uma posição, e percorre toda a linha, desta vez da direita para a esquerda.
4. As etapas 2 e 3 se repetem até que todo o tabuleiro tenha sido percorrido.
Infelizmente, Pacman não pode ignorar os comandos do usuário para fugir dos fantasmas ou pegar mais comida, mas ele pode, a qualquer momento, se aproveitar de um bug de implementação e interromper o jogo, levando consigo toda a comida que estiver carregando.
Você deve escrever um programa que determine a maior quantidade de comida que o Pacman pode levar, se escolher a melhor hora possível para sair. Note que o jogador também tem a opção de não sair antes do final do jogo.
#### Entrada
A primeira linha contém um inteiro $N$, o tamanho do tabuleiro do jogo, que é quadrado. Cada uma das $N$ linhas seguintes contém $N$ caracteres, que podem ser (aspas para melhor clareza):
* ‘.’ um espaço vazio;
* ‘o’ uma comida;
* ‘A’ um fantasma.
#### Saída
Seu programa deve produzir uma única linha contendo um único inteiro, a quantidade máxima de comida que o Pacman pode levar para casa.
#### Restrições
* $2 \leq N \leq 100$
* Não há um fantasma e uma comida na mesma posição.
* Não há fantasma nem comida na posição inicial do Pacman (ou seja, o primeiro caractere da primeira linha do tabuleiro é ‘.’). |
3,351 | 166 | Pirâmide | Difícil | Tecnicas | No depósito da fábrica, encostada numa parede, existe uma matriz de $N$ linhas por $N$ colunas de caixas empilhadas. Cada caixa possui um peso inteiro positivo associado. O inspetor da fábrica precisa retirar algumas caixas da matriz de modo a deixar uma espécie de pirâmide de caixas satisfazendo as seguintes restrições:
* Se uma caixa está na pirâmide, a caixa imediatamente abaixo dela também deve estar na pirâmide;
* Na i-ésima linha de caixas (a linha 1 é a do topo da matriz), a pirâmide deve ter exatamente $i$ caixas consecutivas.
Dados os pesos de todas as caixas na matriz, seu programa deve calcular o peso total mínimo que uma pirâmide poderá ter, se o inspetor retirar algumas caixas segundo as restrições acima.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, indicando a dimensão da matriz. As $N$ linhas seguintes contêm, cada uma, $N$ inteiros representando os pesos das caixas em cada linha da matriz de caixas.
#### Saída
Seu programa deve produzir uma única linha, contendo um inteiro, indicando o peso total mínimo que a pirâmide poderá ter.
#### Restrições
* $1 \leq N \leq 100$
* Os valor dos elementos da matriz está entre 1 e 100, inclusive.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 20 pontos, $N \leq 20$. |
3,352 | 320 | Bingo | Médio | Tecnicas |
Albert, Charles e Mary inventaram uma nova versão do clássico jogo de Bingo. Na versão tradicional, o jogo é presidido por um não-jogador conhecido como caller. No começo de cada partida, cada jogador recebe uma carta contendo uma única combinação de números de 0 até $N$ dispostos em colunas e linhas. O caller opera um globo contendo $N$+1 bolas numeradas de 0 até $N$. Em cada turno, o caller sorteia uma bola do globo, anuncia o número sorteado aos jogadores e não a coloca novamente no globo. Cada jogador procura pelo número em sua carta e o marca caso o encontre. O primeiro jogador que marcar um padrão pré-definido completo em sua carta (uma linha horizontal, por exemplo) ganha um prêmio.
Na versão Albert-Charles-Mary, em cada turno, o caller sorteia uma primeira bola, coloca-a de volta no globo, sorteia uma segunda bola, coloca-a de volta no globo, e então anuncia a diferença absoluta entre os números das duas bolas. Para aumentar o entusiasmo, antes do início da partida, um subconjunto possivelmente vazio de bolas é retirado do globo, de forma que ao menos duas bolas permaneçam no globo. Eles gostariam de saber se cada número de 0 até $N$ podem ainda ser anunciados utilizando a nova regra de sorteio e considerando apenas as bolas que permaneceram dentro do globo.
#### Entrada
Cada caso de teste é dado em exatamente duas linhas. A primeira linha contém dois inteiros $N$ e $B$. O significado de $N$ foi descrito acima, enquanto $B$ representa o número de bolas que permaneceram no globo. A segunda linha contém $B$ inteiros distintos $b_i$, indicando as bolas que permaneceram no globo.
O último caso de teste é seguido por uma linha contendo dois zeros.
#### Saída
Para cada caso de teste, imprima uma única linha contendo um único caractere 'Y' se for possível anunciar todos os números de 0 até $N$, inclusive, ou um único caractere 'N' caso contrário.
#### Restrições
* $1 \leq N \leq 90$
* $2 \leq B \leq N+1$
* $0 \leq b_i \leq N$$ |
3,353 | 509 | Troco | Médio | Tecnicas | Você está num supermercado e está na fila do caixa para comprar alguns produtos. Assim que você termina de passar as compras pelo caixa, se lembra que tem várias moedas em seu bolso, algumas repetidas, e fica pensando se com elas dá para pagar exatamente o valor das compras (para assim se livrar destas moedas e ficar com os bolsos mais leves). Você consegue pagar o valor exato da conta usando estas moedas?
#### Entrada
A primeira linha da entrada contém dois números inteiros $V$ e $M$, indicando, respectivamente, o valor final da compra e o número de moedas que você tem em seu bolso. A segunda linha contém $M$ números inteiros que descrevem o valor $M_i$ de cada moeda existente em seu bolso.
#### Saída
Seu programa deve imprimir apenas uma linha, contendo apenas um caractere: 'S' caso seja possível pagar o valor exato da conta usando apenas suas moedas, ou 'N' caso contrário
#### Restrições
* $1 \leq V \leq 10^5$
* $1 \leq M \leq 10^3$
* $1 \leq M_i \leq 10^5$
#### Informações sobre a pontuação
* Para um conjunto de entradas que vale 70 pontos, $M \leq 20$ |
3,354 | 313 | Isso aqui é que não dá! | Difícil | Tecnicas | "Véi, dá pra me dar o troco sim!"
"Perdão, mas conforme essa discussão se prolonga, tenho mais certeza de que não é possível"
"Olha, aprende! Isso esse aqui é o maior valor, menor que o troco, que não dá!"
E aí, dá pra mostrar esse maior valor que não dá?
#### Entrada
A primeira linha da entrada contém dois inteiros: $N$ e $M$: o número de tipos de moedas que existem e o valor do troco desejado, respectivamente.
A segunda linha contém $N$ inteiros: os valores de cada um dos tipos de moeda
#### Saída
Seu programa deve gerar um único inteiro: a quantidade de valores inteiros e positivos menores que $M$ que não podem ser formados por um conjunto de moedas
#### Restrições
* $1 \leq N,M \leq 1000$
* Os valores das moedas são inteiros menores que $10^4$
|
3,355 | 443 | Hora da Corrida | Fácil | Tecnicas | Vinicius leva muito a sério seu condicionamento físico e, diariamente às 6h da manhã, chova ou faça sol, no verão e no inverno, ele corre no entorno de uma lagoa. Ao longo da pista de corrida existem N placas igualmente espaçadas. Para não desanimar do exercício, Vinicius conta o número de placas pelas quais ele já passou e verifica se ele já correu pelo menos 10%, pelo menos 20%, ... , pelo menos 90% do percurso.
Vamos ajudar o Vinicius, calculando para ele o número de placas que ele precisa contar para ter completado pelo menos 10%, 20%, ... , 90% da corrida, dados o número de voltas que ele pretende correr e o número total de placas ao longo da pista.
Por exemplo, suponhamos que Vinicius queira dar 3 voltas e o número de placas seja 17. Então, para garantir ter corrido pelo menos 30% do percurso, ele precisa contar 16 placas. Para garantir pelo menos 60%, ele precisa contar 31 placas.
#### Entrada
A entrada consiste de uma única linha que contém dois inteiros, $V$ e $N$ ($1 \leq V, N \leq 10^4$), onde $V$ é o número pretendido de voltas e $N$ é o número de placas na pista.
#### Saída
Seu programa deve produzir uma única linha com nove inteiros representando os números de placas que devem ser contadas para garantir o cumprimento, respectivamente, de 10%, 20%, ... , 90% da meta. |
3,356 | 474 | Ponto do Meio | Médio | Tecnicas | Paulo foi contratado por uma companhia de mapas digitais para implementar melhorias em seus mapas. Seu primeiro trabalho na empresa é implementar o algoritmo denominado deslocamento do ponto do meio. Não vamos descrever aqui o algoritmo completo, vamos focar apenas num aspecto importante para Paulo, que está preocupado em otimizar o uso de memória em sua implementação do algoritmo. O algoritmo funciona em passos. Inicialmente, quatro pontos do mapa são selecionados, formando um quadrado. Então a cada passo, para cada quadrado, faça:
* adicione quatro novos pontos, um ponto em cada lado do quadrado, exatamente no meio do lado.
* adicione também mais um novo ponto, exatamente no meio do quadrado.
O algoritmo utiliza os pontos criados para calcular e armazenar valores do mapa, mas Paulo está interessado apenas no número de pontos criados pelo algoritmo. Na figura abaixo, pontos brancos representam pontos adicionados no passo corrente, pontos pretos representam pontos adicionados em passos anteriores.
Paulo notou que o algoritmo gera muitos pontos, e muitos pontos pertencem a mais de um quadrado.
Para economizar memória, Paulo planeja calcular e armazenar cada ponto apenas uma vez. Sua tarefa, dado o número de passos que Paulo planeja executar, é determinar a quantidade de pontos únicos que Paulo necessita calcular e armazenar.
#### Entrada
A entrada consiste de uma única linha que contém um inteiro $N$, o número de passos.
#### Saída
Seu programa deve produzir uma única linha, com apenas um número inteiro, a quantidade de pontos únicos que Paulo deve calcular e armazenar em $N$ passos.
#### Restrições
* $1 \leq N \leq 50$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, $N \leq 3$.
* Para um conjunto de casos de testes valendo outros 40 pontos, $4 \leq N \leq 10$. |
3,357 | 1725 | Lista palíndroma | Difícil | Tecnicas | Uma palavra é chamada de palíndromo se a primeira letra da palavra é igual à última letra da palavra, a segunda letra é igual à penúltima letra, a terceira letra é igual à antepenúltima letra, e assim por diante. Por exemplo, as palavras _osso_ e _sopapos_ são palíndromos.
Nesta tarefa estamos interessados não em palavras, mas em listas de números inteiros. Nesse caso, vamos definir que uma lista é palíndroma se $L[i] = L[N - i + 1]$, onde $L[i]$ representa o $i$-ésimo elemento da lista (note que nesta notação o índices variam de 1 a $N$).
Você pode modificar uma lista usando a operação de _contração_, que é definida da seguinte forma: escolha dois elementos adjacentes da lista e substitua os dois elementos por um único elemento de valor igual à soma dos elementos substituídos. Note que ao efetuar uma operação de contração o número de elementos da lista decresce de um elemento.
Dada uma lista de números inteiros, você deve escrever um programa para determinar o menor número de operações de contração que devem ser realizadas de modo que a lista resultante seja palíndroma.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de elementos da lista. A segunda linha contém $N$ inteiros $L_i$, os elementos da lista.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o menor número de operações de contração necessárias para tornar a lista palíndroma.
#### Restrições
* $1 ≤ N ≤ 10^6$
* $1 ≤ Li ≤ 10^9$, para $1 ≤ i ≤ N$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 30 pontos, $N ≤ 10$.
* Para um conjunto de casos de testes valendo outros 30 pontos $N ≤ 10^3$.
* Para um conjunto de casos de testes valendo outros 40 pontos, nenhuma restrição adicional.
|
3,358 | 74 | Caixinha de Palitos | Médio | Tecnicas | A caixinha contém $N$ palitos de picolé, que precisam ser divididos entre os amigos Renato, Gustavo e Bruno, para um trabalho escolar. Cada amigo deve ganhar pelo menos 1 (um) palito. O professor vai determinar um número $M$ máximo de palitos que cada um pode ganhar.
Nesta tarefa, dados $N$ e $M$, seu programa deve calcular quantas maneiras distintas existem de se dividir todos os $N$ palitos entre os três amigos. Por exemplo, para $N = 100$: se $M = 15$, então há zero maneiras de se dividir, pois a soma dos números de palitos de Renato, Gustavo e Bruno seria no máximo 45, só que precisa ser sempre $N$; mas se $M = 34$, aí veja que haveria 6 maneiras distintas:
#### Entrada
A entrada é composta por apenas uma linha com dois números naturais $N$ e $M$, indicando, respectivamente, o número de palitos na caixinha e o número máximo que cada amigo pode ganhar.
#### Saída
Seu programa deve escrever uma única linha na saída, contendo um único número natural: quantas maneiras distintas existem de se dividir os $N$ palitos entre os três amigos.
#### Restrições
* $3 \leq N \leq 100000$
* $1 \leq M \leq N$
|
3,359 | 682 | Divisão de Terras | Difícil | Tecnicas | Rafael mora no distante reino da Nlândia, o qual é comandado pelo temido rei Leafar. O reino da Nlândia é representado por um mapa similar ao plano cartesiano, que contém apenas números inteiros indicando sua distância em km para a origem. O castelo de Leafar marca a posição origem, [0, 0].
Rafael é um suserano muito rico, e possui $N$ terras retangulares no reino da Nlândia. Cada uma de suas terras podem ser representadas por dois pontos no mapa da Nlândia.
Como pagamento de impostos, o suserano Rafael terá que doar no mínimo $K$ km² em terras para o rei. A seguinte condição foi imposta ao suserano: Você traçará uma reta horizontal em uma posição do mapa, e tal reta dividirá as suas terras de modo que toda extensão de terra que esteja ao sul desta reta seja doada ao rei.
Rafael não quer perder mais extensão de terra do que o necessário, sendo assim, ele pediu ajuda a você, o seu servo mais fiel. Dada a quantidade de terras de Rafael e as suas representações no mapa, diga a ele qual a posição em que a reta deverá ser traçada, de modo que a extensão de terra ao sul da reta seja mínima porém satisfaça o rei.
Observação: Nunca haverão terras se sobrepondo.
#### Entrada
Haverá uma linha contendo dois inteiros $N$ e $K$, representando respectivamente a quantidade de terras pertencentes a Rafael e a extensão de terra mínima que deverá ser doada ao rei.
Em seguida, haverá $N$ linhas representando as terras de Rafael. Cada linha contém quatro inteiros $Xa$, $Ya$, $Xb$ e $Yb$ cada, representando os pontos que definem as terras de Rafael, sendo [$Xa$, $Ya$] o ponto inferior-esquerdo, e [$Xb$, $Yb$] o ponto superior-direito.
#### Saída
A saída deve conter a menor posição da reta que satisfaça o rei. Caso esta posição não exista, a saída deve conter a frase “PERDAO MEU REI”.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq K \leq 10^9$
* $-10^9 \leq Xa, Ya, Xb, Yb \leq 10^9$
* $Xa \leq Xb$
* $Ya \leq Yb$
#### Restrições adicionais
* $1 \leq N \leq 100$, e
* $-100 \leq Xa, Ya, Xb, Yb \leq 100$, para 25% dos casos de teste.
#### Explicação do caso teste
**No primeiro exemplo**, ao traçar a linha horizontalmente na posição 1, a terra 1 terá 2km² de terra em baixo da linha e a terra 3 terá 1km². Totalizando 3km², o suficiente para o rei. |
3,360 | 764 | Rank do Nepscord | Médio | Tecnicas |
O Nepscord é um aplicativo maravilhoso, onde você pode conversar por canais de texto com outros estudantes da comunidade do Neps Academy. No Nepscord você pode discutir soluções de problemas, implementação de algoritmos interessantes, pedir ajuda a _experts_ caso tenha dificuldade com algum exercício de programação e ainda fazer ótimos amigos!
Recentemente, o administrador do Nepscord adicionou um robô para medir quais são os usuários mais ativos do aplicativo, sendo que são mais ativos aqueles usuários com maior número de mensagens válidas enviadas.
São consideradas mensagens válidas apenas aquelas enviadas com um intervalo maior ou igual a $K$ minutos desde a última mensagem creditada enviada, ou seja, após uma mensagem considerada válida ser creditada no minuto $M$, mensagens enviadas em minutos menores que $M+K$ não são creditadas.
O robô também utiliza um sistema de níveis para contar a atividade do usuário. Cada mensagem válida enviada equivale a 25 XP (unidade de medida para pontos), e ao atingir 100 XP o usuário sobe um nível, sendo que cada usuário começa no nível 1. Com base em seu registro, o robô do Nepscord classifica os usuários em um ranque, onde no topo estão os usuários com mais XP.
A partir do momento em que entra no aplicativo, o robô começa a registrar as mensagens que são enviadas nos canais de texto, coletando o nome de usuário único $U$ de quem enviou a mensagem e o minuto $M$ em que a mensagem foi enviada (considerando que o momento em que robô começou a operar como o minuto 0).
Dado o registro de mensagens do robô, contendo $N$ mensagens ordenadas crescentemente por minuto em que foram enviadas, faça o ranqueamento de usuários do Nepscord. No topo do ranque deverão estar os usuários com mais XP. Utilize como critério de desempate a ordem lexicográfica (ordem alfabética) dos nomes dos usuários.
#### Entrada
A primeira linha contém dois inteiros $N$ e $K$, respectivamente, o número de mensagens e o intervalo para que uma mensagem seja válida. As $N$ linhas seguintes descrevem, cada uma, uma mensagem, que contém um nome de usuário $U$ composto apenas por letras minúsculas e um inteiro $M$ indicando o minuto em que a mensagem foi enviada.
#### Saída
A saída começa com uma linha contendo "--Rank do Nepscord--". A seguir seguem 3 linhas, indicando os três usuários no topo do ranque e seus respectivos níveis. Caso não haja usuários o suficiente para preencher todas as posições, imprima-as em branco, sem espaço após ponto.
#### Restrições
* $1 \leq N \leq 10^{3}$
* $0 \leq M \leq 10^{5}$
* $1 \leq K \leq 10^{3}$
* $1 \leq |U| \leq 25$ |
3,361 | 810 | Altos e Baixos | Médio | Tecnicas | Farcos gosta muito de chocolate, e nestes últimos $N$ dias ele foi diariamente ao mercado e comprou exatamente uma barra de chocolate da sua marca favorita, Choconeps.
O mercado que Farcos frequentou estava experimentando uma curiosa estratégia de vendas: todos os dias eles alteravam o preço do chocolate em 1 unidade em relação ao dia anterior.
Farcos achou aquilo interessante, e todos os dias ele anotava em seu caderno se o preço que ele pagou estava mais caro ou mais barato que o dia anterior. Se estivesse mais caro ele anotava a letra "A", e se estivesse mais barato ele anotava a letra "B". No primeiro dia ele não fez nenhuma anotação, pois não havia "dia anterior" com o qual comparar, ou seja, as anotações começam a partir do segundo dia.
Ao final de $N$ dias, Farcos tem $N-1$ anotações em seu caderno.
Farcos não lembra qual era exatamente o preço do chocolate em nenhum dos dias, mas ele sabe que o preço nunca foi negativo, e que em um ou mais dias o preço foi 0.
Com base nas anotações de Farcos, ajude-o a encontrar o preço do chocolate nos $N$ dias.
#### Entrada
A primeira linha contém o inteiro $N$, representando quantos dias Farcos foi ao mercado.
A segunda linha contém uma string de tamanho $N-1$, correspondendo às anotações de Farcos. O primeiro caractere representa a anotação do segundo dia, o segundo caractere à anotação do terceiro dia, e assim por diante.
#### Saída
A saída deve consistir de uma linha, contendo $N$ números inteiros separados por espaços em branco, representando o preço do chocolate em cada um dos $N$ dias.
#### Restrições
* $2 \leq N \leq 10^{6}$ |
3,362 | 338 | Corrida | Médio | Tecnicas | Todo ano, os habitantes da Mlogônia, apesar das crises internas, reúnem-se em torno de um esporte que é a paixão nacional: as corridas de carros. A Grande Corrida anual é um enorme evento organizado pela Associação de Corridas da Mlogônia (ACM), sendo amplamente televisionado e reportado em jornais e revistas de todo o país. Os resultados da corrida são tema principal das rodas de conversa por semanas.
Por bastante tempo, os resultados da Grande Corrida eram compilados manualmente. Observadores especializados iam à pista medir o tempo de cada um dos $N$ carros, numerados de 1 a $N$ , em cada uma das $M$ voltas, anotando então os resultados em tabelas para posterior análise por parte das equipes e dos jornalistas. Muitos erros eram introduzidos nesse processo, e a organização decidiu informatizar todo o sistema.
A ACM percebeu que o esforço necessário para a construção do sistema seria grande, e optou por contar com a ajuda de uma equipe de programadores. Percival foi contratado para escrever a parte do software que determina quais foram os carros vencedores, mas está com dificuldades e pede sua ajuda. A sua tarefa, neste problema, é determinar os três carros melhor colocados, fornecidos os tempos que cada carro levou para completar cada volta da corrida.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$ representando o número de carros e o número de voltas da corrida, respectivamente.
Cada uma das $N$ linhas seguintes representa um carro: a primeira linha representa o primeiro carro, a segunda linha representa o segundo carro, e assim por diante. Cada linha contém $M$ inteiros representando os tempos em cada volta da corrida: o primeiro inteiro é o tempo da primeira volta, o segundo inteiro é o tempo da segunda volta, e assim por diante.
Garante-se que não houve dois carros que gastaram o mesmo tempo para completar a corrida inteira.
#### Saída
A saída consiste de três linhas, contendo um único inteiro cada. A primeira linha contém o número do carro que ganhou a corrida, a segunda contém o número do segundo colocado e a terceira contém o número do terceiro colocado.
#### Restrições
* $3 \leq N \leq 100$
* $1 \leq M \leq 100$
* $1 \leq$ qualquer número da entrada que represente o tempo de uma volta $\leq 10^6$
|
3,363 | 387 | Semente | Médio | Tecnicas | Um experimento biológico utiliza uma fita de papel branco especial, na qual algumas gotas de um reagente são colocadas em posições específicas. Inicialmente a gota de reagente faz com que o papel se torne preto na posição em que foi colocada. A cada dia o reagente se propaga pelo papel, em todas as direções, com velocidade de 1 posição por dia, colorindo a região em que o reagente se propagou. A figura abaixo mostra um experimento com uma fita de 13 posições, com três gotas de reagente inicialmente, colocadas nas posições 2, 6 e 13 (a posição 1 é a primeira mais à esquerda da fita). Ao final do terceiro dia, a fita está completamente tomada pelo reagente.
Você foi contratado para escrever um programa que, dados o comprimento da fita de papel e as posições das gotas de reagente no início do experimento, determine quantos dias serão necessários para a fita de papel ficar completamente tomada pelo reagente.
#### Entrada
A primeira linha contém dois inteiros $F$ e $R$, indicando respectivamente o comprimento da fita de papel, em números de posições, e o número de gotas no início do experimento. A segunda linha contém $R$ inteiros, indicando as posições das gotas de reagente, que são dadas em ordem crescente
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número de dias necessários para que a fita de papel fique totalmente tomada pelo reagente.
#### Restrições
* $1 \leq F \leq 100000$
* $1 \leq R \leq 1000$
|
3,364 | 300 | Sequência da Onda | Difícil | Tecnicas | A Onda é uma sequência de inteiros. Ela tem algumas propriedades interessantes:
* Uma Onda tem tamanho ímpar, da forma $L = 2\cdot n+1$
* Os primeiros $n+1$ inteiros da Onda formam uma sequência estritamente crescente;
* Os últimos $n+1$ inteiros da Onda formam uma sequência estritamente decrescente;
* Não há dois termos adjacentes iguais em uma Onda.
Por exemplo $1, 2, 3, 4, 5, 4, 3, 2, 0$ é uma sequência da Onda de comprimento $9$. Entretanto $1, 2, 3, 4, 5, 4, 3, 2, 2$ não é uma sequência da Onda válida. Neste
problema, você receberá uma sequência de inteiros. Você deve encontrar o comprimento da maior Sequência da Onda que é uma subsequência da sequência dada. Considere que a sequência dada seja: $1 \ 2 \ 3 \ 2 \ 1 \ 2 \ 3 \ 4 \ 3 \ 2 \ 1 \ 5 \ 4 \ 1 \ 2 \ 3 \ 2 \ 2 \ 1$
Aqui, a maior Sequência da Onda é: $1 \ 2 \ 3 \ 4 \ 5 \ 4 \ 3 \ 2 \ 1$. Logo, a saída será $9$.
#### Entrada
A primeira linha da entrada contém um inteiro positivo $m$.
A segunda linha contém $m$ inteiros $a_i$, os elementos da sequência.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro: o tamanho da maior
Sequência da Onda que é uma subsequência da que é fornecida na entrada
#### Restrições
* $1\leq m\leq 10^5$
* $-10^9 \leq a_i \leq 10^9$, para todo $i$
|
3,365 | 343 | Trabalho do Papa | Difícil | Tecnicas | Karol Wojtyła nasceu em Wadowice em 1920, foi eleito papa João Paulo II em 1978 e morreu em 2 de abril de 2005 após completar 26 anos de pontificado. Foi um dos poloneses mais importantes da História. Antes de se tornar religioso, durante a segunda grande guerra, Wojtyła trabalhou em uma fábrica de produtos químicos.
Uma das tarefas de Wojtyła era acomodar os pacotes de produtos químicos em pilhas para transportá-los. O problema surgia do fato de que alguns destes pacotes eram muito pesados, e outros tinham pouca resistência a ter peso sobre eles. Os gerentes da fábrica sempre desejavam pilhas grandes, com o maior número possível de caixas.
Todas as caixas tinham associados dois números: seu peso em quilos e o peso, também em quilos, que era capaz de suportar (incluindo o peso da caixa). Assim, uma caixa de 25 quilos e resistência de 60 quilos era capaz de suportar no máximo 35 quilos em cima dela.
Sua tarefa é, dada uma lista de caixas, com seus pesos e resistências, determinar o número máximo de caixas que podem ser empilhadas sem ultrapassar a resistência de nenhuma caixa da pilha.
#### Entrada
A entrada é composta por diversas linhas. A primeira linha contém um inteiro $N$, indicando o número de caixas. Cada uma das $N$ linhas seguintes contém inteiros $P$ e $R$, correspondendo, respectivamente, ao peso e resistência de uma caixa.
#### Saída
A saída deverá conter apenas uma única linha, o maior número de caixas que podem ser empilhadas nas condições do enunciado.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq P \leq 1000$
* $1 \leq R \leq 1000000$
|
3,366 | 471 | Tabela do Campeonato | Médio | Tecnicas | Joana adora futebol e conseguiu um estágio no clube pelo qual torce. Na sala de troféus Joana encontrou uma caderneta em que um antigo conselheiro do clube anotou os resultados de todos os campeonatos que o time participou.
Para cada campeonato há uma anotação na caderneta informando cinco dados: o número de jogos, o número de pontos, o número de vitórias, o número de empates e o número de derrotas do time naquele campeonato. Em todos os campeonatos, cada vitória vale três pontos, cada empate vale um ponto e derrotas não valem pontos.
Infelizmente, a caderneta era muito velha e alguns desses números estavam ilegíveis. Joana, no entanto, percebeu que, para cada campeonato, se algum número estivesse ilegível ele poderia ser computado utilizando os números legíveis daquele campeonato.
Sua tarefa é escrever um programa para completar as informações encontradas na caderneta.
#### Entrada
A entrada consiste de uma única linha que contém cinco inteiros $J$, $P$, $V$, $E$ e $D$, indicando respectivamente o número de jogos, o número de pontos, o número de vitórias, o número de empates e o número de derrotas para um campeonato. Um ou dois desses números tem o valor -1, indicando que o número é ilegível na caderneta. Todos os casos da entrada têm solução.
#### Saída
Seu programa deve produzir uma única linha, com exatamente cinco números inteiros, os valores corrigidos da caderneta para o campeonato da entrada. Os números devem ser dados na mesma ordem fornecida na entrada: o número de jogos, o número de pontos, o número de vitórias, o número de empates e o número de derrotas, separados por exatamente um espaço em branco. Note que no resultado devem valer as equações $J = V + E + D$ e $P = 3 * V + E$.
#### Restrições
* $1 \leq J \leq 100$; $0 \leq P \leq 300$; $0 \leq V \leq 100$; $0 \leq E \leq 100$; $0 \leq D \leq 100$.
* Na entrada, um ou dois dos valores entre $J$, $P$, $V$, $E$ e $D$ é igual a -1 (e somente nesses casos as restrições acima não são obedecidas).
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, $P$, $V$, $E$, $D \geq 0$ e $J = -1$.
* Para um conjunto de casos de testes valendo outros 40 pontos, apenas um dos valores da entrada é -1.
|
3,367 | 10 | Quase Primo | Difícil | Tecnicas | O jovem César está aprendendo sobre números primos: um número $X > 1$ é primo se for divisível apenas por 1 e por $X$.
A primeira tarefa de casa de César consiste em dizer, para um dado número $N$, quantos números menores ou iguais a $N$ são primos. Acontece que os números são muito grandes e César tem preguiça. Ele suspeita que seu professor é tão preguiçoso quanto ele, e acha que, seu professor, para testar se um número é primo, vai testar só uma pequena quantidade de divisores primos. Com isso em mente, ele compilou uma lista de $K$ números primos que acha que o professor vai usar.
Mesmo assim, César ainda está com preguiça. Dados $N$ e a lista com $K$ números primos, diga quantos números inteiros positivos menores ou iguais a $N$ não são divisíveis por nenhum número primo na lista.
#### Entrada
A primeira linha da entrada contém dois inteiros, $N$ e $K$. A linha seguinte contém $K$ primos distintos $k_i$, ($1 \leq i \leq K$), que são os primos que César acha que o professor irá considerar.
#### Saída
Imprima um único inteiro, a quantidade de números inteiros positivos menores ou iguais a $N$ que não são divisíveis por nenhum número na lista.
#### Restrições
* $1 \leq N \leq 10^9$
* $1 \leq K \leq 40$
* $k_i$ é primo e $2 \leq k_i \leq N$ |
3,368 | 574 | Etiquetas | Difícil | Tecnicas | Uma fita esticada horizontalmente é composta de $N$ quadrados de dimensão $1 \times 1$, cada um deles contendo um número inteiro anotado. Temos também $K$ etiquetas retangulares idênticas, de dimensão $1 \times C$, onde $C$ é um inteiro. Nosso objetivo é colar todas as etiquetas sobre a fita de modo que a soma dos inteiros que não estiverem cobertos por nenhuma etiqueta ao final seja a máxima possível. Cada etiqueta deve ser colada na horizontal, ao longo da fita. Duas etiquetas não podem estar sobrepostas e cada quadrado da fita deve estar ou totalmente coberto por uma etiqueta, ou totalmente descoberto.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $K$ e $C$, representando, respectivamente, o comprimento da fita, o número de etiquetas e o comprimento das etiquetas. A segunda linha da entrada contém $N$ inteiros indicando a sequência de números anotados nos quadrados da fita.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro indicando a soma máxima possível de inteiros descobertos na fita depois que todas as etiquetas sejam coladas seguindo as condições do enunciado
#### Restrições
* $1 \leq N \leq 10000$
* $-10000 \leq A \leq 10000$
* $1 \leq K \leq 10000$
* $1 \leq C \leq 10000$
* $K * C \leq N$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, os números no vetor estão ordenados crescentemente.
* Para um conjunto de casos de testes valendo outros 10 pontos, $C = 1$.
* Para um conjunto de casos de testes valendo outros 20 pontos, $K = 1$.
* Para um conjunto de casos de testes valendo outros 20 pontos, $K, N \leq 100$. |
3,369 | 648 | Quermesse | Fácil | Tecnicas | Os alunos do último ano resolveram organizar uma quermesse para arrecadar fundos para a festa de formatura. A festa prometia ser um sucesso, pois o pai de um dos formandos, Teófilo, dono de uma loja de informática, decidiu doar um computador para ser sorteado entre os que comparecessem. Os alunos prepararam barracas de quentão, pipoca, doces, ensaiaram a quadrilha e colocaram à venda ingressos numerados sequencialmente a partir de 1. O número do ingresso serviria para o sorteio do computador. Ficou acertado que Teófilo decidiria o método de sorteio; em princípio o sorteio seria, claro, computadorizado.
O local escolhido para a festa foi o ginásio da escola. A entrada dos participantes foi pela porta principal, que possui uma roleta, onde passa uma pessoa por vez. Na entrada, um funcionário inseriu, em uma lista no computador da escola, o número do ingresso, na ordem de chegada dos participantes. Depois da entrada de todos os participantes, Teófilo começou a trabalhar no computador para preparar o sorteio. Verificando a lista de presentes, notou uma característica notável: havia apenas um caso, em toda a lista, em que o participante que possuía o ingresso numerado com $i$, havia sido a $i$-ésima pessoa a entrar no ginásio. Teófilo ficou tão encantado com a coincidência que decidiu que o sorteio não seria necessário: esta pessoa seria o ganhador do computador.
Conhecendo a lista de participantes, por ordem de chegada, sua tarefa é determinar o número do ingresso premiado, sabendo que o ganhador é o único participante que tem o número do ingresso igual à sua posição de entrada na festa.
#### Entrada
A entrada é composta de vários conjuntos de teste. A primeira linha de um conjunto de teste contém um número inteiro positivo $N$ que indica o número de participantes da festa. A linha seguinte contém a sequência, em ordem de entrada, dos $N$ ingressos das pessoas que participaram da festa. O final da entrada é indicado quando $N = 0$. Para cada conjunto de teste da entrada haverá um único ganhador.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas. A primeira linha identifica o conjunto de teste, no formato "Teste n", onde $n$ é numerado a partir de 1. A segunda linha deve conter o número do ingresso do ganhador, conforme determinado pelo seu programa. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 10000$ ($N = 0$ apenas para indicar o fim da entrada) |
3,370 | 1360 | Backup | Médio | Tecnicas | A equipe da CPD (Central de Processamento de Dados) de uma empresa é responsável pelo backup semanal dos servidores. Além da cópia física, em máquinas locais e remotas, a equipe entendeu que também seria prudente fazer cópias em mídias físicas e guardá-las em um cofre.
Embora não concorde com tal procedimento, por considerá-lo desnecessário, o departamento de finanças disse que liberaria os recursos para a compra dos equipamentos, desde que o número de equipamentos adquiridos fosse o menor possível e que os equipamentos fossem utilizados em sua totalidade, isto é, cada equipamento deveria armazenar dados em quantidade igual a sua capacidade máxima.
O tamanho do _backup_ é dado em _gigibytes_ (GiB), e os equipamentos que podem vir a ser adquiridos são: pendrives de 1, 2, 4, 8, 16, 32 ou 64GiB; unidades de estado sólido de 128, 256 ou 512GiB; e discos rígidos convencionais de 1, 2, 4 ou 8 _teribytes_ (TiB, onde 1TiB = 1024GiB).
Dado o tamanho do _backup_ semanal, em GiB, e considerando que a CPD consegue dividir este _backup_ em pacotes do tamanho necessário e que possam ser gravados utilizando a íntegra do espaço disponível nos dispostivos escolhidos, determine o número mínimo de equipamentos a serem adquiridos.
#### Entrada
A entrada consiste em uma única linha, com um inteiro indicando o tamanho $T$, em GiB, do _backup_ semanal a ser gravado nos equipamentos.
#### Saída
Imprima, em uma linha, o número mínimo de equipamentos que devem ser adquiridos para armazenar o _backup_ semanal.
#### Restrições
* $1\leq T\leq 16.000$
|
3,371 | 1659 | Sanduíche | Difícil | Tecnicas | Uma nova lanchonete abriu na cidade, prometendo um menu com a maior variedade de sanduíches da região. A cada dia o Chef de cozinha compra $N$ ingredientes distintos e prepara o menu usando esses $N$ ingredientes. Infelizmente não é possível ter sanduíches com qualquer combinação de ingredientes: a cada dia o Chef determina que $M$ pares de ingredientes não podem ser utilizados no mesmo sanduíche, porque ele considera que esses ingredientes “não combinam”.
Por exemplo, suponha que num determinado dia $N$ é igual a quatro e os ingrediantes são queijo, presunto, goiabada e azeitona, e $M$ é igual a dois: os pares (goiabada, presunto) e (azeitona, goiabada) não podem ser utilizados no mesmo sanduíche. Nesse dia, alguns dos sanduíches que podem ser feitos são:
* presunto, queijo
* azeitona
* presunto, azeitona, queijo
* goiabada, queijo
Alguns dos sanduíches que não podem ser feitos são:
* presunto, queijo, goiabada
* azeitona, goiabada
* goiabada, presunto, azeitona
Dados os $N$ ingredientes e os $M$ pares de ingredientes que não combinam, sua tarefa é determinar qual o máximo número de sanduíches diferentes que podem ser feitos. Dois sanduíches $A$ e $B$ são considerados diferentes se $A$ contém um ingrediente $X$ que não está presente em $B$ ou se $B$ contém um ingrediente $Y$ que não está presente em $A$. Um sanduíche deve conter ao menos um ingrediente.
#### Entrada
A primeira linha contém dois números inteiros $N$ e $M$, indicando respectivamente o número de ingredientes e o número de pares de ingredientes que não combinam. Os ingredientes são identificados por números de 1 a $N$. Cada uma das $M$ linhas seguintes contém dois números inteiros $X$ e $Y$ que representam um par de ingredientes que não combinam.
#### Saída
Seu programa deve produzir uma única linha, o número de sanduíches diferentes que podem ser feitos.
#### Restrições
* $1 ≤ N ≤ 20$
* $0 ≤ M ≤ 400$
* $1 ≤ X ≤ N$
* $1 ≤ X < Y$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, $N ≤ 5$.
* Para um conjunto de casos de testes valendo outros 40 pontos, $N ≤ 10$.
* Para um conjunto de casos de testes valendo outros 50 pontos, nenhuma restrição adicional.
|
3,372 | 1596 | O Segundo Maior Número Inteiro | Fácil | Tecnicas | Três inteiros $A$, $B$, e $C$ são dados. Imprima o segundo maior número entre eles.
#### Entrada
A entrada é dada pela entrada padrão na forma a seguir.
$A$ $B$ $C$
#### Saída
Imprima o segundo maior número entre $A$, $B$, e $C$.
#### Restrições
* $1 \leq A \leq 100$.
* $1 \leq B \leq 100$.
* $1 \leq C \leq 100$. |
3,373 | 270 | Bora Bora | Difícil | Tecnicas | Bora Bora é um jogo de cartas simples para crianças, inventado na Ilha do Pacífico Sul de mesmo nome. Duas ou mais pessoas podem jogar, usando um baralho de cartas normais. As cartas têm os valores normais: Ás, 2, 3, 4, 5, 6, 7, 8, 9, 10, Valete, Dama e Rei. Cada carta tem também um dos quatro naipes: Paus, Ouros, Copas e Espadas.
Os jogadores sentam-se em um círculo ao redor da mesa e jogam por turnos. O próximo jogador a jogar pode ser aquele à esquerda (sentido horário) ou o jogador à direita (sentido anti-horário) do jogador atual, dependendo das cartas jogadas, como você verá. No começo, o sentido do jogo é horário.
O baralho é embaralhado e é dada a cada jogador uma mão de cartas. O restante do baralho é colocado na mesa, virado para baixo; a essa pilha é dado o nome de pilha de saque. Então a primeira (a mais acima) carta é removida da pilha e colocada na mesa, virada para cima, começando outra pilha, chamada de pilha de descarte.
O objetivo do jogo é que um jogador descarte todas suas cartas. Em cada turno, um jogador descarta no máximo uma carta. Uma carta pode ser descartada apenas se ela tem o mesmo valor ou o mesmo naipe da carta que se encontra no topo da pilha de descarte. Um jogador descarta uma carta colocando-a, virada para cima, na pilha de descarte (essa carta se torna a carta do topo). Se um jogador não tiver uma carta passível de ser descartada em seu turno, ele deve sacar uma carta da pilha de saque e adicionar à sua mão; se ele puder descartar essa carta, ele o faz, caso contrário ele não faz mais nada e seu turno acaba. Um jogador sempre descarta a carta mais alta que ele consegue. O valor de uma carta é determinado primeiro pelo valor da carta e então pelo naipe. A ordem dos valores é o valor em si (Ás é o menor e Rei é o maior), e a ordem dos naipes é, do menor para o maior, Paus, Ouros, Copas e Espadas. Portanto, a carta de maior valor é o Rei de Espadas e a de menor valor é o Ás de Paus. Como exemplo, a Dama de Ouros tem um valor maior que um Valete (qualquer naipe) mas tem um valor menor que a Dama de Copas.
Algumas das cartas descartadas afetam o jogo, como se segue:
* Quando uma Dama é descartada, a direção de jogo é invertida: se a direção é horária, ela se torna anti-horária, e vice-versa;
* Quando um Sete é descartado, o próximo jogador deve sacar duas cartas da pilha de saque (o número de cartas em sua mão aumenta por dois), e perde a vez (não descarta nenhuma carta);
* Quando um Ás é descartado, o próximo jogador deve sacar uma carta da pilha de saque (o número de cartas em sua mão aumenta por um), e perde sua rodada (não descarta nenhuma carta);
* Quando um Valete é descartado, o próximo jogador perde a vez (não descarta nenhuma carta).
Perceba que a penalidade da primeira carta da pilha de descarte (a carta sacada da pilha de saque no começo) é aplicada ao primeiro jogador a jogar. Por exemplo, se o primeiro jogador é $p$ e a primeira carta na pilha de descarte é um Ás, o jogador $p$ saca uma carta da pilha de saque e não descarta nenhuma carta em seu primeiro turno. Note também que se a primeira carta é uma Dama, o sentido do jogo é invertido para o anti-horário, mas o primeiro jogador a jogar permanece o mesmo.
O vencedor é o jogador que descarta todas suas cartas primeiro (o jogo acaba depois de o vencedor descartar sua última carta).
Dada a descrição do baralho embaralhado e o número de jogadores, escreva um programa que determine quem vencerá o jogo.
#### Entrada
A entrada contém diversos casos de teste. A primeira linha de um caso de teste contém três inteiros $P$, $M$ e $N$, separados por espaço, indicando respectivamente o número de jogadores, o número de cartas distribuídas para cada jogador no começo da partida e o número de cartas no baralho embaralhado. Cada uma das próximas $N$ linhas contém a descrição de uma carta. Uma carta é descrita por um inteiro X e um caractere S, separados por um espaço, representando respectivamente o valor da carta e seu naipe. O valor das cartas é mapeado com inteiros de 1 a 13 (Ás é 1, Valete é 11, Dama é 12 e Rei é 13). Os naipes das cartas são designados pela primeira letra do naipe: 'C' (Paus - Clubs), 'D' (Ouros - Diamonds), 'H' (Copas - Hearts) ou 'S' (Espadas - Spades).
Os jogadores são identificados com valores de 1 a $P$ e sentam-se em um círculo, no sentido horário, $1, 2 \ldots P$, 1. As primeiras $P$ x $M$ cartas do baralho são distribuídas aos jogadores: as primeiras $M$ cartas ao primeiro jogador (jogador 1), as próximas $M$ cartas ao segundo jogador (jogador 2), e assim por diante. Depois de distribuir as cartas aos jogadores, a próxima carta do baralho - a ($P$ x $M$ + 1)-ésima carta - é usada para começar a pilha de descarte, e as cartas restantes formam a pilha de saque. A ($P$ x $M$ + 2)-ésima carta a aparecer na entrada é a carta do topo da pilha de saque, e a última carta a aparecer na entrada (a N-ésima carta) é a carta de baixo da pilha de saque (a última carta que pode ser sacada). O jogador 1 é sempre o primeiro a jogar (mesmo se a carta usada para começar a pilha de descarte é uma Dama). Todos os casos de teste têm um vencedor, e em todos casos de teste o número de cartas no baralho é suficiente para jogar até o fim da partida.
O final da entrada é indicado por uma linha contendo apenas três zeros, separados por espaços.
#### Saída
Para cada caso de teste na entrada, seu programa deve imprimir uma única linha, contendo o número do jogador que ganha a partida.
#### Restrições
* $2 \leq P \leq 10$
* $1 \leq M \leq 11$
* $3 \leq N \leq 300$
|
3,374 | 508 | Quadradinho de 8 | Difícil | Tecnicas | Fernando ficou sabendo de um novo jogo chamado quadradinho de 8. Nesse jogo, é apresentado ao jogador uma fileira de quadrados, um do lado do outro. Em cada quadrado há um número escrito. Veja abaixo um exemplo de fileira de quadrados:
Para ganhar, o jogador deve escolher alguns quadrados de forma que eles juntos formem apenas um retângulo contíguo e que a soma de seus números seja divisível por 8. Na fileira de quadrados acima, o jogador ganha se escolher os quadrados com os números 6, 0 e 2. O jogador perde se escolher os quadrados com 3, 4 e 9, apesar da soma ser divisível por 8, os quadrados não estão juntos, eles acabam formando dois retângulos separados.
Você deve estar pensando agora que Fernando quer sua ajuda para que você mostre a ele como ganhar o jogo, mas Fernando é um garoto muito esperto e sabe resolver o jogo rapidamente. Ele quer na verdade que você o ajude a descobrir de quantas formas é possível ganhar esse jogo.
#### Entrada
A entrada possui duas linhas. A primeira linha contém apenas um inteiro $N$ que indica o número de
quadrados na fileira de um jogo. A segunda linha contém $N$ inteiros indicando na ordem os números
presentes nos quadrados da fileira de um jogo.
#### Saída
Seu programa deve imprimir uma única linha, contendo apenas um inteiro, o número de maneiras de ganhar o jogo apresentado na entrada. Se não for possível que o jogador ganhe o jogo, imprima 0.
#### Restrições
* $1 \leq N \leq 1000000$
* Os números nos quadrados são inteiros não negativos menores ou iguais a 1000.
#### Informações sobre a pontuação
* Para um conjunto de entradas totalizando 50 pontos, $N \leq 200$.
* Para um conjunto de entradas totalizando 70 pontos, $N \leq 5000$.
|
3,375 | 605 | Pão a Metro | Médio | Tecnicas | Pão a metro é um tipo de sanduíche gigante que é uma excelente opção de lanche para torneios de programação, embora a experiência já tenha mostrado que o oferecimento de sanduíches pode gerar reclamação dos competidores. Outro grande problema é que algumas pessoas são mais gulosas que outras e, dessa maneira, acabam pegando pedaços maiores que os pedaços dos outros.
Para a final da OBI, a coordenação estava pensando em providenciar pão a metro para os competidores, porém tais problemas os fizeram recuar na ideia. Embora a ideia tenha sido momentaneamente abandonada, uma ideia simples surgiu: cortar previamente o pão em fatias de tamanho iguais e distribui-las entre as pessoas. O único problema com tal idéia é que se o número de pessoas for muito grande, fica impraticável ter apenas um pão. Por exemplo, se quisermos que 1.000 pessoas recebam 20 centímetros de sanduíche, seria necessário um sanduíche de 20.000 centímetros, ou 200 metros!
Alguém levantou a seguinte hipótese: se houvessem $N$ pessoas e fossem encomendados $K$ sanduíches de empresas diferentes, cada qual com uma determinada metragem (tamanho) $M_i$ ($1 \leq i \leq K$), seria possível retirar desses pães $N$ fatias de mesmo tamanho, possivelmente sobrando partes não utilizadas. A questão seria: qual o tamanho inteiro máximo que essas fatias poderão ter?
Por exemplo, se tivermos $K = 4$, com os tamanhos (em centímetros) $M_1 = 120$, $M_2 = 89$, $M_3 = 230$ e $M_4 = 177$ e $N = 10$, podemos retirar $N$ fatias iguais de tamanho máximo 57, pois assim conseguimos 2 fatias no primeiro pão, 1 no segundo, 4 no terceiro e 3 no quarto, totalizando as 10 fatias necessárias. Se tentarmos cortar fatias de tamanho 58, só será possível obter 3 fatias do terceiro pão, totalizando 9 e, portanto, 57 é realmente o melhor que podemos obter. Note que não podemos usar duas ou mais fatias menores de diferentes pães para formarmos uma fatia do tamanho selecionado. (ficaria muito deselegante dar um lanche recortado às pessoas).
Escreva um programa que, dados os tamanhos de pão disponíveis (em centímetros) e a quantidade de pessoas a serem atendidas, retorne o tamanho inteiro máximo (em centímetros) da fatia que pode ser cortada de maneira a atender todas as pessoas.
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro $N$ que indica a quantidade pessoas. A segunda linha contém um inteiro $K$ que é a quantidade de sanduíches disponível. Na terceira linha há $K$ inteiros $M$ separados por um espaço em branco representando o tamanho de cada pão.
#### Saída
Seu programa deve imprimir, na saida padrão, uma única linha, contendo o tamanho inteiro máximo da fatia que pode ser cortada.
#### Restrições
* $1 \leq N \leq 10000$
* $1 \leq K \leq 10000$
* $1 \leq M \leq 10000$ |
3,376 | 66 | Macacos me Mordam! | Difícil | Tecnicas | Em uma floresta há $N$ árvores alinhadas. A i-ésima árvore tem altura $H_i$ e está localizada na posição $X_i$ da floresta. Obi, o macaco camarada, está na primeira árvore da floresta, e deseja ir até a última árvore da floresta, porque ele ouviu dizer que há muitas bananas esperando por ele lá.
Para ir até a última árvore, Obi vai pular entre as árvores. Obi é um macaco muito ágil, e consegue pular de uma árvore $A$ para outra árvore $B$ sempre que, do topo da árvore A ele consegue enxergar o topo da árvore $B$, independente das posições das árvores $A$ e $B$. Mas Obi é também um macaco muito preguiçoso, e quer pular o menor número de vezes possível.
Na figura acima podemos ver que, do topo da árvore na posicão 2, Obi não consegue enxergar o topo da árvore na posição 4, e portanto ele não pode pular de uma para outra sem passar pela árvore na posição 3. Assim, para o caso da figura acima, para ir da árvore 1 para a árvore 4 ele tem que passar por todas as árvores, dando um total de três pulos.
Dada a descrição da floresta, você deve escrever um programa para determinar o menor número de pulos que Obi deve dar para ir da primeira à última árvore da floresta.
#### Entrada
A primeira linha da entrada contém um número $N$, indicando a quantidade de árvores na floresta. Cada uma das $N$ linhas seguintes descreve uma árvore da floresta, e contém dois inteiros $X_i$ e $H_i$, respectivamente a posição e a altura de uma árvore. Cada árvore ocupa uma posição distinta na floresta (ou seja, não há duas árvores com o mesmo valor $X_i$).
#### Saída
Seu programa deve produzir uma única linha, contendo um único número inteiro, a menor a quantidade de pulos que Obi deve dar para ir da primeira até a última árvore da floresta.
#### Restrições
* $2 \leq N \leq 3 \cdot 10^5$
* $1 \leq H_i, X_i \leq 10^9$
|
3,377 | 1057 | Sobrinhos | Médio | Tecnicas |
O Natal está chegando, e todo mundo sabe que criança adora ganhar presente! Por conta disso, uma loja de balas abriu uma promoção, para conseguir vender o maior número possível de balas, aproveitando a época de Natal. Na véspera, a loja teve uma fila com $N$ pessoas, cada uma comprando balas para dar de presente para seus sobrinhos.
Cada pessoa $i$ comprou uma quantidade $X_i$ de balas, e possui uma quantidade $Y_i$ de sobrinhos. Elas devem dividir igualmente suas balas entre os seus sobrinhos, então pode ser que sobrem balas no final da distribuição, que chamaremos de resto. Por exemplo, se a primeira pessoa da fila comprou 20 balas e possui 8 sobrinhos, cada sobrinho vai ganhar 2 balas e o resto será de 4 balas.
O que queremos saber é o seguinte: se colocássemos as pessoas da fila em ordem, **do menor pro maior resto**, qual seria o resto da pessoa que estaria na $K$-ésima posição da fila ordenada, dado um $K$ menor ou igual a $N$?
#### Entrada
A primeira linha de entrada contém dois inteiros $N$ e $K$.
As próximas $N$ linhas representam as pessoas da fila, da primeira até a última pessoa. Cada uma dessas linhas contém dois inteiros, $X_i$ e $Y_i$, o número de balas que a pessoa $i$ comprou, e o número de sobrinhos que ela tem.
Lembrando que a fila dada na entrada é a fila original, ela não está necessariamente ordenada pelo resto.
#### Saída
Seu programa deve imprimir um único inteiro, o resto de balas da pessoa que estaria na $K$-ésima posição da fila, se a fila estivesse ordenada pelo resto.
#### Restrições
* $1\ \leq\ N\ \leq\ 10^5$
* $1\ \leq\ K\ \leq\ N$
* $1\ \leq\ X_i,\ Y_i\ \leq\ 10^9$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 10 pontos, $1\ \leq\ N\ \leq\ 3$.
* Em um conjunto de casos de teste somando 20 pontos, $K\ =\ 1$.
* Em um conjunto de casos de teste somando 30 pontos, $1\ \leq\ N\ \leq\ 1000$.
* Em um conjunto de casos de teste somando 40 pontos, nenhuma restrição adicional.
|
3,378 | 504 | Tiro ao Alvo | Médio | Tecnicas |
Recentemente Juquinha ganhou de aniversário um joguinho bem clássico: Tiro ao Alvo. Ele arrumou um ótimo lugar em seu quarto para se divertir com o jogo, porém após ler todas as regras do jogo ele percebeu que precisa da sua ajuda para calcular a pontuação obtida.
Segundo as regras, o alvo do jogo é composto por C círculos, todos centrados na origem (0,0). Juquinha atira T vezes e após cada tiro informa suas coordenadas. A pontuação de cada tiro é feita da seguinte forma: para cada círculo em que o tiro estiver contido Juquinha recebe um ponto.
Considere por exemplo a figura abaixo. O tiro marcado com a letra A recebe zero pontos, pois não está contido por nenhum círculo. O tiro marcado com a letra B recebe um ponto, pois está contido por um círculo (o mais externo). O tiro marcado com a letra C recebe dois pontos, pois está contido por dois círculos (note que este caso mostra que tiros exatamente na borda de um círculo são considerados como contidos pelo círculo). Já o tiro marcado com a letra D recebe três pontos, pois está contido pelos três círculos. Considerando todos os pontos, a pontuação total de Juquinha é de 13 pontos.
Dados os raios de $C$ círculos centrados na origem e as coordenadas dos $T$ tiros realizados por Juquinha, escreva um programa que calcula o total de pontos que Juquinha obteve
#### Entrada
A primeira linha da entrada contém dois inteiros positivos, $C$ e $T$, que representam, respectivamente, o número de círculos do alvo e o número de tiros.
Cada uma das $C$ linhas seguintes contém um inteiro positivo. O $i$-ésimo inteiro $R_i$ representa o raio do $i$-ésimo círculo. Os raios $R_i$ são fornecidos em ordem crescente.
Cada uma das $T$ linhas seguintes contém um par $X$, $Y$ de inteiros, que representam as coordenadas de cada tiro.
#### Saída
Seu programa deve imprimir uma única linha, contendo apenas um inteiro, o total de pontos obtidos por Juquinha.
#### Restrições
* $1 \leq C \leq 10^5$
* $1 \leq R_i \leq 10^6$ para $1 \leq i \leq C$
* $R_i > R_{i-1}$ para $2 \leq i \leq C$
* $1 \leq T \leq 10^5$
* $-10^5 \leq X, Y \leq 10^5$
#### Informações sobre a pontuação
Em um conjunto de casos de teste que totaliza 30 pontos:
* $1 \leq C \leq 10^3$
* $1 \leq R_i \leq 10^4$ para $1 \leq i \leq N$
* $1 \leq T \leq 10^3$
* $-100 \leq X, Y \leq 100$ |
3,379 | 330 | Banco do Faraó | Difícil | Tecnicas | Pouca gente sabe, mas foi no Antigo Egito que surgiram os primeiros bancos, de uma forma muito semelhante ao que conhecemos hoje.
O principal banco era do faraó, que decidia, de tempos em tempos, tomar para o Estado o conteúdo de algumas contas. Isso ocorria da seguinte forma. Dado $N$, o número de correntistas do Banco do Faraó (era esse o nome do banco), cada conta podia ter uma quantia em menés (moeda do Antigo Egito) que podia ser, inclusive, negativa (indicando que a pessoa devia aquela quantia ao banco), ou seja, o estado de cada conta era um inteiro ai. O objetivo do faraó era fazer diversas consultas nas contas de seus súditos. Dado um intervalo $[A,B]$ (correspondente as contas $a_A$, $a_{A+1}$, ... , $a_{B-1}$, $a_B$) o faraó desejava encontrar um subintervalo de soma máxima, ou seja, cujo sequestro pelo Estado renderia ao Faraó a maior quantia de dinheiro. Isso era explicado aos correntistas como sendo uma oferenda a Amon-Ahcid, o Deus egípcio do dinheiro.
Fazendo regularmente tais oferendas o deus ficava satisfeito e permitia que o sistema econômico funcionasse perfeitamente. Isso durou surpreendentemente mais de 500 anos, até que num desses sequestros os correntistas se rebelaram, tomaram o palácio e mataram o faraó. O banco foi saqueado e o sistema ruiu. Só se ouviu falar de bancos novamente centenas de anos depois.
Sua tarefa é dado um registro de contas e uma série de consultas, determinar para cada consulta um intervalo de soma máxima.
#### Entrada
A entrada é composta por diversas instâncias. A primeira linha da entrada contém um inteiro $T$ indicando o número de instâncias.
A primeira linha de cada instância contém um inteiro $N$, indicando o número de contas no Banco do Faraó. A segunda linha de cada instância contém $N$ inteiros $V_i$, indicando os saldos nas contas dos correntistas. A terceira linha contém um inteiro $Q$, indicando o número de consultas que serão feitas. Cada uma das $Q$ linhas seguintes contém dois inteiros $A$ e $B$, indicando o intervalo que deve ser consultado.
#### Saída
Para cada instância seu programa deve produzir $Q$ linhas na saída, sendo uma para cada consulta. Cada uma dessas linhas deve conter dois inteiros: o primeiro representa a soma do intervalo com maior soma, e o segundo, o número de elementos desse intervalo. Caso haja mais de um intervalo com maior soma, imprima o número de elementos naquele com maior número de elementos.
#### Restrições
* $1 \leq N \leq 10^5$
* $-10^4 \leq V_i \leq 10^4$
* $1 \leq Q \leq 10^5$
* $1 \leq A,B \leq N$
|
3,380 | 1728 | Mínimo e máximo | Fácil | Tecnicas | Algumas pessoas conseguem fazer cálculos matemáticos com uma velocidade impressionante. Pedrinho tem essa habilidade! Um cálculo que ele consegue fazer muito rapidamente é, dados três números inteiros $S$, $A$, e $B$, determinar qual o menor número inteiro do intervalo $[A, B]$ tal que a soma de seus dígitos é igual a $S$.
Por exemplo, se $S = 3$, $A = 10$, $B = 30$, então a reposta é 12, pois existem três números no intervalo $[10, 30]$ cuja soma dos dígitos é igual a três: 12, 21 e 30, e 12 é o menor deles.
Um colega desafiou Pedrinho a calcular não somente o menor número, mas também o maior número no intervalo $[A, B]$ tal que a soma dos números é igual ao valor de $S$ dado. Por exemplo, se $A = 1$, $B = 1000$ e $S = 1$, então a reposta é 1 e 1000, pois existem quatro números no intervalo $[1, 1000]$ cuja soma dos dígitos é igual a um: 1, 10, 100,1000, sendo 1 o menor e 1000 o maior.
Sua tarefa é escrever um programa de computador para, dados os três números, tentar calcular a resposta para o desafio mais rapidamente do que Pedrinho.
#### Entrada
A primeira linha da entrada contém um número inteiro $S$, o valor da soma dos dígitos. A segunda e a terceira linhas contêm respectivamente os inteiros $A$ e $B$.
#### Saída
Seu programa deve produzir exatamente duas linhas. A primeira linha deve conter um inteiro, o menor número cuja soma de dígitos tem o valor indicado, no intervalo dado. A segunda linha deve conter um inteiro, o maior número cuja soma de dígitos tem o valor indicado, no intervalo dado.
#### Restrições
* $1 ≤ S ≤ 36$
* $1 ≤ A ≤ 10000$
* $1 ≤ B ≤ 10000$
* $A ≤ B$
* sempre haverá ao menos um número no intervalo $[A, B]$ cuja soma dos dígitos é igual a $S$.
|
3,381 | 530 | O Mar não está para Peixe | Médio | Tecnicas | Em um arquipélago no meio do Oceano Pacífico a economia é regida pela pesca, pois o peixe é o principal alimento disponível. Ultimamente, a população desse arquipélago tem aumentado drasticamente, o que levou a um grande aumento da pesca, e, consequentemente, a problemas.
Neste arquipélago, cada pescador vai diariamente ao alto mar com a intenção de conseguir trazer o maior número de peixes para o seu vilarejo. Com a expansão da pesca, os pescadores estão começando a jogar suas redes de pesca por cima das de outros pescadores. Com isso, os pescadores perdem, pois apenas o primeiro pescador pega os peixes da intersecção entre as redes.
A Associação dos Pescadores da ilha decidiu fazer um levantamento para descobrir quanto do mar está de fato sendo aproveitado, ou seja, qual a área do mar que está coberta por pelo menos uma rede de pesca.
Como há muitas intersecções entre as redes de pesca, é muito difícil para a associação calcular a área total da região coberta pelas redes. Por este motivo, eles pediram para que você escrevesse um programa para resolver este problema.
Como é muito difícil navegar pelo mar, os pescadores sempre jogam as redes de forma que as regiões cobertas por cada rede são sempre retângulos com lados paralelos aos eixos, se imaginarmos o mar como um plano cartesiano
#### Entrada
A primeira linha da entrada possui um inteiro $N$ indicando o número de redes que foram lançadas. As próximas $N$ linhas descrevem as regiões cobertas pelas redes: cada uma contém quatro inteiros $X_i$ e $X_f$, $Y_i$ e $Y_f$ . A região coberta pela rede em questão contém todo ponto ($X, Y$) tal que $X_i \leq X \leq X_f$ e $Y_i \leq Y \leq Y_f$.
#### Saída
A saída deve conter apenas uma linha contendo a área da região do mar realmente aproveitada pelos pescadores, ou seja, a área total da região do mar coberta por pelo menos uma rede de pesca.
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq X_i \leq X_f \leq 100$
* $1 \leq Y_i \leq Y_f \leq 100$ |
3,382 | 1170 | Batalha Naval | Médio | Tecnicas |
Batalha Naval é um clássico jogo de estratégia para dois jogadores. Cada jogador posiciona seus navios num grid 10 × 10, e cada rodada do jogo consiste em adivinhar as posições dos navios do adversário. Existem muitas variações das regras, mas tais regras são irrelevantes para esse problema. Estamos interessados num problema mais básico: Dada a lista dos navios e suas posições, você deve determinar se o posicionamento inicial é válido.
As linhas e colunas do tabuleiro são numeradas de 1 a 10, e os navios são posicionados na horizontal ou na vertical, ocupando uma sequência contígua de quadrados do tabuleiro. Para esse problema, um posicionamento é válido se:
* nenhuma posição é ocupada por mais de um navio e;
* todos os navios estão inteiramente contidos no tabuleiro.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ ($1 \leq N \leq 100$), o número de navios. Cada uma das próximas $N$ linhas contém quatro inteiros $D$, $L$, $R$ e $C$ com $D \in \{0, 1\}$, $1 \leq L \leq 5$ e $1 \leq R, C \leq 10$ descrevendo um navio. Se $D = 0$ então o navio está alinhado horizontalmente, e ocupa as posições $(R, C)$. . . $(R, C + L - 1)$. Do contrário, o navio está alinhado verticalmente, e ocupa as posições $(R, C)$. . . $(R + L - 1, C)$.
#### Saída
Imprima uma única linha contendo um único caractere. Se o posicionamento inicial dos navios for válido, então imprima o caractere maiúsculo ‘$Y$’; do contrário, imprima o caractere maiúsculo ‘$N$’. |
3,383 | 536 | Balé | Difícil | Tecnicas | Uma academia de balé irá organizar uma Oficina de Balé Intensivo (OBI) na Semana de Balé Contemporâneo (SBC). Nessa academia, existem $N$ bailarinas que praticam regularmente. O dono da academia, por ser experiente, consegue medir o nível de habilidade de cada uma delas por um número inteiro; nessa medição, números maiores correspondem a dançarinas mais habilidosas, e os números obtidos são todos distintos. Além disso, ele possui uma lista das bailarinas em ordem cronológica de ingresso na academia: As bailarinas que aparecem primeiro na lista estão há mais tempo na academia, e as que estão no final ingressaram mais recentemente. O dono da academia decidiu escolher duas das bailarinas para ajudá-lo na realização do evento: uma ajudará no trabalho braçal, enquanto a outra irá exemplificar os passos de balé. Por seu perfeccionismo, ele deseja que a bailarina que exemplificará os passos de dança seja, dentre as duas meninas do par, a mais habilidosa e a que frequenta a academia há mais tempo.
Ele sabe que a Oficina será um sucesso desde que os dois critérios mencionados acima sejam satisfeitos pela dupla de dançarinas escolhidas. Com isso, ele ficou curioso para saber quantas duplas de dançarinas podem ajudá-lo na Oficina. A quantidade de dançarinas, contudo, é relativamente grande e ele não possui nem tempo nem paciência para fazer tal cálculo. Como vocês são amigos, ele pediu a sua ajuda para contar quantas duplas são válidas. Você pode ajudá-lo?
Por exemplo, digamos que a academia possua 5 dançarinas com níveis de habilidade 1, 5, 2, 4 e 3, onde a primeira, que possui nível 1, está na academia há mais tempo e a última, que possui nível 3, está há menos.
Temos, então, 4 possíveis duplas que poderemos usar nesta Oficina, que são (5, 2),(5, 4),(5, 3) e (4, 3). Note que a dupla (1, 3), por exemplo, não pode ser escolhida pelo dono da academia, pois a mais habilidosa dentre as duas é também a mais nova da dupla.
#### Entrada
A primeira linha contém um número $N$, que representa a quantidade de dançarinas que estão registradas na academia. A segunda linha da entrada contém $N$ inteiros, onde o primeiro inteiro é o nível da dançarina que está há mais tempo na academia, o segundo inteiro é o nível da próxima dançarina mais antiga na academia (mas mais nova que a dançarina anterior), e assim sucessivamente.
#### Saída
A saída consistirá num único número $X$, que representa o total de duplas de dançarinas válidas para essa Oficina, dadas as regras descritas anteriormente.
#### Restrições
* $1 \leq N \leq 100000$
* Todas as dançarinas possuirão níveis distintos, entre 1 e 100000.
* O total de pares válidos, em todos os casos, será $\leq 1 000000$
#### Informações sobre Pontuação
* Em um conjunto de casos de teste que totalizam 70 pontos, $N \leq 300$. |
3,384 | 650 | Saldo de Gols | Médio | Tecnicas | Hipólito é um torcedor fanático. Coleciona flâmulas, bandeiras, recortes de jornal, figurinhas de jogadores, camisetas e tudo o mais que se refira a seu time preferido. Quando ganhou um computador de presente em uma festa, resolveu montar um banco de dados com os resultados de todos os jogos de seu time ocorridos desde a sua fundação, em 1911. Depois de inseridos os dados, Hipólito começou a ficar curioso sobre estatísticas de desempenho do time. Por exemplo, ele deseja saber qual foi o período em que o seu time acumulou o maior saldo de gols. Como Hipólito tem o computador há muito pouco tempo, não sabe programar muito bem, e precisa de sua ajuda.
É dada uma lista, numerada sequencialmente a partir de 1, com os resultados de todos os jogos do time (primeira partida: 3 x 0, segunda partida: 1 x 2, terceira partida: 0 x 5 ...). Sua tarefa é escrever um programa que determine em qual período o time conseguiu acumular o maior saldo de gols. Um período é definido pelos números de seqüência de duas partidas, $A$ e $B$, onde $A \leq B$. O saldo de gols acumulado entre $A$ e $B$ é dado pela soma dos gols marcados pelo time em todas as partidas realizadas entre $A$ e $B$ (incluindo as mesmas) menos a soma dos gols marcados pelos times adversários no período. Se houver mais de um período com o mesmo saldo de gols, escolha o maior período (ou seja, o período em que $B - A$ é maior). Se ainda assim houver mais de uma solução possível, escolha qualquer uma delas como resposta.
#### Entrada
Seu programa deve ler vários conjuntos de teste. A primeira linha de um conjunto de teste contém um inteiro não negativo, $N$, que indica o número de partidas realizadas pelo time (o valor $N = 0$ indica o final da entrada). Seguem-se $N$ linhas, cada uma contendo um par de números inteiros não negativos $X$ e $Y$ que representam o resultado da partida: $X$ são os gols a favor e $Y$ os gols contra o time de Hipólito. As partidas são numeradas sequencialmente a partir de 1, na ordem em que aparecem na entrada.
#### Saída
Para cada conjunto de teste da entrada seu programa deve produzir três linhas na saída. A primeira linha deve conter um identificador do conjunto de teste, no formato “Teste n”, onde $n$ é numerado a partir de 1. A segunda linha deve conter um par de inteiros $I$ e $J$ que indicam respectivamente a primeira e última partidas do melhor período, conforme determinado pelo seu programa, exceto quando o saldo de gols do melhor período for menor ou igual a zero; neste caso a segunda linha deve conter a expressão “nenhum”. A terceira linha deve ser deixada em branco. A grafia mostrada no Exemplo de Saída, abaixo, deve ser seguida rigorosamente.
#### Restrições
* $0 \leq N \leq 10000$ ($N = 0$ apenas para indicar o fim da entrada)
* $1 \leq A \leq N$
* $A \leq B \leq N$
* $0 \leq X \leq 50$
* $0 \leq Y \leq 50$ |
3,385 | 1086 | Torre de Dados | Difícil | Tecnicas |
Hortência está brincando de construir uma torre com dados de seis faces. Os dados são similares aos dados comuns utilizados em jogos, com as faces estampadas com valores de 1 a 6. Mas os dados usados por Hortência têm uma grande diferença em relação aos dados comuns: enquanto em dados comuns a soma dos valores em faces opostas é sempre sete, para os dados de Hortência os valores em faces opostas nem sempre têm soma sete.
Hortência está criando a torre empilhando os seus dados, obedecendo às seguintes regras:
1. Seja $X$ dado que está colocado imediatamente em cima de um dado $Y$. Então o valor da face inferior de $X$ deve ser igual ao valor da face superior de $Y$. Por exemplo, se a pilha tem três dados $R$, $S$ e $T$, empilhados nessa ordem de baixo para cima, então o valor da face superior de $R$ deve ser igual ao valor da face inferior de $S$, e o valor da face superior de $S$ deve ser igual ao valor da face inferior de $T$.
2. Os dados devem ter suas laterais alinhadas, ou seja, a torre formada tem exatamente quatro lados, correspondendo aos lados dos dados.
Hortência quer criar uma torre tal que a soma dos valores de um dos lados da torre seja a maior possível. Note que após empilhar os dados obedecendo à regra (1), Hortência pode girar cada dado horizontalmente de forma independente, obedecendo à regra (2), para alterar os valores das somas dos lados.
Dadas as informações sobre os dados utilizados na torre, escreva um programa para determinar o maior valor possível para a soma de um dos lados da torre.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de dados. Cada uma das $N$ linhas seguintes descreve um dado e contém seis inteiros $A$, $B$, $C$, $D$, $E$ e $F$, identificando os valores dos lados do dado, conforme a figura abaixo.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o maior valor possível para a soma de um dos lados da torre.
#### Restrições
* 1 $\leq\ N\ \leq$ 1000
* 1 $\leq\ A,\ B,\ C,\ D,\ E,\ F\ \leq$ 6, todos distintos em um dado.
**Obs:** Esse exercício teve duas interpretações oficiais. Os casos de teste dessa versão do exercício consideram a torre com os dados na ordem da entrada.
|
3,386 | 906 | Human Learning | Médio | Tecnicas | Está na hora da maratona de programação, uma competição onde times de <b>NO MÁXIMO K</b> pessoas participam para decidir quem consegue achar a maior quantidade de números primos.
O coach de uma faculdade de $N$ alunos, cada um com uma habilidade $Si$, quer montar os times representantes de modo que a sua faculdade ganhe a maior pontuação possível.
* A habilidade de um time é a soma da habilidade de todos os seus integrantes.
* A pontuação de uma faculdade é a soma da habilidade de todos os times.
Contudo, o coach percebeu uma coisa, a pessoa mais experiente de um time tende a repassar seu conhecimento à todos os outros colegas de time! Sendo assim, se duas pessoas, um com habilidade 7, e outro com habilidade 15 estiverem no mesmo time, eventualmente ambos terão habilidade 15.
Eis o plot twist, você é o coach dessa faculdade! Dado a quantidade de alunos e suas habilidades, diga a maior pontuação possível a ser adquirida pela faculdade.
#### Entrada
A primeira linha consiste em dois inteiros $N$ e $K$, indicando a quantidade de alunos que estão na faculdade e o tamanho MÁXIMO de um time, respectivamente.
A segunda linha consiste de $N$ inteiros, indicando a habilidade $Si$ do i-ésimo aluno.
#### Saida
A saída deve conter um único inteiro, contendo a maior pontuação possível que a faculdade pode conquistar.
#### Restrições
$1\leq K\leq N \leq 10^5$
$1 \leq Si \leq 10^9$
#### Explicação do primeiro caso teste
Formando dois times, o primeiro com os alunos 1, 2, 4, 5 de habilidades 3, 10, 2 e 3 respectivamente.
O de habilidade 10 passará seu conhecimento, logo todos terão habilidade 10 no fim.
Sendo assim a pontuação desse time é 10 + 10 + 10 + 10 = 40.
O último time constitui apenas do aluno 3, cuja a habilidade é 3, sendo assim o seu time tem pontuação 4.
Logo, a maior pontuação da faculdade é 40 + 3 = 43. |
3,387 | 1055 | Diária | Médio | Tecnicas | Samyra adora viajar e planeja fazer uma viagem em suas férias. No destino desejado, ela pretende hospedar-se em um hotel específico. Porém, o valor da diária desse hotel não é fixo, e pode ou não mudar a cada dia. No site do hotel é possível verificar, a partir do primeiro dia de férias, quantos dias seguidos possuem a mesma diária e qual o seu valor. Samyra é muito econômica e quer saber quanto gastará se hospedando neste hotel do dia $X$ ao $Y$(inclusive os mesmos).
#### Entrada
A primeira linha de entrada contém um inteiro $N$.
Cada uma das próximas $N$ linhas possuem dois inteiros $K$ e $P$ representando, respectivamente, a quantidade de dias seguidos que possuem a mesma diária e o valor de cada diária, ou seja, em cada um dos $K$ dias seguintes a diária irá custar $P$ reais.
A linha seguinte contém um inteiro $Q$, o número de consultas.
Cada uma das próximas $Q$ linhas possui dois inteiros $X$ e $Y$ representando o primeiro e o último dia, respectivamente, de um intervalo de dias que Samyra quer consultar o preço da hospedagem. No Exemplo de entrada 1 que pode ser encontrado abaixo em Exemplos , os intervalos que Samyra quer consultar são do dia 1 ao 5, do dia 2 ao 4 e do dia 4 ao 7.
#### Saída
Sua saída deve conter, para cada intervalo de $X$ a $Y$ (inclusive), um inteiro representando o valor que Samyra gastará hospedando-se neste hotel nesse intervalo de dias.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq$ Soma de todos os $K\ \leq 10^5$
* $1 \leq P \leq 10^9$
* $1 \leq Q \leq 10^4$
* $1 \leq\ X\ \leq\ Y\ \leq$ Soma de todos os $K$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 15 pontos, $Q \leq 100$ e $P \leq 10^3$.
* Em um conjunto de casos de teste somando 25 pontos, para todas as $Q$ consultas $X\ = \ 1$ e $1 \leq Y \leq$ Soma de todos os $K$.
* Em um conjunto de casos de teste somando 40 pontos, para todas as $N$ linhas $P \leq 10^3$.
* Em um conjunto de casos de teste somando 20 pontos, nenhuma restrição adicional. |
3,388 | 2387 | Martelo do Veigola | Difícil | Tecnicas | Veigola é um jovem que adora jogar craftMine e construir casas magníficas em seu mundo virtual. Nosso grande aventureiro acabou de construir uma casa das boas, mas ainda falta terminar seu acabamento.
Para fazer o acabamento da casa ficar impecável, Veigola precisa ter vários Martelos de Diamante e ele mesmo vai craftá-los (construí-los). Na verdade, ele quer fazer a maior quantidade de Martelos de Diamante que ele conseguir.
Para fazer um Martelo de Diamante, ele precisa de exatamente $6$ diamantes e $1$ graveto. Ou seja, com $18$ diamantes e $3$ gravetos, ele consegue fazer $3$ Martelos, enquanto com $19$ diamantes e $2$ gravetos, ele consegue fazer apenas $2$, pois faltaria $1$ graveto (isso sem considerar as trocas com o aldeão que serão explicadas em seguida).
A figura abaixo mostra o craft de um martelo de diamante: $6$ diamantes e $1$ graveto.
Para a sorte de Veigola, um Aldeão (Huh) realiza trocas envolvendo diamantes e gravetos:
* $4$ gravetos por $1$ diamante (Veigola dá $4$ gravetos e ganha $1$ diamante)
* $1$ diamante por $4$ gravetos (Veigola dá $1$ diamante e ganha $4$ gravetos)
* Ele pode realizar quantas trocar quiser.
Considando as trocas, se Veigola tiver $19$ diamantes e $2$ gravetos, ele consegue fazer $3$ machados, pois ele pode realizar $1$ troca diamante $\rightarrow$ gravetos, ficando com $18$ diamantes e $6$ gravetos.
Sabendo o número inicial $D$ de diamantes e $G$ de gravetos que o nosso aventureiro possui e dado que ele pode realizar as trocas, qual a maior quantidade de martelos de diamante que ele pode construir?
#### Entrada
A entrada possui apenas uma linha que contém os inteiros $D$ e $G$.
#### Saída
Escreva apenas um número na saída: a maior quantidade de martelos de diamante que ele pode construir.
#### Restrições
* $0 \leq D \leq 100$
* $0 \leq G \leq 100$
#### Informações sobre pontuação
* Para um conjunto de casos de teste valendo 40 pontos, $G = 0$
* Para um conjunto de casos de teste valendo 60 pontos, sem restrições adicionais.
|
3,389 | 89 | Ginástica | Difícil | Tecnicas | Vinícius gosta muito de se exercitar na academia de ginástica. Ele fez um acordo com o seu treinador para ter programas de exercícios diferentes a cada vez que usar a bicicleta ergométrica. Um programa, na linguagem das academias, é uma sequência de níveis de dificuldade do exercício. Os programas de Vinícius para a bicicleta ergométrica devem ter a mesma duração em minutos e os níveis de dificuldade devem mudar a cada minuto, para um nível imediatamente acima ou um nível imediatamente abaixo. Os níveis de dificuldade não podem estar abaixo de um mínimo e nem acima de um máximo previamente estipulados.
Seu problema é calcular o número de programas diferentes que o treinador pode construir, obedecidas as restrições acima.
#### Entrada
A entrada consiste de uma única linha que contém três inteiros, $T$, $M$, $N$ ($1 \leq T \leq 50$ , $1 \leq M < N \leq 10^5$ ) em que $T$ é o número de minutos do exercício, $M$ é o valor mínimo de dificuldade permitido e $N$ é o valor máximo de dificuldade permitido.
#### Saída
Seu programa deve produzir uma única linha com um inteiro representando o número de programas diferentes que o treinador pode construir. Como esse número pode ser grande, a resposta deve ser esse número módulo $10^9 + 7$.
|
3,390 | 599 | Ortografia | Difícil | Tecnicas | Um serviço de busca na Internet está preocupado com a crescente taxa de erros de ortografia de seus usuários, tornando mais difíceis as buscas por palavras chaves, que constantemente contêm erros de algumas letras, devidos a má digitação ou má ortografia.
O serviço funciona com base num dicionário de palavras. O usuário deve inserir uma palavra num campo de um formulário; o serviço então procura esta palavra no dicionário e retorna conteúdo que tenha relação com a palavra.
Para contornar o problema de ortografia, você foi contratado para fazer um programa que tenta adivinhar qual palavra o usuário pretendia procurar, independente de haver erros de ortografia nela.
Para este problema vamos definir a distância entre duas palavras $A$ e $B$ como sendo o número de operações, descritas abaixo, necessárias para transformar $A$ em $B$:
1. Retirar uma letra de $A$.
2. Adicionar uma letra a $A$, em qualquer posição.
3. Trocar qualquer letra de $A$ por outra letra, na mesma posição.
O serviço de busca definiu que a palavra $P$ fornecida pelo usuário pode se referir a uma palavra $D$ do dicionário se está a uma distância de no máximo 2 de $D$.
Exemplos:
* A palavra ‘tu’ pode se referir à palavra do dicionário ‘tubo’, realizando duas vezes a operação 2.
* A palavra ‘crto’ pode se referir à palavra do dicionário ‘corte’, realizando uma vez a operação 2 e uma vez a operação 3.
* A palavra ‘crto’ pode se referir à palavra do dicionário ‘curto’, realizando uma vez a operação 2.
* A palavra ‘hortgrafea’ não pode se referir à palavra do dicionário ‘ortografia’.
Você deve escrever um programa que, dado um dicionário de palavras, descubra para cada palavra fornecida pelo usuário a quais palavras do dicionário ela pode se referir, nas condições descritas acima.
#### Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha contém 2 inteiros $N$, $M$, representando respectivamente o número de palavras contidas no dicionário e o número de palavras a serem analisadas. Cada uma das $N$ linhas seguintes conterá uma palavra pertencente ao dicionário. Cada uma das $M$ linhas seguintes conterá uma palavra a ser analisada, fornecida pelo usuário. Cada palavra pode ter de 1 a 20 letras, contendo apenas letras de ‘a’ a ‘z’, minúsculas.
#### Saída
Seu programa deve imprimir, na saída padrão, $M$ linhas, sendo uma linha para cada palavra fornecido pelo usuário. Cada linha deve conter todas palavras do dicionário às quais a palavra fornecida pode se referir. No caso de haver mais de uma palavra em uma linha da resposta, elas devem ser separadas por um espaço em branco, aparecendo na ordem que elas foram dadas na entrada, como pode ser visto no exemplo de saída abaixo. No caso de não haver nenhuma palavra em uma linha da resposta, deixe-a em branco.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq M \leq 100$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 10$ e $M \leq 10$.
* Em um conjunto de casos de teste que totaliza 55 pontos, $N \leq 50$ e $M \leq 500$. |
3,391 | 2281 | Danoninho | Médio | Tecnicas | Leo Paes está numa festa da ICPC e pretende se divertir um pouco tomando o máximo de copos de danoninho que conseguir.
Na mesa central do salão existe uma fileira de $N$ copos, o copo $i$ tem $C_i$ mililitros de danoninho.
Pela tradição da universidade onde ele estuda, Leo deve beber de uma fileira continua de copos de danoninho, um atrás do outro (apenas uma vez). Ou seja, Leo deve escolher dois inteiros $l$ e $r$ e beber dos copos $l,l+1,...,r$, tomando $C_l,C_{l+1},...,C_r$ mililitros de danoninho.
Leonardo já se conhece muito bem, e sabe que se ele beber mais de $D$ mililitros de danoninho, ele vai passar mal, ou seja, ele pode beber no máximo $D$ mililitros de danoninho.
Sabendo disso, Leonardo quer beber a maior quantidade de copos possíveis sem passar mal e seguindo a tradição da sua universidade, mas ele está com preguiça de pensar muito, então pediu sua ajuda para saber qual a maior fileira de copos que ele pode beber sem ultrapassar $D$ mililitros.
É garantido que Leo consegue beber pelo menos um copo.
#### Entrada
A primeira linha contém 2 inteiros $N$ e $D$, que representam a quantidade de copos e o quanto de danoninho Leonardo pode tomar sem passar mal.
A segunda linha contém $N$ inteiros $C_1,C_2,...,C_N$, que representam quantos mililitros de danoninho tem em cada copo.
#### Saída
Imprima um único inteiro: a quantidade máxima de copos que Leo consegue beber sem passar mal.
#### Restrições
* $1 \leq N \leq 10^{5}$
* $1 \leq C_i \leq D \leq 10^9$
#### Informações Sobre Pontuação
* Para um conjunto valendo 20 pontos: $N \leq 10^2$ e $D \leq 10^5$
* Para um conjunto valendo 40 pontos, $N \leq 5*10^3$ e $D \leq 10^5$
* Para um conjunto valendo 40 pontos, $N \leq 10^5$ |
3,392 | 211 | Sequência | Difícil | Tecnicas | O professor da importante disciplina de Indução Matemática está tentando resolver uma versão generalizada de um problema muito tradicional: encontrar o valor máximo possível para a soma dos elementos de uma subsequência contígua de uma sequência de números inteiros quaisquer. Mais rigorosamente, dado uma sequência $S = [s_1, s_2, \ldots , s_N]$, onde $s_i$ é um número inteiro qualquer, para $1 \leq i \leq N$, maximizar <b>soma(i, j)</b> $= s_i + s_{i+1} + \ldots + s_j$ entre todos os possíveis pares $(i, j)$, onde $1 \leq i \leq j \leq N$.
Na versão do professor, entretanto, alguns elementos da sequência são especiais e estão marcados. Além da sequência marcada, são dadas como entrada duas cotas: $L$ e $H$, com $L \leq H$. O objetivo agora é encontrar o valor máximo possível para a soma dos elementos de uma subsequência contígua, que contenha pelo menos $L$ e no máximo $H$ elementos marcados.
Por definição, uma subsequência vazia (de zero elementos) tem soma igual a zero. Mas note que, como podemos ter uma cota inferior para o número de elementos marcados, a subsequência contígua de soma máxima pode ter soma negativa!
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $L$ e $H$, indicando respectivamente o número de elementos na sequência, a cota inferior $L$ e a cota superior $H$. A segunda linha contém $N$ inteiros $s_i$, para $1 \leq i \leq N$, definindo os elementos da sequência. A terceira linha contém $N$ inteiros $m_i$, para $1 \leq i \leq N$, indicando as marcas. Se o i-ésimo elemento está marcado, o valor é $m_i = 1$. Se não estiver marcado, $m_i = 0$.
#### Saída
Imprima um inteiro, representando o valor máximo possível para a soma dos elementos de uma subsequência contígua, que contenha pelo menos $L$ e no máximo $H$ elementos marcados.
#### Restrições
* $1 \leq N \leq 10^5$
* $0 \leq L \leq H \leq 20$
* $-10^3 \leq s_i \leq 10^3$, para $1 \leq i \leq N$
* O número de elementos marcados na sequência é maior ou igual a $L$; portanto sempre existe solução.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 15 pontos, $N \leq 10^2$.
* Para um conjunto de casos de testes valendo 30 pontos, $N \leq 10^4$. |
3,393 | 119 | Isósceles | Médio | Tecnicas | Os irmãos Sérgio e Luiz estavam brincando com cubinhos de madeira e queriam construir um muro, que acabou ficando incompleto, com as colunas tendo diferentes alturas, como nessa figura.
Eles decidiram agora que a brincadeira seria retirar cubinhos, sempre de cima para baixo nas colunas, de maneira que no final restasse apenas um triângulo isósceles de cubinhos. Eles podem apenas retirar cubinhos do muro, sem recolocar em outra coluna, e os triângulos têm que ser completos. A figura abaixo ilustra os cinco primeiros triângulos isósceles de cubinhos, do tipo que eles querem, com alturas 1, 2, 3, 4 e 5 respectivamente.
Dada a sequência de alturas das colunas do muro, seu programa deve ajudar Sérgio e Luiz a descobrir qual é a altura máxima que o triângulo poderia ter ao final. No muro da primeira figura, com 30 colunas de cubinhos, o triângulo mais alto possível teria altura igual a sete.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando o número de colunas do muro. A segunda linha contém $N$ inteiros $A_i$, indicando as alturas de cada coluna.
#### Saída
Seu programa deve produzir uma única linha com um inteiro $H$, representando a altura máxima que um triângulo poderia ter ao final.
#### Restrições
* $1 \leq N \leq 50000$
* $1 \leq A_i \leq N$
|
3,394 | 2383 | Medalhas | Médio | Tecnicas | Em uma determinada competição, os dois primeiros colocados ganham um prêmio: várias medalhas de uma certa cor e de vários tamanhos. Há medalhas de duas cores: azul e vermelho. O primeiro colocado deve receber a maior medalha e todas as outras medalhas da mesma cor da maior. O segundo colocado pega todas as medalhas da cor que sobrou.
Os organizadores já compraram as medalhas, todas de tamanhos distintos, mas decidiram que, para o segundo jogador não ficar triste, ele deveria ter, dentre todas as medalhas restantes, a segunda maior. Para resolver isso, eles vão descartar medalhas até que a maior medalha ainda não descartada seja de uma cor e a segunda maior seja de outra.
Como eles querem evitar desperdício, pediram para você calcular o menor número possível de medalhas descartadas. Então, dadas duas listas: uma com o tamanho das medalhas azuis e outra com o tamanho das medalhas vermelhas, calcule o menor número possível de medalhas a serem descartadas, considerando que você pode descartar qualquer medalha e quantas você quiser.
#### Entrada
A primeira linha contém dois inteiros: $A$ e $V$, o número de medalhas azuis e vermelhas, respectivamente.
A segunda linha contém $A$ inteiros $a_1,a_2,..,a_A$: os tamanhos das medalhas azuis.
A terceira linha contém $V$ inteiros $v_1,v_2,..,v_V$: os tamanhos das medalhas vermelhas.
As medalhas são todas de tamanhos distintos, mesmo tendo cores diferentes.
#### Saída
Imprima uma única linha: o menor número possível de medalhas descartadas.
#### Restrições
$1\leq A,V\leq10^5$
$1\leq A_i,V_i\leq10^9$ |
3,395 | 506 | Vende-se | Difícil | Tecnicas |
A Otacílio Busílis Imóveis (OBI) é a maior imobiliária de Nlogópolis, especializada no aluguel de prédios comerciais; todas as suas propriedades se localizam na Avenida Doutor Otacílio Busílis, assim chamada em homenagem ao fundador da OBI.
Devido à crise econômica mundial, a OBI precisa vender $K$ de seus imóveis para levantar capital de giro.
Dr. Otacílio quer que os prédios restantes após a venda sejam o mais próximos possível - ou seja, a distância entre o primeiro e o último prédios restantes deve ser a menor possível. Infelizmente, a OBI é proprietária de tantos prédios que o Dr. Otacílio não sabe quais prédios ele deve vender; ele lhe contratou para que você escreva um programa que determina qual é a mínima distância possível entre o primeiro e o último prédios da OBI na avenida, após a venda de $K$ prédios.
#### Entrada
A primeira linha da entrada contém os inteiros $N$ e $K$, indicando, respectivamente, quantos prédios a OBI possui, e quantos prédios ela pretende vender. A linha seguinte contém $N$ inteiros $X_i$, indicando a distância de cada um dos $N$ prédios ao início da avenida, em metros.
#### Saída
A saída deve conter um único inteiro indicando a menor distância possível entre o primeiro e o último prédio possuídos pela OBI após a venda.
#### Restrições
* $3 \leq N \leq 10^5$
* $N - K \geq 2$
* $1 \leq X_i \leq 10^6$
* todos os $X_i$ são distintos
#### Informações sobre a pontuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 10$.
* Em um conjunto de casos de teste que totaliza 70 pontos, $N \leq 2000$. |
3,396 | 40 | Taxa | Difícil | Tecnicas | Uma empresa está construindo um condomínio de casas ao redor de um lago. As casas serão construídas em lotes de terra de diferentes tamanhos, mas todos os lotes serão às margens do lago. Além disso, cada lote de terra terá exatamente dois vizinhos no condomínio, um vizinho à direita e um vizinho à esquerda.
A empresa é dona de todo o terreno do condomínio e necessita dividir o terreno em lotes, de acordo com o projeto do condomínio. No entanto, a Prefeitura tem uma lei curiosa de imposto sobre divisão de terra, criada para inibir a criação de lotes de terra muito pequenos:
1. um terreno pode ser dividido apenas usando uma sequência de divisões de terreno;
2. uma divisão de terreno é uma operação que divide um terreno em duas partes; e
3. para cada divisão de terreno deve ser pago um imposto.
Chamando de $A$ a área da maior parte de terreno resultante da divisão, o valor do imposto sobre a divisão de terra é $A × F$, onde $F$ é o fator de divisão, definido anualmente pela Prefeitura. Note que devido a (2), para dividir um terreno em $N$ lotes, são necessárias $N-1$ divisões de terra, e portanto $N-1$ pagamentos devem ser feitos à Prefeitura.
Por exemplo, considerando a figura acima, se o fator de divisão é 2.5 e a primeira divisão de terreno separa o lote com 500 unidades de área dos outros lotes, o imposto a ser pago nesta primeira divisão é 2.5×(300+200+100+100+100). Se a próxima divisão de terreno separa dos lotes restantes o lote de 300 unidades junto com seu lote vizinho de 100 unidades, um imposto adicional de 2.5×(300 + 100) deve ser pago; e assim por diante. Note também que algumas divisões de terra não são possíveis, devido a (2). Por exemplo, após a primeira divisão de terreno mencionada anteriormente não é possível fazer uma divisão para separar a área formada pelo lote de 300 unidades e o lote de 200 unidades da área formada pelos três lotes restantes, porque mais do que duas partes resultariam dessa operação.
Dadas as áreas de todos os lotes ao redor do lago e o valor corrente do fator de divisão, escreva um programa para determinar o menor valor de imposto total que deve ser pago para dividir a terra de acordo com o projeto de condomínio.
#### Entrada
A primeira linha contém um número inteiro $N$ e um número real $F$, indicando respectivamente o número de lotes no condomínio e o fator de divisão (com precisão de dois dígitos). A segunda linha contém $N$ números inteiros $X_i$ , representando as áreas de lotes vizinhos no projeto do condomínio, para $1 \leq i \leq N$, sendo que $X_k$ é vizinho de $X_{k+1}$ para $1 \leq k \leq N-1$, e $X_N$ é vizinho de $X_1$.
#### Saída
Seu programa deve produzir uma única linha na saída, contendo o valor mínimo do imposto a ser pago, como um número real com precisão de dois dígitos decimais.
#### Restrições
* $1 \leq N \leq 200$
* $0 \leq F \leq 5.00$
* $0 < X_i \leq 500$, para $1 \leq i \leq N$ |
3,397 | 2127 | Caminho | Médio | Tecnicas | A pista de treinos de corridas da Prefeitura tem formato circular, com $N$ postes igualmente espaçados na circunferência da pista, cada poste com exatamente uma lâmpada. Atualmente há lâmpadas de várias potências luminosas nos postes.
Vamos chamar o trecho de pista entre duas lâmpadas adjacentes (ou seja, uma vizinha à outra) de trecho escuro se a soma das potências luminosas dessas duas lâmpadas é menor do que 1000.
Para justificar um pedido à Prefeitura para que troquem as lâmpadas, os atletas querem saber qual o maior número de trechos escuros consecutivos (ou seja, um imediatamente em seguida de outro) da pista. Você pode ajudá-los?
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de postes. Cada uma das $N$ linhas seguintes contém um inteiro $P_i$, a potência luminosa de uma lâmpada. A posição de cada lâmpada é dada pela ordem da entrada (ou seja, a ordem das lâmpadas ao longo da pista é a ordem dada na entrada).
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o maior número de trechos escuros consecutivos.
#### Restrições
• $2 ≤ N ≤ 500$ $000$
• $1 ≤ P_i ≤ 1$ $000$ para $i ≤ i ≤ N$
#### Informações sobre a pontuação
• Para um conjunto de casos de testes valendo 40 pontos, $P_1 + P_N ≥ 1$ $000$.
_Explicação do exemplo 1:_ O maior (e único) caminho de pares de lâmpadas com potência luminosa abaixo do especificado é formado pelos pares (499,500), (500, 499) e (499, 499), portanto a resposta é 3.
_Explicação do exemplo 2:_ O único par de lâmpadas com potência luminosa abaixo do especificado é (700,100), portanto a resposta é 1.
_Explicação do exemplo 3:_ O maior (e único caminho) com pares de lâmpadas com potência menor do que o especificado é formado pelos pares (290,700), (700,200), (200,400) e (400,500), portanto a resposta é 4.
_Explicação do exemplo 4:_ Não há nenhum par de lâmpadas com potência abaixo do especificado, portanto a resposta é 0.
_Explicação do exemplo 5:_ O maior (e único caminho) com pares de lâmpadas com potência menor do que o especificado é formado pelos pares (100,101) e (101,100), portanto a resposta é 2. |
3,398 | 425 | Programa de Auditório | Difícil | Tecnicas | Dilson está participando de um programa de auditório que testa sua sorte e suas habilidades de cálculo. O jogo é uma versão modificada do jogo de cartas vinte-e-um. O apresentador tem várias cartas com números, numa ordem fixa, e mostra-as uma a uma para Dilson, que pode escolher ficarcom a carta ou descartá-la. A decisão de descartar um número é irreversível. Dilson quer coletar um conjunto de cartas cujos números somem exatamente $X$.
Para tornar o programa de auditório mais emocionante, o jogo recompensa ter “sangue-frio”. Quanto mais Dilson esperar até pegar uma carta, mais arriscado o jogo fica, pois encontrar uma solução pode se tornar impossível se Dilson esperar demais. Dizemos que uma solução é a mais fria se ela espera o máximo possível até selecionar uma carta, depois espera o máximo possível até selecionar uma segunda carta, e assim por diante. O objetivo de Dilson é encontrar a solução mais fria possível.
Você está nos bastidores desse programa e sabe a ordem em que as cartas vão aparecer. Determine se é possível obter a soma $X$ e, em caso afirmativo, determine a solução mais fria possível.
#### Entrada
A primeira linha contém dois inteiros $N$ e $X$ com o número de cartas que aparecerão e a soma desejada. A segunda linha contém $N$ inteiros representando os números escritos na carta.
#### Saída
A primeira linha da sua saída deverá conter o caractere ‘S’, caso haja um modo de obter soma $X$, ou ‘N’ caso contrário. Na segunda linha, você deve imprimir inteiros separados por espaço, correspondentes aos índices, em ordem crescente e indexados por zero, das cartas escolhidas.
#### Restrições
As restrições do exercício deve ser informada através de listas, conforme o exemplo abaixo:
* $1 \leq N \leq 250$
* As cartas tem valores de $1$ a $250$.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 40 pontos, $1\leq N \leq 50$ e as cartas têm valores de $1$ a $50$, e sua resposta será considerada correta se a primeira linha (‘S’ ou ‘N’) estiver correta. Não é necessário imprimir uma segunda linha nessa subtarefa. (NÃO FUNCIONA POIS REQUER UM CORRETOR MAIS COMPLEXO)
* Para um conjunto de casos de testes valendo 40 pontos, $1\leq N\leq 50$ e as cartas têm valores de $1$ a $50$.
* **OBS: No Neps não há garantia do funcionamento das pontuações parciais para esse problema.** |
3,399 | 1469 | Iguais | Médio | Tecnicas |
O mais popular dos parques do estado do Acre, situado na capital Rio Branco, é o parque que foi nomeado em homenagem ao ambientalista Chico Mendes.
Sendo uma área de preservação ambiental, a natureza é bem conservada e pode ser apreciada em trilhas pelo meio da mata.
Há um parquinho com brinquedos ótimos para as crianças, além de um mini zoológico com algumas espécies protegidas.
Por sua grande popularidade, os comerciantes fazem sucesso vendendo artesanatos típicos da região.
Nas trilhas é possível ver pilhas de pedras pequenas com quantidades variadas e colocadas lado a lado. A uniformidade das pedras com as quais são formadas é tanta que surgiu um boato de que se você recolher $X$ pedras antes de fazer a trilha e conseguir distribuir *todas* entre as pilhas existentes de forma a torná-las iguais, ou seja, todas as pilhas com a mesma quantidade de pedras, você terá boa sorte.
Sabendo disso, faça um programa que dada a quantidade $X$ e os tamanhos das pilhas diga se é possível obter boa sorte.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, a quantidade de pilhas encontradas na trilha.
A segunda linha contém $N$ inteiros $Ai$ separados por um espaço em branco. O $i$-ésimo inteiro dessa linha representa o número de pedras na $i$-ésima pilha.
A terceira linha da entrada contém o inteiro $X$, a quantidade de pedras que deseja distribuir entre as pilhas existentes.
#### Saída
A saída consiste de uma única linha contendo a mensagem "Boa Sorte" caso seja possível deixar todas as pilhas iguais, ou a mensagem "Sem Sorte", em caso contrário.
#### Restrições
* $1 \leq N \leq 10^{6}$
* $1 \leq Ai \leq 10^3$
* $0 \leq X \leq 10^9$
|
Subsets and Splits
Random Sample Across Categories
Selects a random sample of up to 4 questions from each category and difficulty level, providing a basic overview without deep insight.