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 |
|---|---|---|---|---|---|
2,800 | 2232 | Praticando compreensão de listas | Fácil | Estruturas | O código abaixo recebe uma lista de inteiros e os armazena na variável **lista_de_inteiros**.
Você deve completar o código para criar uma nova lista, chamada **resultado**. Para cada item em **lista_de_inteiros**, esse valor deve ser adicionado em **resultado**, **multiplicado por 2 se for par e multiplicado por 3 caso contrário**.
```py
lista_de_inteiros = map(int, input().split())
resultado = #TODO
print(resultado)
```
#### Entrada
A entrada consiste em uma única linha, que contém vários inteiros separados por espaço
#### Saída
A saída consiste apenas de 1 linha, contendo a lista **resultado**.
|
2,801 | 117 | Go-- | Difícil | Estruturas | Go-- é até parecido com o tradicional jogo de Go, mas é bem mais fácil! Ele é jogado em um tabuleiro quadrado de dimensão $N$, inicialmente vazio, no qual dois jogadores, um jogando com as pedras pretas e o outro com as brancas, se alternam colocando uma pedra por vez dentro de qualquer célula que ainda não esteja ocupada. A partida termina depois que cada jogador colocou $P$ pedras no tabuleiro. Considere todas as possíveis sub-áreas quadradas de dimensão de 1 a $N$. Uma sub-área pertence ao jogador que joga com as pedras pretas se ela contém pelo menos uma pedra preta e nenhuma pedra branca. Da mesma forma, uma sub-área quadrada pertence ao jogador que joga com as pedras brancas se contém ao menos uma pedra branca e nenhuma pedra preta. Note que as áreas que não contenham nenhuma pedra, ou que contenham tanto pedras pretas quanto brancas, não pertencem a nenhum jogador.
Neste problema, dada a posição final do tabuleiro, seu programa deve computar quantas sub-áreas quadradas pertencem a cada jogador, para descobrir quem ganhou a partida. Na figura, as pretas possuem 12 sub-áreas (cinco de dimensão 1, seis de dimensão 2 e uma de dimensão 3). As brancas, que perderam a partida, possuem apenas 10.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $P$, representando, respectivamente, a dimensão do tabuleiro e o número de pedras que cada jogador coloca. Cada uma das $P$ linhas seguintes contém dois inteiros $L$ e $C$ definindo as coordenadas (linha, coluna) das pedras pretas. Depois, cada uma das próximas $P$ linhas contém dois inteiros $L$ e $C$ definindo as coordenadas (linha, coluna) das pedras brancas. Todas as pedras são colocadas em células distintas.
#### Saída
Imprima uma linha contendo dois inteiros separados por um espaço: quantas áreas distintas pertencentes às pretas e às brancas.
#### Restrições
* $2 \leq N \leq 500$
* $2 \leq P \leq 500$
* $P \leq N/2$
* $0 \leq L, C \leq N$
|
2,802 | 2230 | Quantidade de Inteiros Diferentes | Fácil | Estruturas | Faça um programa que leia $N$ inteiros e imprima a **quantidade de inteiros diferentes** inseridos. Isto é, se um inteiro $K$ for inserido 2 vezes, ele só deve ser contado uma única vez.
#### Entrada
A primeira linha contém um inteiro $N$. Cada uma das $N$ linhas seguintes possui um inteiro $M$.
#### Saída
Seu programa deve produzir 1 única linha contendo a quantidade de inteiros diferentes inseridos.
|
2,803 | 130 | Recompensas do Hotel | Difícil | Estruturas | Você está planejando passar suas férias de turismo na Europa, ficando cada noite em uma cidade diferente para $N$ noites consecutivas. Você já escolheu o hotel que deseja ficar em cada cidade, para que você saiba o preço $P_i$ do quarto que você vai ficar durante a noite i-th de suas férias, para $i = 1 ,\ldots N$.
Você vai reservar o seu alojamento através de um site que tem um programa de recompensas muito conveniente, que funciona da seguinte forma. Depois de ficar por uma noite em um hotel que você reservou através deste site você é premiado com um ponto, e a qualquer momento você pode trocar $K$ desses pontos em sua conta para uma noite livre em qualquer hotel (que no entanto não dar-lhe outro ponto).
Por exemplo, considere o caso com $N$ = 6 e $K$ = 2 onde os preços para os quartos são $P_1 = 10, P_2 = 3, P_3 = 12, P_4 = 15, P_5 = 12$ e $P_6 = 18$. Depois de pagar pela primeira Quatro noites você teria quatro pontos em sua conta, que você poderia trocar para ficar gratuitamente as duas noites restantes, pagando um total de $P_1 + P_2 + P_3 + P_4 = 40$ para o seu alojamento. No entanto, se após as três primeiras noites você usar dois dos três pontos que você ganhou para ficar a quarta noite de graça, então você pode pagar a quinta noite e usar os dois últimos pontos para obter o sexto gratuitamente. Neste caso, o custo total do seu alojamento é $P1 + P2 + P3 + P5 = 37$, por isso esta opção é realmente mais conveniente.
Você quer fazer um programa para descobrir qual o custo mínimo possível para a acomodação de suas férias é. Você pode assumir com segurança que todos os hotéis que você quer ficar sempre terá um quarto disponível para você, e que a ordem das cidades que você vai visitar não pode ser alterada
#### Entrada
A primeira linha de entrada contém dois números inteiros $N$ e $K$, representando o número total de noites que as suas férias vão durar eo número de pontos que você precisa para obter uma noite livre.
A segunda linha contém $N$ inteiros $P_1, P_2,\ldots , P_N$, representando o preço dos quartos que você vai ficar durante as suas férias.
#### Saída
A saída contém uma linha com um número inteiro que represente o custo mínimo de sua acomodação para todas as suas férias.
#### Restrições
* $1 \leq N, K \leq 10^5$
* $1 \leq P_i \leq 10^4$ para $i = 1, 2, ...,N$ |
2,804 | 617 | Autorama | Difícil | Estruturas | Seu Diniz possui uma pista de autorama profissional. Nessa pista a marcação de tempo é feita com sensores que fazem leitura da passagem de cada cada carrinho pelo ponto onde o sensor está instalado. $K$ sensores são distribuídos ao longo da pista nos chamados postos de checagem.
Durante uma corrida, os carrinhos devem passar pelos postos de checagem na ordem pré-estabelecida, ou seja, primeiro no posto de checagem 1, depois no 2, até o posto de checagem $K$, quando ele deve retornar ao posto de checagem 1 para completar uma volta. Entretanto, às vezes, quando os carrinhos saem da pista os competidores os recolocam mais à frente na pista, pulando alguns postos de checagem. Nesse caso, todas as passagens daquele carrinho por postos de checagem devem ser ignoradas até que ele passe pelo posto de checagem correto.
A posição de um carrinho na corrida é determinada pelo número de postos de checagem que ele passou na ordem correta. Caso dois carrinhos tenham passado pelo mesmo número de postos de checagem, a ordem utilizada é a ordem cronológica, ou seja, está mais à frente o carrinho que passou pelo último posto de checagem primeiro.
A pista de autorama do Seu Diniz possui um computador central que recebe os sinais lidos pelos sensores, mas ainda não possui um programa que permita determinar a posição dos carrinhos ao final da corrida.
Escreva um programa que, dado uma lista de leituras feitas pelos sensores, determine a classificação dos carrinhos na corrida.
#### 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 três inteiros, $K$, $N$ e $M$. $K$ representa o número de postos de checagem, $N$ o número de carrinhos e $M$ o número de leituras feitas pelos sensores. Os carrinhos são identificados por inteiros de 1 a $N$ e os postos de checagem por inteiros de 1 a $K$. As $M$ linhas seguintes contêm cada uma dois inteiros $X$ e $Y$, separados por espaço. Eles indicam que o carrinho número $X$ passou pelo posto de checagem $Y$. Os eventos são apresentados na ordem cronológica. Sempre é possível determinar a classificação de todos os pilotos com os dados fornecidos.
#### Saída
Seu programa deve imprimir, na saída padrão, uma linha contendo $N$ inteiros, sendo que o i-ésimo inteiro representa o carrinho que ocupa a posição $i$ na corrida. Ou seja, o primeiro inteiro é o que ocupa o primeiro lugar, o segundo inteiro é o carrinho que ocupa o segundo lugar, e assim por diante. cada inteiro $I$ contendo o número do carrinho que ocupa a posição de número $I$ na corrida: o primeiro colocado ocupa a posição de número 1, o segundo colocado a posição de número 2, etc.
#### Restrições
* $1 \leq K \leq 100$
* $1 \leq N \leq 100$
* $1 \leq M \leq 10000$
* $1 \leq X \leq N$
* $1 \leq Y \leq K$ |
2,805 | 1751 | Portões | Médio | Estruturas | Você ganhou um aeroporto de aniversário.
O aeroporto tem portões de $G$, numerados de 1 a $G$.
$P$ aviões chegam ao aeroporto, um após o outro. O $i$-ésimo avião deve atracar permanentemente em qualquer portão 1, . . $g_i (1\leq g_i\leq G)$, no qual nenhum avião anterior tenha atracado. Assim que um avião não conseguir atracar em nenhum portão, o aeroporto será fechado e nenhum avião futuro será autorizado a chegar.
A fim de manter feliz a pessoa que lhe deu o aeroporto, você gostaria de maximizar o número de aviões a partir do início que podem atracar em diferentes portões.
#### Entrada
A primeira linha de entrada contém $G (1 ≤ G ≤ 10^5)$, o número de portões no aeroporto.
A segunda linha de entrada contém $P (1 ≤ P ≤ 10 ^5)$, o número de aviões que pousarão.
As próximas $P$ linhas contêm um número inteiro $g_i (1\leq g_i \leq G)$, de tal forma que o $i$-ésimo avião deve atracar em algum portão de 1 a $g_i$, inclusive.
Note que para pelo menos 40% da pontuação desta pergunta, $P ≤ 2000$ e $G ≤ 2000$.
#### Saída
Produzir o número máximo de aviões que podem pousar a partir do início.
#### Explicação do Caso de Teste 1
O primeiro avião pode ir a qualquer lugar, mas é melhor não colocá-lo no Portão 1. Observe que os aviões 2 e 3 querem atracar no Portão 1, portanto, o avião 3 não consegue atracar.
#### Explicação do Caso de Teste 2
Os dois primeiros aviões atracarão nos portões 1 e 2 (em qualquer ordem). O terceiro avião deverá atracar no portão 3. Assim, o quarto avião não pode atracar em nenhum lugar, e o aeroporto está fechado, mesmo que o avião 5 tivesse podido atracar. |
2,806 | 1780 | Juntar | Fácil | Estruturas | uma sequência de inteiros positivos $A=(A_1, A_2, ... , A_N)$ com comprimento $N$ e uma sequência de inteiros positivos $B=(B_1, B_2, ... , B_N)$ de comprimento $M$ são dadas. Ambas as sequências estão ordenadas em ordem não decrescente. Ou seja, elas satisfazem $A_1 \leq A_2 \leq ... \leq A_N$ e $B_1 \leq B_2 \leq ... \leq B_M$.
O seguinte algoritmo é usado para gerar uma sequência $C=(C_1, C_2, ..., C_{N+M})$ de números inteiros positivos com comprimento $N+M$ a partir destas sequências:
* 1.Inicialmente, supõe-se que $C$ esteja vazio.
* 2.Terminar se ambos $A$ e $B$ estiverem vazios.
* 3. Se $A$ ou $B$ estiver vazio, $t$ é a sequência de números que não está vazia. Se nenhum dos dois estiver vazio, $t$ é a sequência cujo primeiro elemento é menor. Entretanto, se os primeiros elementos de $A$ e $B$ têm o mesmo valor, que $A$ seja $t$.
* 4.Adicione o primeiro elemento de $t$ ao final de C.
* 5.Eliminar o primeiro elemento do $t$.
* 6.Voltar para o passo 2.
Dada uma sequência de inteiros $A$ e $B$ positivos que estão ordenadas em ordem não decrescente, escreva um programa que produza a sequência de inteiros $C$ positivos gerados por este algoritmo.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N \ M$
$A_1 \ A_2 \ ... \ A_N$
$B_1 \ B_2 \ ... \ B_M$
#### Saída
Imprima $N + M$ linhas na saída padrão.
Na k-ésima linha ($1 \leq k \leq N + M$), imprima $C_k$.
#### Restrições
* $1 \leq N \leq 500$．
* $1 \leq M \leq 500$．
* $1 \leq A_1 \leq A_2 \leq … \leq A_N \leq 2000$．
* $1 \leq B_1 \leq B_2 \leq … \leq B_M \leq 2000$． |
2,807 | 1787 | Subsequente Contínua Crescente mais longa | Fácil | Estruturas | Dada uma sequência $A=(A_1, \ A_2, ..., \ A_N)$ de números inteiros positivos de comprimento $N$ Encontre o comprimento da subsequência crescente contínua mais longa da sequência inteira $A$.
Ou seja, encontre o comprimento da mais longa das duas subsequências de tal forma que $A_l \leq A_{l+1} \leq ... \leq A_r$. Para quaisquer dois inteiros $l, r \ ( 1 \leq l \leq r \leq N )$, e encontre o valor máximo de $r-l+1$.
#### Entrada
A entrada é dada pela entrada padrão na seguinte forma
$N$
$A_1 \ A_2 ... \ A_N$
#### Saída
Imprima o comprimento da subsequência crescente contínua mais longa de uma sequência de inteiros positivos $A$.
#### Restrições
* $1 \leq N \leq 100.$
* $1 \leq A_i \leq 2020 \ (1 \leq i \leq N).$ |
2,808 | 2317 | Chinelos | Fácil | Estruturas | Uma comunidade indígena produz chinelos de juta e criou um site para vender a produção online.
Os chinelos são de apenas um tipo, mas são produzidos em vários tamanhos.
Você foi contratado(a) para desenvolver um programa de controle de estoque para o site. O estoque pode ser visto como uma tabela com uma única linha, em que cada coluna representa um tamanho, como mostrado na figura (a) abaixo. Na figura, os tamanhos são representados por números de 1 a 5. Assim, a tabela da figura (a) informa que o estoque do chinelo de tamanho 1 é 4 unidades, e o estoque do chinelo de tamanho 4 é 3 unidades.
Quando um chinelo é vendido, o estoque deve ser atualizado. Por exemplo, se um chinelo de tamanho 1 for vendido, o estoque atualizado é mostrado na figura (b). Se o estoque para um tamanho de chinelo tem valor zero, chinelos desse tamanho não podem ser vendidos (por exemplo o chinelo de tamanho 3). Ou seja, a venda não é efetivada.
Dados o estoque inicial e a lista de pedidos de clientes, escreva um programa para determinar quantos chinelos são efetivamente vendidos no total. Cada pedido se refere a um único chinelo. As vendas são processadas sequencialmente, na ordem em que os pedidos foram feitos. Se uma venda não é possível por falta de estoque, o pedido correspondente é ignorado.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de tamanhos de chinelos no estoque. Tamanhos são identificados por inteiros de $1$ a $N$. Cada uma das N linhas seguintes contém $N$ inteiros $X_i$ , indicando a quantidade de chinelos de tamanho $i$, para $1 ≤ i ≤ N$. A seguir a entrada contém uma linha com um número inteiro P, o número de pedidos recebidos pela loja. Cada uma das P linhas seguintes contém um inteiro I representando o tamanho do chinelo de um pedido. Os pedidos são dados na ordem em que foram feitos.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número total de chinelos
efetivamente vendidos.
#### Restrições
* $1 ≤ N ≤ 500$
* $0 ≤ X_i ≤ 20$ para $1 ≤ i ≤ N$
* $1 ≤ P ≤ 1 000$
* $1 ≤ I ≤ N$
#### Informações sobre a pontuação
* A tarefa vale 100 pontos.
* Para um conjunto de casos de testes valendo 27 pontos, N ≤ 3.
* Para um conjunto de casos de testes valendo outros 73 pontos, nenhuma restrição adicional. |
2,809 | 1541 | Estimando a Velocidade do Velocista | Médio | Estruturas | Trick E. Dingo está a tentando, como de costume, apanhar o seu nêmesis, o Velocista de Rua. As suas tentativas passadas usando imãs, armadilhas e explosivos falharam miseravelmente, por isso está apanhando fôlego para recolher dados de observação e aprender mais sobre a velocidade do Velocista de Rua.
Trick E. Dingo e o Velocista de Rua habitam ambos uma única estrada reta oeste-leste com uma pedra particularmente famosa, conhecida carinhosamente como A Origem. As posições nesta estrada reta são medidas numericamente de acordo com a distância da Origem, usando números negativos para as posições a oeste da Origem e números positivos para as posições a leste da Origem.
As observações de Trick E. Dingo contém cada uma dois números: um tempo, e o valor da posição do Street Sprinter na estrada nesse momento. Dada esta informação, de que velocidade deve ser capaz o Velocista de Rua?
#### Entrada
A primeira linha contém um número $2 ≤N≤100000$, o número de observações que se seguem. As linhas seguintes $N$ contêm cada uma um número inteiro $0≤T≤1000000000$, indicando o tempo, em segundos, de quando foi feita uma medição, e um número inteiro $-1000000000≤X≤1000000000$, indicando a posição, em metros, do Velocista de Rua nessa ocasião. Não haverá duas linhas com o mesmo valor de $T$.
#### Saída
Produza um único número $X$, de tal forma que podemos concluir que a velocidade do Velocista de Rua foi de pelo menos $X$ metros/segundo em algum momento, e tal que $X$ é tão grande quanto possível. Se a resposta correta for $C$, o juiz verá $X$ como correto se $\frac{|X-C|}{C}<10^{-5}$.
#### Explicação da Saída para o Caso de Teste 1
Já que o Velocista correu da posição $100$ para a posição $120$ entre o tempo $0$ e o tempo $10$, sabemos que a sua velocidade deve ter sido pelo menos 2 em algum momento: se foi sempre inferior a $2$, então a distância de $20$ não pôde ser coberta em $10$ segundos. Da mesma forma, a velocidade deve ter sido de pelo menos $7$ para viajar entre a posição $120$ e $50$ em $10$ segundos. |
2,810 | 2438 | Intervalo Distinto | Médio | Estruturas | Você foi contratado pela Agência Extra-Espacial Brasileira, que procura indícios de vida extraterrestre. Um dos telescópios da Agência, para o espectro ultravioleta, gera uma sequência de valores inteiros positivos que devem ser analisados diariamente. Sua primeira missão é determinar, na sequência gerada, o tamanho do maior intervalo contínuo que contém apenas números distintos.
#### Entrada
A primeira linha contém um inteiro $N$, o número de elementos da sequência. Cada uma das linhas seguintes contém um inteiro $I_i$, os elementos da sequência na ordem em que foram gerados.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número de elementos do maior intervalo que contém apenas números distintos.
#### Restrições
- $1 \leq N \leq 10^5$
- $1 \leq I_i \leq 10^5$ |
2,811 | 2330 | Diferença de Idade | Médio | Estruturas | Uma cidade tem $N$ habitantes numerados de 1 a $N$. A idade do habitante $i \ (1 \leq i \leq N)$ é $A_i$ anos.
Dadas as idades $A_1, A_2, ... , A_N$ dos habitantes da cidade, escreva um programa para encontrar a diferença máxima de idade entre o habitante $i$ e os outros habitantes para $i = 1, \ 2, \ ... \ , \ N$.
#### Entrada
A entrada é dada da seguinte forma:
$N$
$A_1 \ A_2 \ ... \ A_N$
#### Saída
Na linha $i \ (1 \leq i \leq N)$, indicar a diferença máxima de idade entre o habitante $i$ e os outros habitantes.
#### Sub-tarefas
1. (33 pontos) $N = 2$.
2. (33 pontos) $N \leq 1 000$.
3. (33 pontos) Sem restrições adicionais.
#### Restrições
* $2 \leq N \leq 250 000$.
* $0 \leq A_i \leq 10^9 \ (1 \leq i \leq N)$.
* Todos os valores de entrada são inteiros.
##### Explicação do exemplo de entrada/saída 1:.
* A diferença de idade entre o habitante 1 e os habitantes 2 e 3 é de 2 e 7 anos, respetivamente. O valor máximo destes é 7 anos, por isso 7 é o valor de saída na primeira linha.
* A diferença de idade entre o habitante 2 e os habitantes 1 e 3 é de 2 e 5 anos, respetivamente. O valor máximo destes é 5 anos, por isso a segunda linha impressa é 5.
* A diferença de idade entre o habitante 3 e os habitantes 1 e 2 é de 7 e 5 anos, respetivamente. O valor máximo destes é 7 anos, por isso a terceira linha impressa é 7.
Este exemplo de entrada satisfaz as restrições das sub-tarefas 2 e 3. |
2,812 | 1345 | Handebol | Fácil | Estruturas |
Frustrado e desanimado com os resultados de sua equipe de futebol, o Super Brasileiro Clube (SBC) resolveu investir na equipe de handebol. Para melhor avaliar os atletas, os técnicos identificaram que seria útil analisar a regularidade dos jogadores. Especificamente, eles estão interessados em saber quantos jogadores fizeram gols em todas as partidas.
Como o volume de dados é muito grande, eles gostariam de ter um programa de computador para realizar essa contagem.
#### Input
A primeira linha da entrada contém dois inteiros $N$ e $M \ (1 \ \leq \ N \ \leq \ 100$ e $1 \ \leq \ M \ \leq \ 100)$, indicando respectivamente o número de jogadores e o número de partidas. Cada uma das $N$ linhas seguintes descreve o desempenho de um jogador: a i-ésima linha contém $M$ inteiros $X_j \ (0 \ \leq \ X_j \ \leq \ 100,$ para $1 \ \leq \ j \ \leq \ M )$, informando o número de gols do i-ésimo jogador em cada partida.
#### Output
Seu programa deve produzir uma única linha, contendo um único inteiro, o número de jogadores que fizeram gols em todas as partidas.
|
2,813 | 415 | Linhas de Metrô | Difícil | Estruturas | O sistema de metrô de uma grande cidade é formado por um conjunto de estações e por túneis que ligam alguns pares de estações. O sistema foi desenhado de forma que existe exatamente uma sequência de túneis ligando qualquer par de estações. As estações nas quais apenas um túnel chega são chamadas de terminais. Há várias linhas de trens que fazem viagens de ida e volta entre duas estações terminais, transitando pelo caminho único entre elas. A população está reclamando das linhas atuais e, por isso, o prefeito ordenou uma reformulação total das linhas. Como o sistema possui muitas estações, nós precisamos ajudar os engenheiros que estão tentando decidir quais pares de terminais passarão a definir uma linha.
A figura ilustra um sistema onde as estações terminais são mostradas como círculos preenchidos e as não-terminais são mostradas como círculos vazios. Na parte esquerda, veja que se o par ($A$,$B$) definir uma linha e o par ($C$,$D$) definir outra, elas não terão qualquer estação em comum. Mas, na parte direita, podemos ver que se os pares ($E$,$F$) e ($G$,$H$) definirem duas linhas, elas terão duas estações em comum.
Dada a descrição do sistema de túneis e uma sequência de Q consultas constituídas de dois pares de terminais, seu programa deve computar, para cada consulta, quantas estações em comum as linhas definidas pelos dois pares teriam.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ ($5 \leq N \leq 10^5$) e $Q$ ($1 \leq Q \leq 20000$), representando respectivamente o número de estações e o número de consultas. As estações são numeradas de 1 até $N$. Cada uma das $N -1$ linhas seguintes contém dois inteiros distintos $U$ e $V$, $1 \leq U, V \leq N$, indicando que existe um túnel entre as estações $U$ e $V$ . Cada uma das $Q$ linhas seguintes contém quatro inteiros distintos $A$, $B$, $C$ e $D$ ($1 \leq A, B, C, D \leq N$), representando uma consulta: as duas linhas de trem são definidas pelos pares ($A$, $B$) e ($C$, $D$).
#### Saída
Para cada consulta, seu programa deve imprimir uma linha contendo um inteiro representando quantas estações em comum teriam as duas linhas de trem definidas pela consulta.
|
2,814 | 1744 | Anagrama | Difícil | Estruturas | Mariazinha está na escola, e todo dia a professora envia uma tarefa para ela fazer em casa. Porém, muitas vezes fica difícil para a professora corrigir as suas tarefas, pois como Mariazinha está aprendendo a escrever, de vez em quando ela se confunde e acaba trocando as letras do alfabeto. Na cabeça dela, de alguma forma, as letras são embaralhadas, como no seguinte exemplo:
____________________________________**moto**
____________________________________**vaca**
Nesse exemplo, Mariazinha queria escrever a palavra moto, mas acabou escrevendo a palavra vaca. Isso aconteceu porque, na cabeça dela, o alfabeto se embaralhou da seguinte forma:
| a | b | c | d | e | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
:-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-: | :-:
| **t** | b | **o** | d | e | g | h | i | j | k | l | **v** | n | **a** | p | q | r | s | **c** | u | **m** | w | x | y | z
(A linha de cima é o alfabeto de original, a de baixo é o alfabeto de Mariazinha)
Podemos ver que, mesmo embaralhando as letras, nenhuma delas se repete. Logo, se Mariazinha substituir uma letra $L1$ por uma letra $L2$, a letra $L2$ também deverá ser substituída por outra letra (podendo ser $L1$ ou não). Nesse mesmo exemplo acima, podemos ver que a letra $‘o’$ foi substituída por $‘a’$, e $‘a’$ foi substituída por $‘t’$.
Esse “embaralhamento” pode ser diferente para cada palavra que Mariazinha escrever. Ou seja, se ela escrever duas palavras, pode ser que na primeira o embaralhamento seja de uma forma e na segunda ele seja de outra forma.
A última tarefa que a professora enviou para casa era a seguinte: Mariazinha deveria escrever uma lista com $N$ palavras e depois contar quantos pares de anagramas existiam nessa lista. Claro,a professora também explicou o que é um par de anagrama: duas palavras formam um par de anagrama se for possível pegar as letras da primeira palavra e reordená-las de forma a chegar na segunda palavra.
Ao pegar a tarefa de Mariazinha para corrigir, a professora teve muita dificuldade, já que Mariazinha embaralhou o alfabeto para escrever algumas das palavras. Ela então pensou em primeiro verificar qual seria o número máximo de possíveis pares de anagramas que poderiam ser formados considerando todas as possibilidades de “correspondência” das letras de Mariazinha. Por exemplo,se Mariazinha escreveu apenas duas palavras, ‘moto’ e ‘cava’, podemos dizer que essas duas palavras são um possível par de anagrama, pois se Mariazinha tiver embaralhado as letras da segunda palavra como no exemplo mostrado, a palavra original seria ‘tomo’, que é um anagrama de ‘moto’ (existem outros embaralhamentos que também nos levariam à mesma conclusão).
Ela percebeu que verificar isso sozinha é bastante trabalhoso. Você pode ajudá-la?
#### Entrada
A primeira linha de entrada contém um inteiro $N$, indicando o número de palavras que Mariazinha escreveu. Cada uma das próximas $N$ linhas possui uma palavra $S_i$, contendo apenas letras minúsculas, de tal forma que a linha de número $i$ contém a $i$-ésima palavra que Mariazinha escreveu.
#### Saída
Sua saída deve conter um inteiro $X$ representando o número máximo de possíveis pares de anagramas que podem existir nessa lista.
#### Restrições
* $2 \leq N \leq 10^5$
* $1 \leq $ tamanho de cada $S_i \leq 20$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando $10$ pontos, $N = 2$.
* Em um conjunto de casos de teste somando $50$ pontos, $N \leq 10^3$.
* Em um conjunto de casos de teste somando $40$ pontos, nenhuma restrição adicional.
|
2,815 | 360 | Doce de Banana | Difícil | Estruturas | Iara faz deliciosos doces de banana, que são um sucesso em sua cidade. Todos os dias ela vai a feira e compra bananas frescas para preparar seus doces, que são feitos por encomenda.
Iara tem uma lista de quantas latas de doce devem ser feitas em cada um dos próximos $N$ dias. Cada lata de doce precisa de uma banana para ser feita. Para manter a qualidade de seus doces, Iara usa apenas bananas frescas. Uma banana é fresca se ela foi comprada no dia atual ou no anterior. A quantidade disponível e preço das bananas na feira varia a cada dia. O dono da feira informou a Iara a quantidade de bananas a venda e seu preço para cada um dos $N$ dias seguintes.
Iara pediu sua ajuda para saber se ela conseguirá fazer as encomendas, e qual o menor valor que ela precisa para comprar as bananas.
#### Entrada
A primeira linha irá conter $N$ - o número de dias. As próximas $N$ linhas irão conter três inteiros $D_i$, $B_i$, $P_i$ - o número de latas de doce, quantidade de bananas a venda e preço das bananas no i-ésimo dia, respectivamente.
#### Saída
Imprima uma linha com o menor valor que Iara precisa gastar comprando bananas para preparar seus doces. Caso não seja possível preparar o número necessário de doces para algum dia, imprima -1.
* $1 \leq N \leq 10^5$
* $1 \leq D_i \leq 10^6$
* $1 \leq B_i \leq 10^6$
* $1 \leq P_i \leq 10^3$
* Em um conjunto de casos de teste equivalente a 20 pontos, $N \leq 10^3, B_i \leq 100$ e $D_i \leq 100$.
* Em um conjunto de casos de teste equivalente a 40 pontos, $N \leq 10^3, B_i \leq 10000$ e $D_i \leq 10000$.
* Em um conjunto de casos de teste equivalente a 70 pontos, $N \leq 10^4$.
|
2,816 | 775 | Redução Bitwise | Muito Difícil | Estruturas | Farcos adora operações bitwise, por isso, toda vez que recebe um array de números inteiros positivos ele escolhe algum segmento desse array, realiza uma das suas três operações bitwises favoritas (XOR, OR ou AND) com todos os elementos desse segmento e insere o resultado ao lado de alguma posição do segmento. Aumentando assim o tamanho do segmento e, por consequência, o do array. Claro que Farcos raramente faz somente uma inserção desse tipo.
Um elemento de um segmento que é igual ao resultado de uma operação bitwise sobre todos *os outros* elementos desse mesmo segmento é chamado de redutor bitwise sobre aquela operação naquele segmento. Por essa definição, todos os números inseridos por Farcos já seriam redutores bitwise, porém, se algum número do segmento for modificado após uma inserção, por exemplo, o número inserido pode perder sua propriedade de redutor e outro número pode passar a receber, ou também pode acontecer de o segmento não possuir mais um redutor bitwise sobre aquela operação.
Sua tarefa é processar 4 tipos de ações sobre um array:
* *x* $L$ $R$ : Deve retornar um redutor bitwise sobre a operação XOR nos elementos do array de índice $L$ ao $R$, inclusive. Caso haja mais de um, retorne o maior deles. Caso haja nenhum, retorne -1.
* *a* $L$ $R$ : Deve retornar um redutor bitwise sobre a operação AND nos elementos do array de índice $L$ ao $R$, inclusive. Caso haja mais de um, retorne o maior deles. Caso haja nenhum, retorne -1.
* *o* $L$ $R$ : Deve retornar um redutor bitwise sobre a operação OR nos elementos do array de índice $L$ ao $R$, inclusive. Caso haja mais de um, retorne o menor deles. Caso haja nenhum, retorne -1.
* *u* $K$ $V$ : Deve alterar o valor do número de índice $K$ para $V$.
#### Entrada
A primeira linha da entrada possui dois inteiros $N$ e $Q$ sendo, respectivamente, a quantidade de elementos do array e número de ações a ser processada.
A segunda linha da entrada possui $N$ números inteiros $A_i$ separados por um único espaço em branco e representando os números do array.
Após essas duas primeiras linhas, se seguem $Q$ linhas, uma para cada ação. Cada uma com um caractere $C$ seguido de dois inteiros separados por um único espaço em branco. As ações são de acordo com o especificado no texto.
Há ao menos uma operação onde $C \ne$ 'u'.
#### Saída
A saída consiste em uma linha para cada ação que retorna um redutor bitwise. Na ordem em que são fornecidas.
#### Restrições
* $2 \leq N \leq 10^5$
* $1 \leq Q \leq 10^5$
* $0 \leq V$, $A_i \lt 2^{31}$
* $1 \leq K \leq N$
* $1 \leq L < R \leq N$
* $C \in$ {$‘x’, ‘a’, ‘o’, ‘u’$} |
2,817 | 108 | Angariando Fundos | Difícil | Estruturas | Uma politica de prestígio visando a presidência no próximo ano está planejando um evento para angariar fundos para sua campanha. Ela possui uma lista de pessoas abastadas no país e quer convidá-los de uma forma a maximizar seus fundos.
Algumas vezes os ricos e abastados tem comportamentos fúteis e não gostam da ideia de alguém mais rico ou bonito do que eles existir. Toda vez que alguém assim encontra uma pessoa rigorosamente mais bonita, mas não rigorosamente mais rica, então uma discussão começa. Similarmente, se eles encontram uma pessoa que é rigorosamente mais rica mas não rigorosamente mais bonita uma discussão também começa. Essas duas situações são as únicas causas possíveis de discussões entre dois indivíduos. Assim, duas pessoas nunca discutirão caso uma seja estritamente mais bonita e mais rica que a outra. Também não ocorrem discussões quando ambas as pessoas são igualmente ricas e igualmente bonitas.
Como a nossa presidenciável gostaria de garantir o máximo de dinheiro possível, discussões devem ser evitadas a qualquer custo, pois poderiam arruinar a campanha ou o evento. Dado as características de algumas pessoas abastadas no país, você deve encontrar uma lista de convidados que maximize as doações enquanto garanta que nenhuma discussão ocorra no evento.
#### Entrada
A primeira linha contem um inteiro $N$ ($1 \leq N \leq 10^5$ ) representando o número possível de convidados. Cada uma das próximas $N$ linhas descreve um possível candidato com três inteiros $B$, $F$ e $D$ ($1 \leq B, F, D \leq 10^9$ ), indicando respectivamente seu nivel de beleza, sua fortuna e quanto esta pessoa doaria caso fosse convidada.
#### Saída
Imprima uma única linha contendo um inteiro que indica a soma máxima de doações possíveis para uma lista de convidados que não gere discussão alguma durante o evento.
|
2,818 | 498 | Frequência | Muito Difícil | Estruturas | Byteland é uma cidade bastante conhecida por propor variados desafios aos seus habitantes. Recentemente, o prefeito de Byteland, Joãozinho, decidiu propor um desafio que ele gosta de chamar de Tabuleiro da Frequência.
A brincadeira ocorre da seguinte forma. Inicialmente, um tabuleiro com dimensões $N \times N$ é dado contendo apenas 0’s. Depois disso, Q operações são propostas, podendo ser de 4 tipos:
* 1 $X$ $R$: Atribuir o valor $R$ a todos os números da linha $X$;
* 2 $X$ $R$: Atribuir o valor $R$ a todos os números da coluna $X$;
* 3 $X$: Imprimir o valor mais frequente na linha $X$;
* 4 $X$: Imprimir o valor mais frequente da coluna $X$.
Joãozinho é muito bom com computadores, mas também é bastante preguiçoso. Sabendo que você é um dos melhores programadores do mundo, ele decidiu pedir sua ajuda para resolver este problema.
#### Entrada
A primeira linha da entrada é composta por dois inteiros $N$ e $Q$, representando, respectivamente, o tamanho do tabuleiro e a quantidade de operações. As próximas $Q$ linhas da entrada vão conter as $Q$ operações. O primeiro inteiro de cada linha vai indicar o tipo da operação. Caso seja 1 ou 2, será seguido por mais dois inteiros $X$ e $R$. Caso seja 3 ou 4, será seguido por apenas mais um inteiro $X$.
#### Saída
Para cada operação do tipo 3 ou 4, seu programa deve produzir uma linha, contendo o valor da resposta correspondente. Se uma linha ou coluna tiver dois ou mais valores que se repetem o mesmo número de vezes, você deve imprimir o maior deles. Por exemplo, se uma linha tem os valores [5,7,7,2,5,2,1,3], tanto o 2, 5 e 7 se repetem duas vezes, então a resposta será 7, pois é o maior deles.
#### Restrições
* $1 \leq N, Q \leq 10^5$
* $1 \leq X \leq N$
* $0 \leq R \leq 50$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste equivalente a 30 pontos, $N \leq 10^3$.
* Em um conjunto de casos de teste equivalente a 20 pontos, apenas as operações 2 e 3 serão usadas. |
2,819 | 2162 | Estante | Difícil | Estruturas | Juliana estava arrumando seus $N$ livros colocando um livro em cada caixa. Porém, quando foi colocá-las na estante percebeu que não tinha espaço suficiente para todas elas. Portanto, ela decidiu juntar alguns livros em uma mesma caixa, a fim de minimizar a quantidade de caixas utilizadas, mas devido à sua mania de organização ela resolveu que em cada caixa poderiam ser colocados apenas livros que sejam de um mesmo gênero, ela conhece todas as $R$ relações de livros que possuem o mesmo gênero.
Você é uma grande amiga de Juliana, e ela está muito ocupada tentando achar um bom fornecedor de caixas, resolveu se propor a ajudá-la durante essa organização, construindo um programa que dada as relações de gênero dos livros e o número $K$ máximo de livros que cada caixa pode armazenar diga o menor número de caixas que Juliana irá precisar comprar.
#### Entrada
A primeira linha contém três inteiros $N$, $R$ e $K$ que representam, nessa ordem, o número de livros, o número de relações de gênero entre os livros e o número máximo de livros que cada caixa pode armazenar. Cada uma das $R$ linhas seguintes, contém dois inteiro $A$ e $B$ indicando que os livros $A$ e $B$ são do mesmo gênero, ou seja, podem ser colocados na mesma caixa.
Vale ressaltar que cada livro possui um único gênero, portanto se os livros $A$ e $B$ pertencem ao mesmo gênero e os livros $B$ e $C$ também. Logo, $A$ pertence ao mesmo gênero que $C$.
#### Saída
Imprima o menor número de caixas que Juliana precisa para organizar sua estante.
#### Restrições
* $1 ≤ N ≤ 10^5$
* $0 ≤ R ≤ N(N − 1)/2$
* $0 ≤ R ≤ 5 \cdot 10^5$
* $1 ≤ K ≤ N$
* $1 ≤ A, B ≤ N$
* $A \neq B$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 80 pontos, considere que sempre é possível colocar
todos os livros de um mesmo gênero em uma única caixa.
* Em um conjunto de casos de teste somando 20 pontos, considere nenhuma restrição adicional. |
2,820 | 2111 | Detetive Watson | Médio | Estruturas | John Watson, mesmo após anos trabalhando ao lado de Sherlock Holmes, nunca conseguiu entender como ele consegue descobrir quem é o assassino com tanta facilidade.
Em uma certa noite, Sherlock bebeu mais do que devia e acabou contando o segredo a John. “Elementar, meu caro Watson”, disse Sherlock Holmes. “Nunca é o mais suspeito, mas sim o segundo mais suspeito”.
Após descobrir o segredo, John decidiu resolver um crime por conta própria, só para testar se aquilo fazia sentido ou se era apenas conversa de bêbado.
Dada uma lista com $N$ inteiros, representando o quanto cada pessoa é suspeita, ajude John Watson a decidir quem é o assassino, de acordo com o método citado.
#### Entrada
Cada caso de teste inicia com um inteiro $N (2 ≤ N ≤ 1000)$, representando o número de suspeitos.
Em seguida haverá $N$ inteiros distintos, onde o $i$-ésimo inteiro, para todo $1 ≤ i ≤ N$, representa o quão suspeita a $i$-ésima pessoa é, de acordo com a classificação dada por John Watson. Seja $V$ o valor do $i$-ésimo inteiro, $1 ≤ V ≤ 10000$.
O último caso de teste é indicado quando $N = 0$, o qual não deverá ser processado.
#### Saída
Para cada caso de teste imprima uma linha, contendo um inteiro, representando o índice do assassino, de acordo com o método citado.
|
2,821 | 1333 | Jogo de Estratégia | Fácil | Estruturas |
Um jogo de estratégia, com $J$ jogadores, é jogado em volta de uma mesa. O primeiro a jogar é o jogador 1, o segundo a jogar é o jogador 2 e assim por diante. Uma vez completada uma rodada, novamente o jogador 1 faz sua jogada e a ordem dos jogadores se repete novamente. A cada jogada, um jogador garante uma certa quantidade de Pontos de Vitória. A pontuação de cada jogador consiste na soma dos Pontos de Vitória de cada uma das suas jogadas.
Dado o número de jogadores, o número de rodadas e uma lista representando os Pontos de Vitória na ordem em que foram obtidos, você deve determinar qual é o jogador vencedor. Caso mais de um jogador obtenha a pontuação máxima, o jogador com pontuação máxima que tiver jogado por último é o vencedor.
#### Input
A entrada consiste de duas linhas. A primeira linha contém dois inteiros $J$ e $R$, o número de jogadores e de rodadas respectivamente $(1 \ \leq \ J, \ R \ \leq \ 500)$. A segunda linha contém $J \ * \ R$ inteiros, correspondentes aos Pontos de Vitória em cada uma das jogadas feitas, na ordem em que aconteceram. Os Pontos de Vitória obtidos em cada jogada serão sempre inteiros entre 0 e 100, inclusive.
#### Output
Seu programa deve produzir uma única linha, contendo o inteiro correspondente ao jogador vencedor.
|
2,822 | 355 | Análise de Risco | Muito Difícil | Estruturas | A W.M.P S/A (Wow, Much Problem. Such Accepted) é uma empresa de análise de risco. Ela foi contratada por uma outra empresa para fazer uma cálculo de risco em relação a uma produto que está prestes a ser lançado no mercado. O desenvolvimento desse produto é definido em $N$ etapas, onde cada etapa possui um valor $V_i$ que representa uma estimativa de risco para a produção da i-ésima etapa.
A W.M.P encontrou uma fórmula que pode calcular esse risco total do produto e é definida da seguinte forma:
* $f(x) = \{(i,j) | 1 \leq i \leq j \leq N$ e $mdc (V_i, V_{i+1}, \ldots, V_j) \leq x \}$
* $g(L,R) = \sum_L^R{} |f(i)|$ (soma do tamanho do conjunto $f(x)$ com $x$ variando de $L$ até $R$, inclusive.)
* $mdc(a,b) = 0$ maior inteiro $c$ que divide $a$ e $b$.
Após uma certa análise, a empresa W.M.P descobriu que a função $g(L, R)$ é exatamente correspondente ao risco total do produto. Sabendo isso, ela contratou você que é um excelente programador para desenvolver um software que dado o valor de $N$, um array $V$ contendo os riscos das $N$ etapas e dois inteiros $L$ e $R$, retorne o risco total do produto.
Tomando o primeiro exemplo como base, podemos definir os seguintes valores para $f(x)$:
* $f(1) = \{\}$
* $f(2) = \{(1,1), (1,2), (2,3), (3,4), (1,3), (2,4), (1,4)\}$
Sabemos então que $g(1, 2) = |f(1)| + |f(2)|$, logo $g(1, 2) = 7$.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $L$ e $R$ representando respectivamente a quantidade de etapas do produto e as variáveis $L$ e $R$ usadas no cálculo do risco.
A segunda linha da entrada contém $N$ inteiros separados por um único espaço em branco representando a estimativa de risco de cada uma das $N$ etapas.
#### Saída
Seu programa deve imprimir apenas uma linha contendo um inteiro positivo, o valor total do risco do produto.
#### Restrições
* $1 \leq N \leq 10^5$
* $1 \leq L, R \leq 10^8$
* $1 \leq V_i \leq 10^8$
#### Informações sobre a Pontuação
* Em um conjunto de casos de teste totalizando 20 pontos, $N \leq 1.000$
* Os testes restantes possuem um valor $N$ distribuído gradualmente entre $10^3$ e $10^5$
|
2,823 | 893 | Faltou uma Historinha | Muito Difícil | Estruturas | Eu queria escrever um textinho bem legal e bacana, mas estou sem tempo!
Então vamos fingir que aqui está escrito uma historinha que não serve de nada …
Aqui mais uma história que tenta disfarçar o que o problema quer…
E aqui está o que realmente o problema quer:
Será dado uma fita com $N$ células todas inicialmente com cor $1$ e $Q$ operações que podem ser do tipo:
$1 L R X$ - Atribuir a cor $X$ para todas as células no intervalo fechado $[L, R]$
$2 X$ - Determinar qual a frequência da cor $X$
$3$ - Determinar a frequência da cor mais frequente (Em caso de empate imprima a cor a de menor índice).
Mais prático, não? Então resolve aí.
#### Entrada
A primeira é composta por dois inteiros $N$ e $Q$, o número de células e quantidade de operações.
Segue então $Q$ linhas, cada linha é uma alguma das operações descritas.
#### Saída
Para cada operação do tipo $2$ e $3$ imprima um inteiro. Faz o favor de não esquecer a quebra de linha.
#### Restrições
##### 25 pontos:
$1 \leq N \leq 10^3$
$1 \leq Q \leq 10^4$
$1 \leq X \leq 10^4$
$1 \leq L \leq R \leq N$
##### 75 pontos:
$1 \leq N \leq 10^5$
$1 \leq Q \leq 10^5$
$1 \leq X \leq 10^5$
$1 \leq L \leq R \leq N$
|
2,824 | 505 | Catálogo de Músicas | Difícil | Estruturas | Joyce é uma menina que gosta muito de ouvir música, e possui uma enorme coleção de músicas num DVD. Ela é uma menina organizada e deixa suas músicas em pastas, mas como o número de músicas e de pastas é grandre, Joyce construiu um catálogo para melhor localizá-las.
Para o catálogo Joyce utilizou uma convenção usual em sistemas operacionais, em que a descrição da localização de cada arquivo é formada pela sequência dos nomes das pastas no caminho da raiz do dvd até o arquivo, separados pelo caractere barra (‘/’). Por exemplo, na figura abaixo, a descrição da música **Sampa.mp3** no catálogo é **MPB/Caetano/Sampa.mp3**.
Utilizando essa convenção, o catálogo do dvd mostrado na figura é:
**Rock/AngraCarryOn.mp3**
**MPB/Caetano/Sampa.mp3**
**MPB/Cartola/Alvorada.mp3**
Como o dvd de Joyce tem muitas músicas e pastas, o catálogo é muito grande. Joyce notou no entanto que o catálogo poderia ser menor (ter um número menor de caracteres) caso ela utilizasse outro conceito usual na nomeação de arquivos em sistemas operacionais: usar uma pasta como referência, ao invés da raiz.
Se uma pasta diferente da raiz for escolhida como referência, então para todos os arquivos que estejam diretamente nessa pasta ou em alguma subpasta não será mais necessário escrever o nome da pasta referência no catálogo. Para as demais pastas, é necessário indicar o caminho utilizando as pastas acima (na direção da raiz) utilizando a convenção ‘../’ para a pasta imediatamente acima da pasta referência. No exemplo da figura acima, no caso de a referência ser a pasta **Caetano**, a música **Sampa.mp3** seria simplesmente descrita como **Sampa.mp3**. Já a música **Alvorada.mp3** seria descrita como **../Cartola/Alvorada.mp3**.
Assim, se a pasta **Caetano** for utilizada como referência, o catálogo será:
**../../Rock/AngraCarryOn.mp3**
**Sampa.mp3**
**../Cartola/Alvorada.mp3**
Nesse caso, a descrição do catálogo tem 59 carateres, menor do que quando a referência utilizada é a raiz do DVD.
Seu objetivo é, dada a informação de todas as músicas do catálogo, determinar o número mínimo de caracteres necessários para descrever o catálogo.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, indicando quantos arquivos Joyce possui no DVD. Cada uma das $N$ linhas seguintes contém a descrição de um arquivo, a partir da raiz.
#### Saída
Seu programa deve imprimir uma única linha, contendo apenas um inteiro, o número mínimo de caracteres necessários para descrever o catálogo.
#### Restrições
* $1 \leq N \leq 10^5$
* Número de pastas na entrada $\leq 10^5$
* O nome de cada pasta e de cada arquivo é composto por no máximo 20 caracteres, entre letras minúsculas, maiúsculas e ponto (.)
* Cada pasta possui no máximo 100 pastas como filhas diretas.
#### Informações sobre a pontuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 1000$ e o número de pastas $\leq 1000$. |
2,825 | 356 | Intervalo | Muito Difícil | Estruturas | Dado um vetor inicial de $N$ elementos e $Q$ consultas de um dos seguintes tipos:
* $I\ x\ V$: Insere o inteiro $V$ na x-ésima posição do vetor. Caso essa posição já esteja ocupada, então o elemento deverá ser inserido entre as posições $x e x + 1$.
* $S\ x\ y$: Calcula a soma de todos os inteiros entre a x-ésima posição e a y-ésima posição.
Você foi contratado para desenvolver um programa que determine o resultado de cada consulta do tipo $S\ x\ y$.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ representando a quantidade de elementos no vetor inicial.
A segunda linha da entrada contém $N$ inteiros $A_i$ representando o vetor inicial.
A terceira linha da entrada contém um inteiro $Q$ representando a quantidade de consultas.
Cada uma das próximas $Q$ linhas contém uma consulta, podendo essa ser do tipo $I\ x\ V$ ou $S\ x\ y$, como descrito no enunciado.
#### Saída
Para cada consulta do tipo $S\ x\ y$, seu programa deve imprimir um único inteiro que responde a consulta. Cada consulta deverá ser impressa em linhas separadas.
#### Restrições
* $1 \leq N, Q \leq 10^5$
* $0 \leq A_i, V \leq 10^8$
* $0 \leq x \leq y \leq N$
#### Informações sobre a Pontuação
* Em um conjunto de casos de teste totalizando 20 pontos, $1 \leq N, Q \leq 2000$
|
2,826 | 1949 | Função Hash | Fácil | Estruturas | Depois de ler todo o livro **Competitive Programming 3** e aprender bastante sobre vários tópicos de maratona de programação, Ovatsug se interessou por funções hash.
Funções hash são algoritmos que recebem como entrada uma quantidade qualquer de bits e gera uma saída de tamanho fixo. Há várias nomenclaturas para o resultado de uma função hash tais como **soma hash**, **código hash**, **valores hash** ou simplesmente **hash**.
Seja $F$ uma função hash e $F(x)$ o valor hash de uma entrada $x$ qualquer. Diz-se que $F$ é boa se cumpre, essencialmente, os três pontos abaixo:
1. Dado $F(x)$ deve ser difícil deduzir $x$;
2. Qualquer alteração em $x$, mesmo que seja um bit, gerando um $x'$, deve fazer com que $F(x)$ seja completamente diferente de $F(x′)$.
3. Deve ser difícil encontrar $x_1$ e $x_2$ tais que $F(x_1) = F(x_2)$ com $x_2 \neq x_2$.
Ovatsug está muito empolgado, pois ele acredita fielmente que inventou uma boa função hash. E ele gostaria da sua ajuda para testá-la no que diz respeito ao item 3 citado acima.
Ele fornecerá uma lista de hashes gerados a partir de entradas diferentes, e gostaria da sua ajuda para verificar se há algum hash que se repete na listagem. Se nenhum se repetir, você deve infor- mar que “A funcao eh boa.”, mas se pelo menos um hash se repetir, então você deve informar que “A funcao nao eh boa.”.
#### Entrada
A entrada é composta de apenas um caso de teste. Cada caso se inicia com um inteiro $Q (2 ≤ Q ≤ 10^5)$ representando a quantidade de hashes que há na lista que Ovatsug te passou.
Seguem $Q$ linhas, cada uma contendo uma string $S (2 ≤ |S| ≤ 100)$ representando o valor hash ob- tido por Ovatsug. $|S|$ representa o tamanho da string $S$.
Cada string $S$ conterá apenas dígitos ou letras. A comparação deve ser case-sensitive, ou seja, ‘A’ != ‘a’.
#### Saída
A saída deve conter a frase “A funcao eh boa.” (sem aspas) se não houver nenhuma repetição, ou “A funcao nao eh boa.” (sem aspas) caso contrário.
|
2,827 | 2175 | Portas | Difícil | Estruturas | Ada está participando do Torneio Feminino de Cartas (TFC). No TFC a participante passa em frente a um corredor com $N$ portas numeradas sequencialmente de $1$ até $N$. Atrás de cada porta há um baú inicialmente vazio.
Antes do jogo começar $k$ assistentes passam. Cada uma delas anuncia três números $L$, $R$ e $X$, e adiciona uma carta de valor $X$ em cada baú atrás de cada porta de $L$ até $R$.
Quando o jogo começa, Ada escolhe duas portas $i$ e $j$, $i ≤ j$, ela entra no corredor pela porta $i$ e segue o caminho para a direita pegando todas as cartas que estão em baús atrás das portas entre $i$ e $j$.
A pontuação da participante é dada pela soma dos valores de todas as cartas que ela pegou. Qual a maior pontuação que Ada pode obter?
#### Entrada
A primeira linha de entrada contém dois inteiros $N$ e $K$ representando o número de portas e o número de assistentes. Cada uma das $K$ linhas seguintes possui $3$ inteiros $L_i$, $R_i$ e $X_i$, os números anunciados pela $i$-ésima assistente.
#### Saída
Sua saída deve conter um inteiro $A$, a maior pontuação que Ada pode obter.
#### Restrições
* $1 ≤ N ≤ 10^6$
* $1 ≤ K ≤ 10^6$
* $−100 ≤ X_i ≤ 100$
* $1 ≤ Li ≤ R_i ≤ N$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando $10$ pontos, $X_i ≥ 0$, para todo $i$.
* Em um conjunto de casos de teste somando $10$ pontos, $K ≤ 5 \times 10^3$ e $N ≤ 5 \times 10^3$
* Em um conjunto de casos de teste somando $30$ pontos, $K ≤ 2 \times 10^5$ e $(R_i − L_i) ≤ 100$ para todo $i$.
* Em um conjunto de casos de teste somando $50$ pontos, nenhuma restrição adicional. |
2,828 | 2290 | Evento especial | Fácil | Estruturas | Você está tentando programar um evento especial em um dos cinco dias possíveis.
Sua tarefa é determinar em que dia o evento deve ser programado para que o maior número possível de pessoas interessadas possa comparecer.
#### Entrada
A primeira linha de entrada conterá um em número inteiro positivo $N$, representando o número de pessoas interessadas em participar do evento. As próximas $N$ linhas conterão a disponibilidade de uma pessoa, usando um caractere para cada Dia $1$, Dia $2$, Dia $3$, Dia $4$ e Dia $5$ (nessa ordem). O caractere Y significa que a pessoa pode comparecer e um ponto (.) significa que a pessoa não pode comparecer.
#### Saída
A saída consistirá em uma linha listando o(s) número(s) do(s) dia(s) em que o maior número de pessoas interessadas poderá comparecer.
Se houver mais de um dia em que o maior número de pessoas poderá comparecer, exiba todos esses números de dias em ordem crescente e separados por vírgulas (sem espaços).
##### Explicação Entrada/saída de Exemplo 1:
Todas as três pessoas podem comparecer no dia $4$ e nem todas estão disponíveis em nenhum outro dia.
##### Explicação Entrada/Saída de Exemplo 2:
Não há nenhum dia em que todas as cinco pessoas possam comparecer. Quatro pessoas podem comparecer tanto no dia $2$ quanto no dia $5$. |
2,829 | 2156 | Laser | Difícil | Estruturas | Mariazinha adora jogos online, e recentemente anda viciada em um jogo que conheceu a pouco tempo. A personagem do jogo é uma aventureira atrás de um tesouro. Ela está dentro de uma caverna onde o tesouro foi escondido, porém essa caverna está cheia de armadilhas. Após passar por todas, Mariazinha finalmente consegue chegar na fase final: a fase dos Lasers. Basicamente, ela é colocada em um plano, no formato de um tabuleiro, onde existe um laser em cada posição. Os lasers são aleatoriamente ativados e desativados. Quando um laser é ativado, ele bloqueia o acesso a todas as posições que fazem parte da mesma linha ou da mesma coluna da posição daquele laser. Mariazinha quer sua ajuda pra identificar se certo subgrid do tabuleiro está totalmente coberto por lasers ou não. Você receberá $Q$ queries, que podem ser de três tipos:
1. $A$ $x$ $y$ - Ativa o laser da posição $(x, y)$.
2. $R$ $x$ $y$ - Desativa o laser da posição $(x, y)$.
3. $Q$ $x_1$ $y_1$ $x_2$ $y_2$ - Imprima ’S’ se todas as posições dentro do subgrid com canto superior na posição $(x_1, y_1)$ e canto inferior na posição $(x_2, y_2)$ forem cobertas por lasers, e ’N’ caso contrário.
É garantido que não haverão queries que tentarão ativar um laser já ativado, ou desativar um laser já desativado. Você pode ajudar Mariazinha a responder todas as queries do tipo 3?
#### Entrada
A primeira linha de entrada contém dois inteiros $N$ e $M$, representando a quantidade de linhas e colunas do tabuleiro, respectivamente. A segunda linha de entrada contém um inteiro $Q$, representando o número de queries. As próximas $Q$ linhas representam cada uma uma query, no formato especificado anteriormente. É garantido que todas as queries são válidas.
#### Saída
Imprima, para cada query do tipo 3, um caractere ’S’ se todas as posições dentro do subgrid forem cobertas por lasers, e ’N’ caso contrário.
#### Restrições
* $1 ≤ N, M ≤ 10^5$
* $1 ≤ Q ≤ 2 ∗ 10^5$
* $1 ≤ x ≤ N$
* $1 ≤ y ≤ M$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 10 pontos, $N = M = 2$.
* Em um conjunto de casos de teste somando 50 pontos, $N$, $M < 100$, $Q < 200$.
* Em um conjunto de casos de teste somando 40 pontos, nenhuma restrição adicional.
|
2,830 | 489 | Pontos | Difícil | Estruturas | São dadas as coordenadas de $N$ pontos no espaço $(P_1, P_2, \ldots, P_N )$. Inicialmente, esses pontos estão distribuídos em $N$ conjuntos unitários, um para cada ponto. Serão realizadas $Q$ operações sobre esses conjuntos. As operações podem ser de três tipos:
* Tipo 1: dados dois pontos $P_i$ e $P_j$, previamente em conjuntos distintos, unir os conjuntos aos quais eles pertencem.
* Tipo 2: desfazer a última união de conjuntos realizada que ainda não foi desfeita.
* Tipo 3: dados dois pontos $P_i$ e $P_j$, em conjuntos distintos, imprimir a maior distância de Manhattan de um ponto do conjunto de $P_i$ para um ponto do conjunto de $P_j$.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando a quantidade de pontos que se seguem.
As $N$ linhas seguintes contêm, cada uma, três inteiros $x_i$, $y_i$ e $z_i$, indicando as coordenadas do $i$-ésimo ponto.
A próxima linha contém um inteiro $Q$, representando a quantidade de consultas a serem realizadas. Cada uma das próximas $Q$ linhas representa uma consulta, e está em algum dos seguintes formatos:
* 1 $i$ $j$: representa uma consulta do tipo 1 sobre os pontos $P_i$ e $P_j$.
* 2: representa uma consulta do tipo 2.
* 3 $i$ $j$: representa uma consulta do tipo 3 sobre os pontos $P_i$ e $P_j$ .
#### Saída
Para cada consulta do tipo 3, o seu programa deverá imprimir, em uma única linha, a sua resposta.
#### Restrições
* $1 \leq N \leq 2 * 10^5$
* $1 \leq Q \leq 3 * 10^5$
* $-10^8 \leq x_i, y_i, z_i \leq 10^8$
#### Informações sobre a pontuação
* Em um conjunto de testes que totaliza 15 pontos, $N, Q \leq 10^3$.
* Em um conjunto de testes que totaliza 15 pontos, vale que $y_i = z_i = 0$.
* Em um conjunto de testes que totaliza 20 pontos, vale que $z_i = 0$ e não há consultas do tipo 2.
* Em um conjunto de testes que totaliza 30 pontos, vale que $z_i = 0$.
|
2,831 | 382 | Chuva (Seletiva IOI 2017) | Muito Difícil | Estruturas | A água da chuva contém muitas informações importantes sobre a composição química da atmosfera de uma determinada região. Por isto, anualmente a organização da IOI encomenda um estudo de amostras de chuva da cidade que se propõe a sedear a próxima edição da competição, antes de expor os competidores a perigos como chuvas ácidas ou concentrações muito grandes de CO2. Neste ano, a organização pediu a sua ajuda para avaliar uma das cidades candidatas a sede da IOI no próximo ano.
A cidade pode ser representada por uma matriz onde cada posição possui uma altura inteira. A organização distribuiu coletores pela cidade, em posições informadas a você, de forma a obter amostras de água de chuva. Um estudo anterior mostrou que, nessa cidade, todas as chuvas caem exatamente em retângulos dentro da matriz. Quando chove em uma posição da matriz, a água escorre dessa posição para posições adjacentes acima, abaixo, à direita e à esquerda que possuam altura menor ou igual à da posição onde choveu. O fluxo de água da chuva segue, e a água continua escorrendo até chegar a um sumidouro, ou seja, uma posição desde a qual não é possível que a água chegue a nenhuma outra posição de altura menor ou igual, direta ou indiretamente. Os sumidouros são posições no solo, que absorve a água em vez de deixar que ela acumule. Também é possível que a água escorra para fora da cidade.
A organização posicionou estrategicamente vários coletores de água em pontos espalhados pela cidade. Agora, ela pediu sua ajuda em avaliar a escolha de posições feitas com base no histórico de chuvas no último ano. Dada a matriz de alturas que representa a cidade, as posições onde foram colocados os coletores de água e as áreas retangulares onde ocorreram todas as chuvas dos últimos anos na cidade, diga para cada chuva quantos coletores distintos irão receber água daquela chuva. Mesmo que a água encontre um coletor, ela continua escorrendo pois apenas uma pequena amostra de água é coletada.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $M$ e $K$. Os dois primeiros representam o número de linhas e de colunas da matriz de alturas, enquanto o terceiro representa o número de coletores espalhados pela cidade. As próximas $N$ linhas contem $M$ inteiros cada, de forma que o j-ésimo inteiro da i-ésima linha representa a altura $H_{ij}$ da posição $(i, j)$. As próximas $K$ linhas contém as posições dos coletores. A i-ésima delas contém dois inteiros $A_i$ e $B_i$ indicando que a posição $(A_i,B_i)$ contém um coletor. Uma posição pode ter no máximo um coletor. A linha seguinte contém um inteiro $Q$ indicando o número de consultas. Cada uma das $Q$ linhas seguintes descreve uma consulta. A i-ésima delas contém quatro inteiros $P_i$, $T_i$, $R_i$, $S_i$, representando o retângulo cujo o ponto superior esquerdo é $(P_i, T_i)$ e o ponto inferior direito é $(R_i, S_i)$.
#### Saída
Para cada uma das consultas, imprima uma linha contendo um único inteiro representando o número de coletores que receberão água caso chova no retângulo da consulta.
#### Restrições
* $1 \leq N \leq 10^3$
* $1 \leq M \leq 10^3$
* $0 \leq K \leq 250$
* $1 \leq Q \leq 10^6$
* $1 \leq P_i \leq R_i \leq N$
* $1 \leq T_i \leq S_i \leq M$
* $1 \leq H_{ij} \leq 10^6$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 20 pontos, $1 \leq N \leq 100$, $1 \leq M \leq 100$, $1 \leq Q \leq 10^4$.
* Em um conjunto de casos de teste somando 20 pontos, $0 \leq K \leq 20$
* Em um conjunto de casos de teste somando 20 pontos, $1 \leq N \leq 300$, $1 \leq M \leq 300$, $1 \leq Q \leq 10^5$.
* Em um conjunto de casos de teste somando 40 pontos, não há restrições adicionais.
#### Importante
Não é garantido que este problema possa ser resolvido em uma linguagem diferente do C++.
|
2,832 | 2155 | Potes | Médio | Estruturas | Marcela trabalha em uma fabrica de potes coloridos. Recentemente a sua empresa resolveu expandir a produção, e para isso decidiu automatizar o processo.
Sua linha de produção funciona da seguinte forma: Uma sequência de potes e tampas coloridos vem misturados pela esteira principal, um item atrás do outro, e termina com potes fechados com suas respectivas tampas.
Durante a produção em cada momento pode-se:
* Pegar o primeiro pote da esteira e coloca-lo no topo de uma pilha (os potes são feitos com tanta precisão que cabem perfeitamente um dentro do outro), de forma que a cada momento temos uma pilha de potes sem tampa, potencialmente vazia.
* Pegar a primeira tampa da esteira e caso tenham cores iguais, junta-la com o pote que está no topo da pilha, tirando tanto o pote da pilha quando a tampa da esteira. Caso a tampa e o pote do topo da pilha tenham cores diferentes não podemos retirar a tampa.
Observou-se que alguns potes não vem com tampa correspondente, e para evitar que isso interrompa a produção foi criado um processo onde é possível solicitar, sob demanda, qualquer tipo de tampa. Essa solicitação porém implica em um custo extra de produção, sendo esse $V_i$ para se produzir uma tampa da cor $i$.
Essas tampas extras podem ser produzidas a qualquer momento, instantaneamente, uma quantidade ilimitada de vezes, e só podem ser usadas para tampar o pote no topo da pilha, retirando-o de lá.
Marcela gostaria da sua ajuda para, dado esse processo, calcular o menor custo possível para esvaziar a esteira de produção e pilha, se assegurando sempre que potes e tampas combinados tem cores correspondentes. É possível porém, que não seja possível terminar a produção de todos os itens da esteira, possivelmente sobrando alguns, e Marcela gostaria também de saber caso isso aconteça.
Você pode ajudá-la?
#### Entrada
A primeira linha de entrada contém dois inteiros, $N$ e $M$, indicando o tamanho da sequência de potes e tampas, e a quantidade de estilos diferentes de potes, respectivamente.
A segunda linha contém $M$ inteiros separados por espaço, representando $V_i$, com o $i$-ésimo indicando o valor de uma tampa reserva da cor $i$.
A terceira contém $N$ inteiros separados por espaço, formando a sequência de potes e tampas $S$. Nessa sequência temos que o i-ésimo termo é um pote caso $S_i > 0$ e uma tampa caso $S_i < 0$. A cor de cada pote/tampa é $S_i$, ou seja, caso tenhamos um pote da cor $S_i$, ele será representado pelo inteiro $S_i$; e caso seja uma tampa do tipo $S_i$, será representado pelo inteiro $S_i$, com ênfase no sinal de negativo.
#### Saída
Sua saída deverá conter um inteiro, representado o menor custo possível para combinar todos os potes com suas tampas, como descrito no enunciado. Caso seja impossível combinar todos os potes com tampas correspondentes, imprima $−1$.
#### Restrições
* $1 ≤ N, M ≤ 2 · 10^5$
* $1 ≤ V_i ≤ 1000$
* $1 ≤ |S_i| ≤ M$
|
2,833 | 2039 | Dinossauros | Médio | Estruturas | Paleontólogos das Ilhas Galápagos encontraram fósseis pertencentes a dinossauros que viveram no período Triássico. Os paleontólogos estimaram que diversas espécies diferentes de dinossauros viveram em um período de $10^5$ anos. Para propósitos de simplicidade, considera-se que tal período comece no ano $1$ e termine no ano $10^5$.
Inicialmente, os paleontólogos catalogaram todos os fósseis e conseguiram identificar $N$ espécies de dinossauros. Utilizando técnicas avançadas de datação de fósseis, os cientistas conseguiram estimar o período (ano inicial e ano final) que cada espécie viveu nas Ilhas Galápagos. Entretanto, como podem existir muitas espécies de dinossauros e poucos cientistas para analisar as estatísticas relacionadas aos dados obtidos dos fósseis, os paleontólogos solicitam sua ajuda.
Sua tarefa consiste em identificar a maior quantidade de espécies distintas de dinossauros que viveram em um ano considerando o período de $10^5$ anos do estudo dos paleontólogos.
#### Entrada
A primeira linha da entrada apresenta o número inteiro $N (1 \leq N \leq 10^5)$ indicando a quantidade de espécies de dinossauros catalogadas pelos paleontólogos.
As próximas $N$ linhas descrevem o período em que cada espécie viveu no planeta Terra. Em cada linha existem dois inteiros separados por espaço em branco $l_i$ e $r_i$ $(1\leq l < r\leq10^5)$ indicando o primeiro e o último ano de registros de vida da $i$-ésima espécie de dinossauro.
#### Saída
Imprima um número inteiro representando a maior quantidade de espécies de dinossauros que viveram em um único ano durante o período compreendido (ano $1$ e o ano $10^5$). |
2,834 | 1856 | Hotel | Médio | Estruturas | Você possui um hotel de luxo onde cada quarto ocupa todo um andar.
O hotel possui $N$ andares, numerados de $1$ a $N$, sendo o andar $N$ o mais alto.
Você possui uma lista de tentativa de reservas que deve ser atendida por ordem cronológica. Na $i$-ésima reserva, o hóspede sempre específica sua restrição de altura, ou seja, um número do andar mais alto que ele aceitaria se hospedar.
Você vai confirmando as reservas de acordo com as restrições, mas assim que não é possível atender alguma restrição de um hóspede, você encerra as reservas, mesmo que posteriormente tenha um hóspede que poderia ter sua restrição atendida.
Qual o número máximo de reservas que pode receber no seu hotel?
#### Entrada
A primeira linha da entrada contém o inteiro $N$.
A segunda linha da entrada contém um inteiro $R$ que específica o número de pedidos de reservas.
As próximas $R$ linhas contém um único inteiro $L_i$ cada. A $i$-ésima linha contém o limite de altura $L_i$ que $i$-ésimo hóspede aceitaria se hospedar.
#### Saída
A saída consiste de um único inteiro representando a quantidade de reservas que é possível confirmar no seu hotel em sequência a partir do primeiro pedido de reserva.
#### Restrições
* $1 \leq N \leq 10^{5}$
* $1 \leq R \leq 10^5$
* $1 \leq L_i \leq N$
|
2,835 | 490 | Xor | Muito Difícil | Estruturas | Considere um vetor $A$ de tamanho $N$, composto apenas por inteiros não-negativos, e um número inteiro positivo $K$. Você deverá encontrar o subvetor ($A_i, A_{i+1},\ldots, A_j$), para $1 \leq i \leq j \leq N$, de maior tamanho possível tal que, para todo elemento de índice $X$ contido nele ($i \leq X \leq j$), exista algum índice $Y \neq X$, também contido no subvetor ($i \leq Y \leq j$), satisfazendo $A_X \bigoplus A_Y < K$ (estritamente menor). A operação $A_X \bigoplus A_Y$ é definida como o Ou Exclusivo bit a bit entre os números $A_X$ e $A_Y$ (operador ∧ em C e C++). Observe que os índices $X$ e $Y$ precisam ser diferentes, mas os valores $A_X$ e $A_Y$ podem ser iguais.
#### Entrada
A primeira linha da entrada contém os dois inteiros $N$ e $K$, nessa ordem. A segunda linha da entrada contém os inteiros $A_1, A_2, \ldots, A_N$ , nessa ordem.
#### Saída
A saída deverá conter um único inteiro: o tamanho do subvetor encontrado, ou 0 se nenhum subvetor atender à propriedade descrita.
#### Restrições
* $1 \leq N \leq 3 * 10^5$
* $1 \leq K \leq 10^9$
* $0 \leq A_i \leq 10^9$
#### Informações sobre a pontuação
* Em um conjunto de testes que totaliza 15 pontos, $N \leq 200$.
* Em um conjunto de testes que totaliza 25 pontos, $N \leq 3000$.
|
2,836 | 127 | Espectro de Emissão | Difícil | Estruturas | Cientistas do <i>Interstellar Consortium of Planets and Constellations</i> (ICPC) estão estudando a composição de muitos objetos celestes analisando seu espectro de emissão. O espectro de emissão de um objeto celeste é o espectro de freqüências de radiação eletromagnética emitida devido a suas transições de energia atômica, juntamente com a intensidade da radiação emitida. Em outras palavras, corresponde à intensidade de cada cor para a luz irradiada pelo objeto.
De acordo com os postulados da mecânica quântica, o espectro de emissão de um objeto celeste é sempre discreto. Deste modo, o ICPC pode armazenar o espectro de emissão de um objecto como uma sequência de números inteiros em que cada posição na sequência corresponde à intensidade de um comprimento de onda específico. Nesta representação do espectro, números maiores correspondem a intensidades emitidas mais elevadas, e posições contíguas na sequência correspondem a comprimentos de onda contíguos no espectro. O espectro de emissão de um objeto celeste é o resultado de processos físicos muito complexos, podendo assim variar ao longo de sua vida útil. Notavelmente, devido a complexas reações atômicas ainda não totalmente compreendidas, a intensidade de dois comprimentos de onda contíguos pode ser trocada em um dado momento.
O ICPC está estudando muito de perto o espectro de emissão de algum objeto celeste em comprimentos de onda particulares. No entanto, os cientistas estão tendo problemas para obter dados úteis de suas observações. Particularmente, dada uma gama de comprimentos de onda e um inteiro $K$, eles estão interessados em conhecer a intensidade do comprimento de onda que tem a $K$-ésima menor intensidade nessa gama. Dada uma lista de eventos observacionais misturando informações solicitadas pelos cientistas e trocas de intensidade de onda no espectro, sua tarefa é ajudar os cientistas respondendo a suas perguntas.
#### Entrada
A primeira linha contém dois números inteiros $N$ e $Q$, representando o número de comprimentos de onda medidos e o número de eventos, respectivamente. A segunda linha contém $N$ inteiros $I_1, I_2,\ldots , I_N$, representando $I_i$ a intensidade inicial do i-ésimo comprimento de onda. Cada uma das $Q$ linhas seguintes corresponde a um evento e começa com um caractere que representa o tipo de evento. Se o evento corresponde a uma consulta dos cientistas do ICPC, o caractere é um 'Q'; Se corresponde a uma reação de troca atômica é um 'S'. Os eventos de consulta têm três inteiros $A$, $B$ e $K$ após o caractere 'Q', representando que os cientistas estão interessados na $K$-ésima menor intensidade na faixa de $A$ a $B$, inclusive. Os eventos de troca de intensidade têm um único inteiro $W$ após o caracter 'S', representando que as intensidades para os comprimentos de onda nas posições $W$ e $W$ + 1 no espectro são trocadas.
#### Saída
A saída contém uma linha para cada evento de consulta na entrada, contendo um único número inteiro representando a intensidade do comprimento de onda com a $K$-ésima menor intensidade na faixa do espectro de $A$ para $B$, inclusive (onde $A$, $B$ e $K$ são os parâmetros especificados na consulta correspondente). As consultas devem ser respondidas na mesma ordem em que aparecem na entrada.
#### Restrições
* $1 \leq N, Q \leq 10^5$
* $0 \leq I_i \leq 10^9$ para $i = 1, 2, \ldots,N$
* $1 \leq A \leq B \leq N$ e $1 \leq K \leq B - A + 1$
* $1 \leq W \leq N - 1$
|
2,837 | 358 | Robô | Difícil | Estruturas | Em um labirinto retangular, de $Y$ centímetros de altura e $X$ centímetros de largura, são colocadas $X-1$ barreiras verticais igualmente espaçadas entre si. Nosso robô, de formato circular com 1 centímetro de diâmetro, precisa percorrer uma trajetória ortogonal, começando em qualquer ponto da parede esquerda do labirinto e terminando em qualquer ponto da parede direita, evitando, claro, as barreiras. Para ele economizar energia, a trajetória deve possuir o menor número possível de segmentos de reta. É esse número que o seu programa deve computar!
A figura acima ilustra um labirinto com $X=33$ e, portanto, com 32 barreiras. A parte de cima da figura ilustra uma possível trajetória com 23 segmentos. Na parte de baixo da figura, uma trajetória com número mínimo possível de segmentos, 13.
#### Entrada
A primeira linha da entrada contém dois inteiros $Y$ e $X$. As $X-1$ próximas linhas contêm, cada uma, dois inteiros $I$ e $F$, com $I < F$, $0 \leq I,F \leq Y$ e $(F-I) < Y$, definindo a posição inicial e final de cada barreira. As barreiras são dadas em ordem, da mais à esquerda, para a mais à direita.
#### Saída
Seu programa deve imprimir um inteiro, o número mínimo possível de segmentos em uma trajetóra do robô.
#### Restrições
* $5 \leq Y, X \leq 10^5$;
* Em um conjunto de casos de teste equivalente a 40 pontos, $5 \leq Y, X \leq 10^3$
|
2,838 | 2032 | Sugoroku e Peças | Médio | Estruturas | JOI está segurando um gamão. Este gamão consiste em 2019 quadrados em uma linha horizontal. Estes quadrados são numerados de 1 a 2019, começando do quadrado inicial na extremidade esquerda até o quadrado final na extremidade direita.
Existem atualmente $N$ peças no gamão. Estas peças são numeradas de 1 a $N$ em ordem de proximidade ao início. A peça $i \ (1 \leq i \leq N)$ está colocada no quadrado $X_i$. Todas as peças estão em quadrados diferentes.
JOI realiza $M$ operações. A j-ésima operação $(1 \leq j \leq M)$ move a peça $A_j$ um quadrado à frente. Entretanto, se o quadrado original for o quadrado de destino, ou se outra peça está colocada no quadrado de destino, a peça $A_j$ não avança e sua posição não muda.
Imprima a casa na qual cada peça estará colocada quando todas as operações forem concluídas.
#### Entrada
A entrada é fornecida pela entrada padrão no seguinte formato.
$N$
$X_1 \ X_2 \ X_2 ... \ X_N$
$M$
$A_1 \ A_2 ... \ A_M$
#### Saída
A saída possui $N$ linhas, onde a i-ésima linha $(1 \leq i \leq N)$ é o número do quadrado em que a peça $i$ estará quando todas as operações forem concluídas.
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq X_1 < X_2 < ... < X_N \leq 2019$
* $1 \leq M \leq 100$
* $1 \leq A_j \leq N \ (1 \leq j \leq M)$
##### Explicação do exemplo de entrada/saída 1:
Na primeira operação, a peça 1 seria movida do quadrado 2 para o quadrado 3. Entretanto, a peça 2 já está colocada no quadrado 3, portanto, a peça 1 não avança.
Na segunda operação, a peça 3 é movida do quadrado 6 para o quadrado 7.
Quando todas as operações são concluídas, a peça 1 esta no quadrado 2, a peça 2 esta no quadrado 3 e a peça 3 esta no quadrado 7.
##### Explicação do exemplo de entrada/saída 2:
Quando a terceira operação for concluída, a peça 2 estará colocada no quadrado 2019. Portanto, a peça 2 não avançará na quarta operação. |
2,839 | 1824 | Tempo de Espera | Médio | Estruturas | Você troca mensagens de texto com seus amigos. Como você recebe tantas mensagens, você quer medir quanto tempo seus amigos têm que esperar por suas respostas.
Seu dispositivo de mensagens registra cada mensagem recebida e enviada em ordem, utilizando os dois tipos de entradas a seguir:
* $R$ $X$ indica que uma mensagem foi recebida de um amigo com o número $X$;
* $S$ $X$ indica que uma mensagem foi enviada a um amigo com o número $X$.
Seu dispositivo de mensagens envia e recebe mensagens instantaneamente, e para cada par de entradas consecutivas descritas acima, ou
* uma única entrada $W$ $X$ é registrada entre eles, indicando que ocorrem com um intervalo de $X$ segundos, ou
* não há nenhuma entrada entre eles e eles ocorrem com um segundo de diferença.
Várias regras de etiqueta de mensagem são sempre seguidas:
* as únicas mensagens que você envia são respostas a mensagens que recebeu;
* você envia no máximo uma resposta a qualquer mensagem de qualquer amigo em particular;
* seus amigos não enviam uma mensagem subsequente até que você tenha respondido à mensagem anterior deles.
O tempo de espera por uma mensagem é o tempo que passa entre quando você a recebe e o momento em que você responde a ela. Se um amigo $X$ recebeu uma resposta para cada mensagem enviada, o tempo total de espera para o amigo $X$ é a soma de todos os tempos de espera para todas as mensagens do amigo $X$. Caso contrário, o tempo total de espera para o amigo $X$ é de $-1$.
Seu trabalho é determinar o tempo total de espera para cada amigo.
#### Entrada
A entrada consiste do número inteiro $M (1 \leq M \leq 20)$, seguido por $M$ linhas, onde cada linha consiste de um caractere ($W$, $R$, ou $S$), seguido por um espaço, seguido por um número inteiro $X (1 \leq X \leq 100)$. Estas $M$ linhas são as entradas descritas acima (em ordem).
#### Saída
Produza uma linha para cada amigo que enviou uma mensagem no formulário $X$ $T$ onde $X$ é um número de amigo e $T$ é o tempo total de espera para o amigo $X$. As linhas estão em ordem crescente dos números de amigos.
#### Explicação do Caso de Teste 1
O Amigo 2 envia uma mensagem no momento 0 e o Amigo 3 envia uma mensagem no momento 1. O Amigo 2 recebe uma resposta no momento 6 e o Amigo 3 recebe uma resposta no momento 7.
#### Explicação do Caso de Teste 2
Para o Amigo 12, uma mensagem é recebida no momento 0 e respondida no horário 13. Para o Amigo 23, duas mensagens são trocadas, sendo que a primeira mensagem tem um tempo de espera de 6 segundos e a segunda mensagem tem um tempo de espera de 2 segundos. Para o Amigo 34, uma mensagem é recebida no tempo 10 e respondida no tempo 12. O Amigo 45 envia uma mensagem a qual nunca é respondida.
|
2,840 | 345 | Binária | Muito Difícil | Estruturas | Neste problema estamos interessados em árvores binárias de busca, que são árvores binárias (onde cada nó possui até dois nós filhos, o esquerdo e o direito), onde os nós possuem valores naturais distintos, satisfazendo a restrição de que se o valor de um nó é $X$, então todos os valores na sua sub-árvore esquerda são menores do que $X$ e todos os valores na sua sub-árvore direita são maiores do que $X$. Dado uma árvore binária de busca $T$, para inserir um novo valor $Y$ realizamos o seguinte procedimento recursivo:
* se $T$ estiver vazia, o valor $Y$ é inserido como a raiz de $T$;
* senão, se o valor na raiz de $T$ for maior do que $Y$, então o valor $Y$ será inserido na sub-árvore esquerda de $T$; e se o valor for menor, será inserido na sub-árvore direita de $T$.
Por exemplo, considere a figura abaixo. Começando com uma árvore vazia e inserindo valores na ordem (4,6,5,7), obteremos ao final a árvore binária de busca mais a direita na figura. Notamos que essa árvore tem altura 3, que é o número de vértices no caminho mais longo entre a raiz e um nó folha (que não tem filhos) da árvore.
Se considerarmos os sete primeiros números naturais, faltam nessa árvore os valores {1,2,3}. Se quisermos inserir esses valores que faltam, a altura final que a árvore terá, quando estiver com os 7 valores, depende da ordem em que os valores forem inseridos. Por exemplo, se forem inseridos na ordem (2,1,3) a árvore final terá altura 3; mas se a ordem de inserção for (1,3,2), então a altura final será 4, como mostrado na figura abaixo.
Neste problema, dados três inteiros $N$, $K$ e $H$, e uma sequência fixa de $K$ inteiros distintos $v_1, \ldots, v_k$, com $1 \leq v_i \leq N$, para todo i, considerando que esses $K$ valores serão inicialmente inseridos na árvore de busca nesta ordem, queremos calcular quantas ordens distintas dos $N-K$ valores naturais restantes entre 1 e $N$ resultarão em árvores de altura $H$.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $K$ e $H$, respectivamente o número final de nós, o número de valores na sequência fixa inicial e uma altura $H$. A segunda linha contém a sequência de inteiros distintos inseridos inicialmente.
#### Saída
Seu programa deve imprimir uma linha, contendo um inteiro, o número de ordens distintas dos $N-K$ valores naturais restantes entre 1 e $N$ que resultarão em árvores binárias de busca de altura exatamente $H$. Como esse número pode ser muito grande, imprima o resto da divisão dele por $10^9+7$.
#### Restrições
* $1 \leq N \leq 100$
* $0 \leq K \leq N$
* $1 \leq H \leq N$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste cuja soma é 25 pontos: $N \leq 8$
* Em um outro conjunto de casos de teste cuja soma é 25 pontos: $K = 0$
|
2,841 | 1920 | Bons grupos | Médio | Estruturas | Uma classe foi dividida em grupos de três. Esta divisão em grupos pode violar dois tipos de restrições: alguns estudantes devem trabalhar juntos no mesmo grupo, e alguns estudantes devem trabalhar em grupos separados.
Seu trabalho é determinar quantas das restrições são violadas.
#### Entrada
A primeira linha conterá um número inteiro $X$ com $X \ \ge \ 0$. As próximas $X$ linhas consistirão cada uma de dois nomes diferentes, separados por um único espaço. Estes dois alunos devem estar no mesmo grupo.
A próxima linha conterá um número inteiro $Y$ com $Y \ \ge \ 0$. As próximas $Y$ linhas consistirão cada uma de dois nomes diferentes, separados por um único espaço. Estes dois estudantes não devem estar no mesmo grupo.
Entre estas $X + Y$ linhas que representam restrições, cada possível par de estudantes aparece no máximo uma vez.
A próxima linha conterá um número inteiro de $G$ com $G \ \ge \ 1$. As últimas $G$ linhas consistirão cada uma em três nomes diferentes, separados por espaços individuais. Estes três alunos foram colocados no mesmo grupo.
Cada nome consistirá de letras maiúsculas entre $1$ e $10$. Não haverá dois alunos com o mesmo nome e cada nome aparecendo em uma restrição aparecerá exatamente em um dos $G$ grupos.
#### Saída
Imrpima um número inteiro entre 0 e $X +Y$, que é o número de restrições que são violadas.
##### Explicação da Entrada/Saída de Exemplo 1:
Há apenas uma restrição e ela não é violada: ELODIE e CHI estão no mesmo grupo.
##### Explicação da Entrada/Saída de Exemplo 2:
A primeira restrição é que A e B devem estar no mesmo grupo. Isto é violado.
A segunda restrição é que G e L devem estar no mesmo grupo. Isto é violado.
A terceira restrição é que J e K devem estar no mesmo grupo. Isto não é violado.
A quarta restrição é que D e F não devem estar no mesmo grupo. Isto é violado.
A quinta restrição é que D e G não devem estar no mesmo grupo. Isto não é violado.
Das cinco restrições, três são violadas. |
2,842 | 2159 | Laserzinho | Difícil | Estruturas | Mariazinha adora jogos online, e recentemente anda viciada em um jogo que conheceu a pouco tempo. A personagem do jogo é uma aventureira atrás de um tesouro. Ela está dentro de uma caverna onde o tesouro foi escondido, porém essa caverna está cheia de armadilhas. Após passar por todas, Mariazinha finalmente consegue chegar na fase final: a fase dos Lasers. Basicamente, ela é colocada em um plano, no formato de um tabuleiro, onde existe um laser em cada posição. Os lasers são aleatoriamente ativados e desativados. Quando um laser é ativado, ele bloqueia o acesso a todas as posições que fazem parte da mesma linha ou da mesma coluna da posição daquele laser. Mariazinha quer sua ajuda pra identificar se certo subgrid do tabuleiro está totalmente coberto por lasers ou não. Você receberá $Q$ queries, que podem ser de três tipos:
1. $A$ $x$ $y$ - Ativa o laser da posição $(x, y)$.
2. $R$ $x$ $y$ - Desativa o laser da posição $(x, y)$.
3. $Q$ $x_1$ $y_1$ $x_2$ $y_2$ - Imprima ’S’ se todas as posições dentro do subgrid com canto superior na posição $(x_1, y_1)$ e canto inferior na posição $(x_2, y_2)$ forem cobertas por lasers, e ’N’ caso contrário.
É garantido que não haverão queries que tentarão ativar um laser já ativado, ou desativar um laser já desativado. Você pode ajudar Mariazinha a responder todas as queries do tipo 3?
#### Entrada
A primeira linha de entrada contém dois inteiros $N$ e $M$, representando a quantidade de linhas e colunas do tabuleiro, respectivamente. A segunda linha de entrada contém um inteiro $Q$, representando o número de queries. As próximas $Q$ linhas representam cada uma uma query, no formato especificado anteriormente. É garantido que todas as queries são válidas.
#### Saída
Imprima, para cada query do tipo 3, um caractere ’S’ se todas as posições dentro do subgrid forem cobertas por lasers, e ’N’ caso contrário.
#### Restrições
* $1 ≤ N, M ≤ 100$
* $1 ≤ Q ≤ 200$
* $1 ≤ x ≤ N$
* $1 ≤ y ≤ M$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 10 pontos, $N = M = 2$.
* Em um conjunto de casos de teste somando 90 pontos, nenhuma restrição adicional.
|
2,843 | 112 | Batata Quente | Muito Difícil | Estruturas | Batata quente é uma brincadeira bastante popular entre crianças na escola. A brincadeira é simples: a criança que está com a batata a joga para uma outra criança. Em algum momento, o professor, que não está olhando para o que está acontecendo, irá dizer que a brincadeira acabou. Quando isso acontece, a criança que está com a batata perde. Uma variação da brincadeira, jogada na fila da cantina, é proposta por um professor. As crianças estão numeradas de 1 a $N$ de acordo com sua posição na fila, onde a criança com o número 1 é a primeira da fila.
Cada uma receberá um papel com um número, e sempre que receber a batata, deverá passá-la para a criança na posição anotada em seu papel. O jogo termina com o professor vitorioso se a batata chegar em uma posição menor ou igual a $X$ na fila, com $X$ definido no início da brincadeira. Se isso nunca acontecer, o jogo nunca termina, porém as crianças saem vitoriosas: no dia seguinte todas ganham um desconto na cantina.
O professor começa o jogo jogando a batata para alguma criança na fila. Como sua mira não é muito boa, ele só consegue garantir que vai jogar a batata para alguma criança em um invervalo $L \ldots R$ da fila com a mesma probabilidade. Ele está considerando vários possíveis intervalos da fila para iniciar a brincadeira. Para isso, o professor gostaria de descobrir, para cada um desses intervalos, qual o valor de $X$ que ele deve escolher para que o jogo seja o mais justo possível, ou seja, a probabilidade de o jogo terminar seja a mais próxima possível da probabilidade de o jogo não terminar.
Você deve auxiliar o professor a avaliar as propostas. Dados os papéis de cada criança da fila e vários intervalos possíveis, responda, para cada intervalo, o valor de <b>X</b> que torne o jogo mais justo possível. Se houver empate, responda o $X$ mais próximo do início da fila.
#### Entrada
A primeira linha da entrada contém dois inteiros, $N$ e $Q$. A linha seguinte contém <b>N</b> inteiros $p_1, p_2 \cdots p_N$, os valores dos papéis recebidos por cada uma das crianças. Seguem então $Q$ linhas, cada uma com dois inteiros $L$ e $R$, representando um intervalo considerado pelo professor.
#### Saída
Imprima $Q$ linhas, cada uma contendo, para cada intervalo considerado pelo professor, o número inteiro $X$ que o professor deverá escolher para que a brincadeira seja a mais justa possível.
#### Restrições
* $2 \leq N \leq 50000$
* $1 \leq Q \leq 10^5$
* $1 \leq p_i \leq N$
* $1 \leq L \leq R \leq N$
#### Importante
Os casos de testes desse problema o tornam muito difíceis de soluções em Python, Javascript e Java passarem no tempo. |
2,844 | 1503 | Cupim ganancioso | Muito Difícil | Estruturas | Existem $N$ hastes de madeira colocadas verticalmente sobre uma linha horizontal. As hastes são numeradas de 1 a $N$ da esquerda para a direita. Cada barra $i \ (1 \leq i \leq N)$ é colocada na posição $x_i$ e tem uma altura $h_i$.
Um cupim quer comer todas as hastes, uma a uma. Ele começa comendo de uma haste arbitrária $s \ (1 \leq s \leq N)$. Então, depois de comer uma vara $i$, o cupim seleciona a próxima vara a comer com base no seguinte método. Dentre as demais hastes $j$, aquela com máximo $h_j - | x_i -x_j |$ é selecionado. Se houver empate, aquele com mínimo $| x_i -x_j |$ é selecionado. Se ainda houver empates, a barra mais à esquerda é selecionada.
Sua tarefa é calcular a distância total (horizontal) percorrida pelo cupim para comer todas as hastes.
#### Entrada
A primeira linha da entrada contém dois inteiros separados por espaço $N$, o número de hastes e $s$, o número da hastes inicial $(1 \leq s \leq N \leq 100000)$. As hastes são descritas nas próximas $N$ linhas. Na linha $1 + i \ (1 \leq i \leq N)$, a i-ésima barra é especificada com dois inteiros separados por espaço $x_i \ (| x_i | \leq 10^9)$ e $h_i \ (1 \leq h_i \leq 10^9)$. Além disso, para cada $i \ (1 \leq i \leq N - 1)$, $x_i <x_i + 1$.
#### Saída
Você deve imprimir um único inteiro denotando a distância total percorrida pelo cupim. |
2,845 | 562 | Simulador | Difícil | Estruturas | Um novo processador, denominado Faíska, está sendo desenvolvido para a empresa SBC. Este novo processador tem apenas duas instruções: inversão e soma, descritas a seguir.
* Inversão: dados dois endereços de memória $X$ e $Y$ , a operação inverte($X,Y$) inverte a posição de palavras da memória de forma que
* a palavra no endereço $X$ troca de posição com a palavra de memória da posição $Y$;
* a palavra no endereço $X + 1$ troca de posição com a palavra de memória da posição $Y - 1$;
* a palavra no endereço $X + 2$ troca de posição com a palavra de memória da posição $Y - 2$;
* e assim por diante, até que $X \geq Y$.
* Soma: dados dois endereços de memória $X$ e $Y$ , a operação soma($X,Y$) imprime a soma das palavras de memória entre os endereços $X$ e $Y$ (inclusive).
Por exemplo, se a memória contém inicialmente, a partir da primeira posição de memória (endereço igual a 1) os valores [1,2,3,4,5,6,7,8], a operação inverte(3,7) deixa a memória igual a [1,2,7,6,5,4,3,8]. Então, nesse estado, a execução de soma(1,3) produz a saída 10.
Sua tarefa é escever um programa que, dada uma sequência de instruções do Faíska, simule a execução e produza o mesmo resultado que o Faíska produziria
#### 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 dois números inteiros $N$ e $M$, representando respectivamente o número palavras na memória ($1 \leq N \leq 10^9$) e o número de instruções do programa ($1 \leq M \leq 3000$). Cada uma das $M$ linhas seguintes contém uma instrução do Faíska. Cada instrução é composta de um caratere descrevendo a instrução (‘I’ para inversão e ‘S’ para soma), seguido de um espaço, seguido de dois inteiros indicando os argumentos da instrução. Inicialmente a configuração da memória é tal que cada palavra tem como conteúdo o seu próprio endereço. Em outras palavras, o conteúdo inicial da memória é $[1,2,3,\ldots,N]$. Há pelo menos uma instrução soma em cada caso de teste.
#### Saída
Seu programa deve imprimir, na saída padrão, uma sequência de números inteiros, um em cada linha, indicando a saída gerada pelo Faíska.
#### Informações sobre a pontuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 100$ e $M \leq 100$.
* Em um conjunto de casos de teste que totaliza 70 pontos, $N \leq 10^4$ e $M \leq 10^3$. |
2,846 | 1542 | Procurando Strings | Difícil | Estruturas | É dada uma string $N$, chamada a agulha, e uma string $H$, chamada o palheiro, ambas contendo apenas letras minúsculas `a`...`z`.
Escreva um programa para contar o número de permutações distintas de $N$ que aparecem como substring de $H$ pelo menos uma vez. Note-se que $N$ pode ter no total entre $1$ e $|N|!$ permutações distintas - por exemplo, a string `aab` tem $3$ permutações distintas (`aab`, `aba`, e `baa`).
#### Entrada
A primeira linha contém $N (1≤|N|≤200000)$, a string de agulha.
A segunda linha contém $H (1≤|H|≤200000)$, a string de palheiro.
#### Saída
A saída consiste de um inteiro, o número de permutações distintas de $N$ que aparecem como substring de $H$.
#### Explicação da Saída para o Caso de Teste
As permutações `aba` e `baa` aparecem cada uma como substrings de $H$ (a primeira aparece duas vezes), enquanto que a permutação `aab` não aparece. |
2,847 | 2360 | Pregue! | Difícil | Estruturas | Tudor é um competidor na Competição de Carpintaria Canadense (CCC). Para vencer a CCC, Tudor deve demonstrar sua habilidade em pregar tábuas de madeira para fazer a cerca mais longa possível. Para alcançar esse objetivo, ele possui $N$ peças de madeira. A i-ésima peça de madeira tem comprimento inteiro $L_i$.
Uma tábua é feita exatamente com duas peças de madeira. O comprimento de uma tábua feita de madeiras com comprimentos $L_i$ e $L_j$ é $L_i + L_j$. Uma cerca consiste em tábuas que têm o mesmo comprimento. O comprimento da cerca é o número de tábuas usadas para construí-la, e a altura da cerca é o comprimento de cada tábua na cerca. No exemplo de cerca abaixo, o comprimento da cerca é $4$; a altura da cerca é $50$; e o comprimento de cada peça de madeira é mostrado:
Tudor gostaria de fazer a cerca mais longa possível. Por favor, ajude-o a determinar o comprimento máximo de qualquer cerca que ele poderia fazer, e o número de alturas diferentes que uma cerca desse comprimento máximo poderia ter.
#### Entrada
A primeira linha conterá o inteiro $N \ (2 \leq N \leq 1 \ 000 \ 000)$.
A segunda linha conterá $N$ inteiros separados por espaço $L_1, \ L_2, . . . , L_N \ (1 \leq L_i \leq 2 \ 000)$.
#### Saída
Imprima dois inteiros em uma única linha separados por um único espaço: o comprimento da cerca mais longa e o número de alturas diferentes que uma cerca com o comprimento máximo poderia ter.
##### Explicação Exemplo de Entrada/Saída 1:
Tudor primeiro combina as peças de madeira com comprimentos $1$ e $4$ para formar uma tábua de comprimento $5$. Então ele combina as peças de madeira com comprimentos $2$ e $3$ para formar outra tábua de comprimento $5$. Finalmente, ele combina as tábuas para fazer uma cerca com comprimento $2$ e altura $5$.
##### Explicação Exemplo de Entrada/Saída 2:
Tudor não pode fazer uma cerca com comprimento maior que $1$, e existem $10$ formas de fazer uma cerca com comprimento $1$, escolhendo qualquer duas peças de madeira para pregar juntas. Especificamente, ele pode ter uma cerca com altura $11, \ 101, \ 1001, \ 2001, \ 110, \ 1010, \ 2010, \ 1100, \ 2100$ e $3000$. |
2,848 | 1579 | Agenda da Lola | Difícil | Estruturas | Lola é uma garota enérgica com muitos interesses, tornando cada dia um oceano de possibilidades para ela, cheio de atividades emocionantes nas quais ela está mais do que disposta a participar. Infelizmente, muitas das atividades em que Lola participa acontecem em espaços fechados, e por causa disso seus níveis de vitamina D estão um pouco abaixo do ideal. Para ajudar, um médico prescreveu um suplemento vitamínico que ela deve tomar diariamente a cada $X$ minutos.
Lola escreveu um aplicativo para manter o controle de suas atividades. A principal característica do aplicativo é o agendamento das atividades. Cada atividade consiste de um título e seus horários de início e fim. O aplicativo também permite criar lembretes únicos, consistindo simplesmente em um título e no momento em que ela deve receber uma única notificação, e lembretes recorrentes, consistindo em um título, o tempo para a primeira notificação, e com que freqüência o lembrete deve ser repetido. Depois de comprar o suplemento, Lola quer adicionar um lembrete recorrente ao aplicativo, que se repete a cada $X$ minutos, para ter certeza de que ela será notificada sempre que chegar a hora de tomar o suplemento. O ideal é que ela prefira não ter que tomar o suplemento enquanto participa de uma atividade. Com uma agenda tão ocupada, ela está tendo dificuldades para chegar ao momento ideal para começar a tomá-lo.
Sua tarefa é ajudar Lola a escolher o momento ideal $T$ após a compra do suplemento para tomá-lo pela primeira vez. Diz-se que um tempo de $T$ é o ideal se passar no máximo $8$ horas do momento em que Lola comprou o suplemento, o número de vezes em que ela precisa tomar o suplemento que entra em conflito com suas atividades é mínimo, e não há outro tempo anterior a $T$ que resultaria no mesmo número de conflitos.
#### Entrada
A primeira linha contém dois inteiros $N (1 ≤ N ≤ 10^4)$ e $X (1 ≤ X ≤ 720)$, indicando que Lola tem $N$ de atividades futuras exportadas de seu aplicativo, e que ela deve tomar o suplemento a cada $X$ minutos. Cada uma das seguintes linhas $N$ descreve uma atividade com dois inteiros $S$ e $D (1 ≤ S, D ≤ 10^5)$, representando que a atividade começa $S$ minutos após a compra do suplemento, e que sua duração é de $D$ minutos. As atividades não se sobrepõem, ou seja, dado qualquer par de atividades diferentes, uma delas termina estritamente antes da outra começar, ou vice-versa.
#### Saída
Produzir uma única linha com dois inteiros $T$ e $C$, indicando respectivamente o tempo ideal para tomar o suplemento pela primeira vez, expresso em minutos desde a compra do suplemento, e o número de conflitos que tomar o suplemento neste momento levará. |
2,849 | 120 | Jogos Olímpicos | Difícil | Estruturas | Um grupo de investidores está pensando em investir pesado em atletas da delegação brasileira após as olimpíadas do Rio. Para isso, eles vêm observando $N$ atletas e perceberam que alguns estão em decadência e outros em ascensão. Em especial, o grupo está de olho em dois fatores sobre cada atleta: seu cansaço e sua habilidade. Eles anotaram os valores de habilidade e cansaço de cada atleta logo ao final das olimpíadas de 2016. Em seguida, o grupo estimou a taxa com a qual cada atleta perde ou ganha habilidade e a taxa com a qual cada atleta se cansa ao longo do tempo, e percebeu que essas taxas são constantes para os dois atributos.
Os investidores perceberam que esses dados lhes permitem definir o que resolveram chamar de atleta de ouro: um atleta que, em um determinado período de tempo, é o atleta menos cansado e o mais habilidoso. Ficou decidido que investimentos serão feitos apenas em atletas de ouro. Descubra quantos jogadores, entre os observados inicialmente, receberão algum investimento. Considere que o tempo $t = 0$ é o tempo das olimpíadas do Rio: nenhum atleta que foi de ouro antes desse tempo pode receber investimento. Considere também que qualquer tempo após as olimpíadas do Rio deve ser considerado, por maior que seja. Um atleta que é de ouro exatamente no tempo <b>t</b> = 0 deve ser contado.
#### Entrada
A primeira linha da entrada contém um inteiro, <b>N</b>, o número de atletas. Seguem <b>N</b> linhas, cada uma com quatro números inteiros: $H_i, H^{t}_i , C_i, C^{t}_i$, representando, respectivamente, a habilidade ao final das olimpíadas, a taxa de variação da habilidade, o cansaço ao final das olimpíadas e a taxa de variação do cansaço do i-ésimo atleta.
#### Saída
Seu programa deve produzir uma única linha com um inteiro <b>O</b>, representando o número de atletas que receberão algum investimento do grupo.
#### Restrições
* $1 \leq N \leq 10^5$
* $-10^6 \leq H_i, H^{t}_i , C_i, C^{t}_i \leq\ 10^6$, $H^{t}_i$ e $C^{t}_i$ $\neq$ 0 |
2,850 | 1239 | Mount Marathon | Difícil | Estruturas | Mount Marathon é um jogo solitário que é jogado com um baralho normal de 52 cartas. Para iniciar o jogo, o jogador embaralha o baralho e coloca $N$ cartas viradas para cima na mesa, formando uma linha reta de $N$ pilhas, tendo cada pilha uma única carta. Nenhuma outra carta é utilizada durante o resto do jogo. Então o jogador move repetidamente uma pilha em cima de outra pilha até que não haja mais movimentos disponíveis. O objetivo do jogo é acabar com o número mínimo de pilhas. Ao mover uma pilha em cima de outra pilha $q$, as seguintes condições devem ser mantidas:
* A pilha $p$ deve ser uma pilha de uma só carta.
* O valor da única carta da pilha $q$ deve ser maior ou igual ao valor da carta que está em cima da pilha $q$.
* A pilha $q$ deve ser a próxima pilha restante imediatamente à direita da pilha $p$.
A figura (a) abaixo mostra uma configuração com seis cartas no início do jogo. O jogador pode mover a quinta pilha para o topo da sexta, e depois a segunda pilha para topo da terceira; uma vez que não há mais movimentos disponíveis, isto concluiria o jogo com quatro pilhas restantes, como se pode ver na figura (b). Contudo, neste caso é possível terminar o jogo apenas com as três pilhas que aparecem na figura ( c ).
Dadas as pilhas iniciais, é necessário determinar o número mínimo de pilhas que é possível obter no final do jogo.
#### Entrada
A primeira linha contém um número inteiro de $N \ (1 \ \leq \ N \ \leq \ 52)$ representando o número de cartas no jogo. A segunda linha contém $N$ inteiros $C_1, \ C_2, . . . , \ C_N \ (1 \ \leq \ C_i \ \leq \ 13$ for $i \ = \ 1, \ 2, . . . , \ N)$ indicando os valores das cartas nas pilhas iniciais, da esquerda para a direita. Cada valor das cartas aparece no máximo quatro vezes.
#### Saída
Produzir uma única linha com um número inteiro indicando o número mínimo de pilhas que é possível obter no final do jogo. |
2,851 | 99 | Dispositivo Assombrado | Difícil | Estruturas | Em uma recente viagem a uma escavação arqueológica na ilha caribenha de São Basil, você encontrou um misterioso dispositivo com instruções que lembram um enigma. Seu guia local Vibenas diz que caso você resolva o enigma, o dispositivo talvez lhe mostre o local onde um grande tesouro deixado pelo sanguinário pirata Lyerpes está escondido.
O dispositivo tem uma fita com $L$ células indexadas de 0 à $L-1$. Cada célula possui uma cor que pode ser alterado através dos comandos do dispositivo. Cada cor é codificada como um inteiro, e inicialmente todas as células possuem a mesma cor. As instruções que você encontrou representam N passos que devem ser executados antes do dispositivo mostrar o caminho do tesouro. Cada passo é descrito usando 4 inteiros $P$, $X$, $A$ e $B$. As instruções dizem que para completar um passo você deve contar o número de células que atualmente possuem a cor P. Digamos que este número seja S. Então você deve calcular os valores
$$ M_1 = (A + S^2 )\ mod\ L $$
$$ M_2 = (A + (S + B)^2)\ mod\ L$$
Finalmente você deve fazer todas as células no intervalo fechado [min($M_1$,$M_2$, max($M_1$,$M_2$)] serem da cor de $X$.
Após essa exaustiva tarefa de processar os $N$ passos requeridos pelo dispositivo, você tera ainda um trabalho: dada a cor que aparece o maior número de vezes no dispositivo após todos os passos (isto é, a cor mais frequente), você deve ir ao local do naufrágio do navio de Lyerpe e dizer em voz alta o número de celulas que possuem tal cor. Note que este número é único mesmo se mais de uma cor aparecer o maior número de vezes no dispositivo após todos os passos.
Realizando todos estes cálculos no dispositivo levariam gerações, mas você, um renomado programador, pode criar um programa que rapidamente indica a resposta para o enigma. Após isso, o verdadeiro desafio será encontrar o local do naufrágio do velho navio de Lyerpes.
#### Entrada
O primeiro número contem três inteiros $L$, $C$ e $N$ ($1 \leq L, C, N \leq 10^5$ ), representando respectivamente o número de celulas na fita, o número de cores disponíveis e o número de passos nas instruções. Cores são identificadas por inteiros distintos indo de 1 à $C$ e inicialmente todas as células contem 1 cor. Cada uma das próximas $N$ linhas descreve um passo das instruções com 4 inteiros $P$, $X$, $A$ e $B$ ($1 \leq P, X \leq C$ e $0 \leq A, B \leq 10^8$ ), indicando respectivamente a cor a qual o número de celulas é usado para decidir o intervalo dos valores usado para calcular os limites como acima descritos.
#### Saída
Dado uma cor que aparece o maior número de vezes na fita do dispositivo após realizar a sequência de passos descrita na entrada, imprima uma única linha com um inteiro que indica o número de células contendo aquela cor. |
2,852 | 109 | Moeda de Mármore | Muito Difícil | Estruturas | Cubiconia é conhecido por ter uma das maiores taxas de imposto. Os impostos são calculados diariamente e até mesmo coisas que parecem inúteis estão sujeitas a impostos. Alguns dos amigos do imperador criaram uma nova moeda usando mármores. Infelizmente, não deu certo, os mármores também ficaram sujeitos a impostos.
Apesar disso, o imperador acredita que usar mármore como moeda é uma grande ideia e que no futuro ele irá valer muito mais. Então ele decidiu roubar todos os mármores dos seus amigos. Para não chamar atenção desnecessária, cada noite ele irá visitar um de seus amigos e durante cada visita irá roubar exatamente um mármore. Como os amigos do imperador mantém seus mármores em pilhas, apenas o mármore no topo da pilha pode ser roubado.
Cada mármore tem um valor associado a ele. O valor de imposto de um mármore e calculado por $V * 365^D$ onde $V$ é o valor associado ao mármore e $D$ é a quantidade de dias que ele mantém o mármore. O emperador planeja vender todo o mármote quando terminar de roubar todos eles. Isso significa que, se há um total de $T$ mármores, o mármore que ele irá manter por menos tempo ele mantém por 1 dia, enquanto o primeiro mármore que ele roubou ele terá mantido por $T$ dias.
O imperador é inteligente e já percebeu. Para evitar pagar mais impostos do que o necessário, ele gostaria de saber a melhor ordem para roubar os mármores. Você pode ajudá-lo?
#### Entrada
A primeira linha contém um inteiro $N$ ($1 \leq N \leq 10^5$) representando o número de pilhas que o imperador planeja roubar. Cada uma das próximas $N$ linhas descreve uma pilha com um inteiro $K$ ($1 \leq K \leq 10^5$); seguido de $K$ inteiros $V_1, V_2, \ldots, V_K$ ($1 \leq V_i \leq 300$ para $i = 1, 2,\ldots, K$); O número $K$ é a quantidade de peças de mármore na pilha, enquanto $V_1, V_2, \ldots, V_K$ são os valores dos mármores na pinha de cima para baixo. A quantiadade é mármores é no máximo $4*10^5$
#### Saída
Imprima uma única linha contendo um inteiro representando o valor mínimo das taxas se os mármores forem roubados na ordem ótima. Como esse número pode ser muito grande, imprima o resto da divisão por $10^9+7$.
|
2,853 | 102 | Portas da Incerteza | Difícil | Estruturas | Uma porta NAND (porta AND negada) é um circuito digital que produz uma saída que é falsa apenas se todas as entradas são verdadeiras; em outras palavras, a saída de uma porta NAND é o oposto para a saída de uma porta AND para as mesmas entradas. A seguinte figura mostra o símbolo usual de uma porta NAND de duas entradas e sua tabela verdade resultante, usando 1 para verdade e 0 para falso.
Neste problema nos temos uma árvore binaria representado o circuito composto apenas por portas NAND de duas entradas. Em uma árvore, cada nó interno representa uma porta NAND, a qual usa como entrada os valores produzidos pelas suas filhas. Cada folha na árvore representa uma entrada externa ao circuito, e é um valor em {0, 1}. O valor produzido pelo circuito é o valor produzido pela porta na raiz da árvore. A seguinte imagem mostra um circuito com 9 nós, o dos quais 4 são portas NAND e cinco são entradas externas.
Cada porta no circuito pode estar emperrada, quer dizer que ela apenas produzem 0 ou apenas produzem 1 independente das entradas do portão. Um padrão teste é um array de valores associados às entradas externas de forma que o valore produzido pelo circuito está incorreto devido ao emperramento de uma das portas.
Dada uma descrição do circuito, você deve escrever um programa que determine o número de maneiras diferentes de escrever um padrão de testes para o circuito.
#### Entrada
A primeira linha contem um inteiro $N$ ($1 \leq N \leq 10^5$ ) representando o número de portas no circuito, o qual possui forma de uma árvore binaria. Portas são identificadas por inteiros distintos indo de 1 a $N$, porta um sendo a raiz da árvore. Para $i = 1, 2,\ldots,N$, o i-ésimo das próximas $N$ linhas descreve a porta $i$ com três inteiros $X$, $Y$ e $F$ ($0 \leq X, Y \leq N$ e $-1 \leq F \leq 1$). Os valores $X$ e $Y$ indicam as duas entradas da porta. Se $X = 0$ a primeira entrada é proveniente de uma entrada externa, senão a entrada é a saída produzida pela porta $X$. Analogamente, se $Y = 0$, a segunda entrada é uma entrada externa, senão a entrada é a saída produzida pela porta $Y$. O valor de $F$ representa o estado da porta: -1 significa que a porta está normal, 0 significa que ela está emperrada em 0, e 1 significa que a porta está emperrada em 1.
#### Saída
Imprima uma única linha com um inteiro indicando o número de maneiras diferentes de padrões teste para o dado circuito. Devido à possibilidade deste número ser muito grande, imprima o resto de sua divisão por $10^9+7$.
|
2,854 | 2310 | Clube de Contagem de Cartas | Difícil | Estruturas | Durante a criação do Clube de Contagem de Cartas, o clube queria combinar sua prática de contagem de cartas com o processo de escolha da ordem dos jogadores em seus jogos. Eles convergiram em um jogo de contagem que é jogado da seguinte forma:
1. No início do jogo, cada jogador recebe uma mão com o mesmo número de cartas que os demais.
2. Cada jogador começa a vez mostrando a carta com o menor valor em sua mão para os outros jogadores.
3. O jogador com a menor carta pode descartá-la.
1. Apenas um jogador pode descartar sua carta, e os empates são desfeitos escolhendo-se o jogador cujo nome vem primeiro lexicograficamente (ou seja, na ordem padrão do dicionário).
2. Todos os jogadores que não descartarem suas cartas deixam uma pequena marca na carta e a colocam de volta na mão. Cada marca aumenta o valor da carta em um valor de penalidade acordado.
4. Quando um jogador fica sem cartas, ele é contado como eliminado.
5. O jogo é disputado até que todos os jogadores sejam contados.
Quando o jogo termina, a ordem em que os jogadores foram contados é usada para escolher a ordem em que os membros do clube jogarão outros jogos.
Com o passar do tempo, o clube aumentou para 35 pessoas e o custo das cartas e o tempo necessário para jogar o jogo se tornaram excessivos. Assim, o clube recorre a você para criar um programa que jogue o jogo para eles, economizando tempo e o custo das cartas de baralho.
#### Entrada
A primeira linha contém três inteiros $N, M, P$ $( 2 \leq N \leq 35$, $1 \leq M \leq 17\ 000$ e $1 \leq P \leq 10$) em que $N$ é o número de jogadores, $M$ é o tamanho da mão de cada jogador e $P$ é o valor da penalidade para cada marca. As próximas $N$ linhas contêm o nome do jogador seguido de $M$ inteiros separados por espaço $x_1, x_2, \ldots , x_ N$ ($1 \leq x_ i \leq 200\ 000$ para cada $1 \leq i \leq M$) representando os valores das cartas na mão do jogador. Os valores podem se repetir dentro e entre as mãos. O nome de cada jogador consistirá apenas de letras maiúsculas e terá um tamanho entre $2$ e $10$.
#### Saída
Em uma única linha, exiba a lista de nomes de jogadores na ordem em que eles são contados no jogo normal. Os nomes consecutivos nessa linha devem ser separados por um espaço simples. |
2,855 | 1439 | Lição de matemática | Muito Difícil | Estruturas | Seu professor de matemática deu a você uma tarefa envolvendo a obtenção de uma sequência de $N$ inteiros $A_1,... , \ A_N$, de modo que $1 \ \leq \ A_i \ \leq \ 1 000 000 000$ para cada $i$.
A sequência $A$ também deve satisfazer $M$ requisitos, com o i-ésimo afirmando que o GCD (maior divisor comum) da subsequência contígua $A_{X_i},... , A_{Y_i} \ (1 \ \leq \ X_i \ \leq \ Y_i \ \leq \ N)$ deve ser igual a $Z_i$. Observe que o GCD de uma sequência de inteiros é o maior inteiro $d$, de modo que todos os números na sequência são divisíveis por $d$.
Encontre *qualquer* sequência válida $A$ consistente com todos esses requisitos ou determine que essa sequência não existe.
#### Entrada
A primeira linha contém dois inteiros separados por espaço, $N$ e $M$.
Cada uma das próximas $M$ linhas contém três inteiros separados por espaço, $X_i, Y_i \ e \ Z_i \ (1 \ \leq \ i \ \leq \ M)$.
#### Resultado
Se essa sequência não existir, imprima a string Impossível em uma linha. Caso contrário, em uma linha, produza $N$ inteiros separados por espaço, formando a sequência $A_1, \ ... , \ A$. Se houver várias sequências válidas possíveis, qualquer sequência válida será aceita.
#### Restrições
* $1 \leq N \leq 150 000$
* $1 \leq M \leq 150 000$
* $1 \leq Z_i \leq 16$ para cada $i$
|
2,856 | 1686 | Ingredientes Típicos | Médio | Estruturas | A região Norte do Brasil é berço de uma culinária muito rica e criativa. Com ingredientes típicos, temperos únicos, combinações e modos de preparo peculiares, os pratos da região sempre encantam os moradores e turistas.
Nesta culinária são usados dois tipos de ingrediente: ingredientes típicos do Norte, e ingredientes comuns ao resto do país. Uma porção é uma mistura de ingredientes (típicos e/ou comuns) e/ou outras porções, e só é considerada típica se mais da metade de seus componenetes forem típicos.
Rafael está visitando o Norte pela primeira vez, e após algumas refeições ficou muito satisfeito com a gastronomia do local. Ele percebeu que quanto mais componentes típicos a sua porção tivesse, mais ele era surpreendido pelo gosto.
Após fazer algumas anotações Rafael pediu sua ajuda: Dada a lista de ingredientes típicos, e em seguida a descrição de várias porções, diga quais destas porções são típicas.
#### Entrada
A entrada inicia com um inteiro $N$, indicando quantos são os ingredientes típicos da região $(1 \leq N \leq 50)$. Em seguida haverá $N$ nomes, representando os $N$ ingredientes típicos da região.
Em seguida haverá um inteiro $M$, indicando quantas porções deverão ser analisadas $(1 \leq M \leq 100)$.
Em seguida haverá $M$ conjuntos de entrada, cada um representando uma porção.
Cada um destes conjuntos iniciará com um nome $S_i$ e um número $K_i$, representando o nome da porção e a quantidade de componentes (típicos, comuns ou porções) que compõem esta porção $(1 \leq K_i \leq 50)$.
Em seguida haverá $K_i$ nomes, cada um representando um dos componentes desta porção $S_i$.
Os nomes de todos os ingredientes e porções contém apenas letras do alfabeto (maiúsculas ou minúsculas) e hífen, e terão no máximo 50 caracteres.
#### Saída
Para cada porção imprima uma linha contendo a frase "porcao tipica" caso a porção seja típica, ou "porcao comum" caso a porção não seja típica. |
2,857 | 2345 | Retalhos | Médio | Estruturas | A avó de Adam está prestes a fazer aniversário e ele quer presenteá-la com um lindo quilt feito de retalhos. Ele criou uma coleção de desenhos de retalhos que irá costurar no quilt. No entanto, ele está com dificuldades para decidir exatamente onde colocar seus retalhos. Seu procedimento atual é costurar todos os retalhos em uma determinada configuração, verificar se gosta do resultado e cortá-los todos se não estiver satisfeito. Isso é altamente ineficiente e Adam está ficando sem tempo.
Adam começa com um pano branco retangular que será usado como base para o quilt e possui uma coleção de tipos possíveis de retalhos. Cada tipo de retalho é uma peça retangular de pano com um design específico. Felizmente, Adam está bem preparado e tem uma quantidade ilimitada de cada tipo de retalho. Adam pediu que você escreva um programa para determinar como o pano ficará após costurar os retalhos em uma ordem específica e em locais específicos. Note que Adam corta o excesso de tecido que fica para fora da borda da base do quilt, portanto, seu programa também deve fazer o mesmo.
Ajude Adam escrevendo um programa para exibir o quilt completo.
#### Entrada
A primeira linha de entrada consiste em dois inteiros $R, C$ ($1 \leq R, C \leq 100$) dando as dimensões do quilt. Inicialmente, este quilt é branco e é representado por uma grade com $R$ linhas e $C$ colunas, onde cada entrada é o caractere '.' (um ponto) representando branco.
A segunda linha contém um único inteiro $N$ ($1 \leq N \leq 100$), que é o número de tipos diferentes de retalhos. A seguir, descreve-se os retalhos:
* A primeira linha da descrição do $i$-ésimo tipo de retalho consiste em dois inteiros $r_ i, c_ i$ ($1 \leq r_ i, c_ i \leq 100$) dando o número de linhas $r_ i$ e colunas $c_ i$ deste retalho.
* Em seguida, seguem $r_ i$ linhas, cada uma contendo $c_ i$ caracteres ASCII que não são espaços em branco, descrevendo o $i$-ésimo tipo de retalho.
A próxima linha contém um único inteiro $M$ ($1 \leq M \leq 100$), que é o número de retalhos que Adam deseja costurar no quilt.
As próximas $M$ linhas de entrada descrevem a colocação e os tipos desses retalhos. A $j$-ésima linha contém três inteiros $q_ j$ ($0 \leq q_ j < R$), $t_ j$ ($0 \leq t_ j < C$) e $p_ j$ ($1 \leq p_ j \leq N$). Isso significa que o $p_ j$-ésimo retalho é costurado no quilt com seu canto superior esquerdo na posição $q_ j, t_ j$ da linha/coluna do quilt. Esta lista é fornecida na ordem em que são costurados no quilt.
#### Saída
Imprima o quilt completo. Ou seja, imprima $R$ linhas e $C$ colunas de caracteres ASCII, onde cada posição é o padrão do quilt após costurar os retalhos fornecidos, removendo o excesso de tecido. |
2,858 | 1577 | Alocador de Trabalhos | Difícil | Estruturas | A Infraestrutura Consorciada para Pública Computação (ICPC) é uma rede de computadores administrada por voluntários de todo o mundo que compartilham recursos computacionais uns com os outros. Os colaboradores são capazes de conectar e desconectar suas máquinas da rede, e também de executar trabalhos de computação nas máquinas da rede. Com a ICPC, projetos importantes que de outra forma teriam custos de infraestrutura proibitivos (como executar juízes on-line para competições de programação) tornam-se empreendimentos viáveis.
Por melhor que pareça no papel, por enquanto, o ICPC é apenas um sonho. Para que funcione, falta uma peça chave de software: o alocador de tarefas. É aqui que você entra: a comunidade conta com você para fazer esta importante (mas voluntária, é claro) contribuição.
A rede é extremamente dinâmica: as máquinas se conectam e se desconectam o tempo todo. O alocador de tarefas precisa acompanhar as máquinas que estão atualmente conectadas e quais recursos eles compartilham. Há vários tipos de recursos, como núcleos de CPU, GPUs e discos SSD. Uma máquina pode compartilhar um ou mais recursos, possivelmente mais de um do mesmo tipo. Além disso, em qualquer momento, os usuários podem solicitar máquinas para executar trabalhos de computação. Para isso, eles especificam uma lista de recursos que uma máquina precisa para executar seu trabalho, e o alocador de trabalhos tem que determinar quantas das máquinas atualmente conectadas possuem todos os recursos necessários para executar o trabalho. Por exemplo, para um trabalho que precisa de um núcleo de CPU e duas GPUs, o alocador precisaria contar quantas máquinas têm pelo menos um núcleo de CPU e duas ou mais GPUs.
Sua tarefa é simplesmente contar quantas máquinas conectadas satisfazem as necessidades de recursos de cada trabalho, uma vez que outro voluntário assumiu a tarefa de implementar a real atribuição de trabalhos às máquinas. Toda a comunidade da ICPC depende de você. Você é capaz de ajudar?
#### Entrada
A primeira linha contém dois inteiros $N (1 ≤ N ≤ 10^5)$ e $K (1 ≤ K ≤ 8)$, indicando respectivamente o número de eventos de rede que devem ser processados e o número de tipos de recursos que estão disponíveis no ICPC. Os eventos são descritos em ordem cronológica nas próximas linhas N, um evento por linha. Há três tipos de eventos.
Se o evento representar que uma nova máquina está sendo conectada à rede, a linha contém a letra maiúscula "C", seguida por um número inteiro $R (1 ≤ R ≤ 8)$ indicando o número de recursos que a máquina está compartilhando, seguido por $R$ inteiros $T_1, T_2, . . , T_R (1 ≤ T_i ≤ K$ para $i = 1, 2, . . . , R)$, descrevendo o tipo de cada um dos recursos compartilhados. As novas máquinas são implicitamente designadas pelo ICPC a identificadores inteiros sequenciais únicos, começando em $1$.
Quando o evento representa que uma máquina está sendo desconectada da rede, a linha contém a letra maiúscula "D", seguida por um número inteiro indicando o identificador da máquina. É garantido que este identificador corresponde a uma máquina conectada válida.
Finalmente, se o evento representar que um usuário deseja executar um trabalho, a linha contém a letra maiúscula "J", seguida por um número inteiro $R (1 ≤ R ≤ 8)$ indicando o número de recursos que o trabalho necessita, seguido por $R$ inteiros $T_1, T_2, . . , T_R (1 ≤ T_i ≤ K$ para $i = 1, 2, . . . , R)$, descrevendo o tipo de cada um dos recursos necessários. É garantido que a entrada contém pelo menos um evento deste tipo.
#### Saída
Produzir uma linha para cada evento do tipo "J". A linha deve conter um número inteiro indicando o número de máquinas que no momento do evento estão conectadas à rede e fornecer todos os recursos solicitados. Escrever os resultados em ordem cronológica, ou seja, usando a mesma ordem que a entrada.
|
2,859 | 2343 | Número Coliseu | Difícil | Estruturas | Bem-vindo ao Coliseu dos Números, onde duas equipes de inteiros estão se preparando para a batalha! No lado esquerdo da reta numérica, temos a equipe dos Negativos, enquanto no lado direito temos a equipe dos Positivos. Cada inteiro lutando no coliseu pertence a uma dessas duas equipes.
No início da batalha, os competidores se alinham do lado de fora do coliseu. Um por um, eles entram no coliseu e seguem as seguintes regras:
* Se não houver competidores da equipe adversária, o competidor aguardará e se tornará o competidor mais recente a entrar no coliseu.
* Se houver pelo menos um competidor da equipe adversária no coliseu, o competidor atual lutará contra o competidor da equipe adversária que entrou mais recentemente no coliseu. O vencedor de uma luta entre um inteiro negativo e um inteiro positivo é aquele com o maior valor absoluto. Após uma luta, o valor do vencedor se torna a soma dos dois inteiros lutadores, enquanto o perdedor sai. Observe que se os dois inteiros têm o mesmo valor absoluto, ambos perdem e saem. Se houver um vencedor, eles continuarão lutando enquanto houver mais competidores adversários. Caso contrário, eles esperarão.
Depois que todos os inteiros entrarem no coliseu, apenas uma equipe poderá ser declarada a vencedora do Coliseu dos Números! Dada a lista de competidores para a próxima batalha, escreva um programa para determinar qual equipe triunfará, bem como o estado do coliseu após todas as lutas terem ocorrido.
Entrada
A primeira linha contém um único inteiro $N$ ($1 \leq N \leq 5 \cdot 10^5$), que é o número de competidores que entrarão no coliseu. A segunda linha contém a lista de competidores. Ela conterá $N$ inteiros separados por espaço $x_1, x_2, \ldots , x_ N$ ($1 \leq |x_ i| \leq 10^6$ para cada $1 \leq i \leq N$), o valor do $i$-ésimo competidor que entra no coliseu.
Saída
Exiba a equipe vencedora com Positivos venceram! ou Negativos venceram!. Na linha seguinte, mostre a lista de inteiros que restaram no coliseu após todas as lutas terem terminado. Exiba esses inteiros na ordem de entrada no coliseu.
Se nenhuma equipe vencer, exiba Empate! (Tie!) em vez disso.
Explicação Exemplo Entrada/Saída 1:
Na Exemplo de Entrada $1$, $N = 4$ e os competidores estão alinhados na seguinte ordem $[-3, -4, 9, 1]$.
* Primeiro, o competidor $-3$ entra no coliseu, que agora contém $(-3)$.
* Em seguida, o competidor $-4$ entra no coliseu, que agora contém $(-3, -4)$.
* Então, $9$ entra e luta contra $-4$. O competidor $9$ vence e se torna $5$, enquanto o competidor $-4$ perde e sai. Em seguida, $5$ luta contra $-3$, vence e se torna $2$, enquanto $-3$ perde e sai. O coliseu agora contém $(2)$.
* Por fim, $1$ entra no coliseu. O estado final do coliseu é $(2, 1)$ e os Positivos vencem! |
2,860 | 1497 | Torneio de Xadrez do Cafebazaar | Muito Difícil | Estruturas | Ali hospeda um torneio anual de xadrez para o festival Shab-e Yalda do CafeBazaar. Em um torneio de xadrez, cada par de participantes joga um jogo um contra o outro exatamente uma vez. Além disso, os jogadores recebem um ponto por vitória, meio ponto por empate e nenhum ponto por derrota em seu resultado no torneio.
Danial construiu um sistema para prever o resultado do torneio de Ali. Com base na experiência, ele atribuiu uma habilidade de abertura e uma habilidade de finalização para cada um dos $N$ participantes do torneio. Para o i-ésimo participante, denotemos a abertura com $o_i$ e a finalização com $e_i$. Em um jogo entre o i-ésimo e o j-ésimo participantes, o Danial decide o resultado do jogo de acordo com as seguintes regras:
* 1. Se $o_i > o_j$ e $e_i > e_j$, então o i-ésimo participante ganha o jogo.
* 2. Se $o_j > o_i$ e $e_j > e_i$, então o j-ésimo participante ganha o jogo.
* 3. Caso contrário, o jogo termina empatado.
Para tornar o torneio mais emocionante, Ali quer convidar Danial para se juntar aos outros $N$ participantes do torneio. Como Danial não tem experiência anterior com xadrez, decide treinar para o torneio. Com base na quantidade de treinamento, Danial pode acabar com qualquer habilidade de abertura e finalização. No entanto, Danial prometeu a Ali que treinará de forma que sua habilidade inicial seja **diferente** da habilidade inicial dos outros participantes. Ele também manterá sua habilidade final **diferente** da habilidade final dos outros participantes.
Para sua campanha publicitária, Ali quer saber o número de pontuações finais distintas que Danial pode obter com base nas regras de Danial mencionadas acima. Por exemplo, Danial pode atingir as pontuações 0, 1.5, 2.5, 3, 4 e 5 na amostra. Por exemplo, a pontuação 3 é obtida definindo as habilidades de abertura e finalização do Danial como 1.5. Já que Ali e todos os outros programadores do CafeBazaar estão ocupados planejando o evento, ele pediu ajuda a você. Escreva um programa para calcular este valor.
#### Entrada
A primeira linha da entrada contém um único inteiro $N \ (1 \leq n \leq 200.000)$, o número de participantes. A i-ésima linha das próximas $N$ linhas contém dois inteiros $o_i$ e $e_i \ (1 \leq o_i, e_i \leq N)$, as habilidades de abertura e finalização do i-ésimo participante, respectivamente. Observe que os limites para as habilidades de abertura e finalização não se aplicam às habilidades de abertura e finalização de Danial. Mais especificamente, as habilidades de abertura e finalização de Danial podem ser quaisquer números reais.
#### Saída
Na única linha da saída, imprima o número de pontuações finais distintas possíveis para Danial. |
2,861 | 2054 | Estrutura de Dados | Difícil | Estruturas | É um fato bem conhecido que, dentro dos computadores, todos os dados são armazenados em pirâmides 2D de blocos de dados.
Uma certa pirâmide tem $N (1 \leq N \leq 10^9)$ linhas, numeradas de cima para baixo. Cada linha $r$ tem $r$ blocos de espaços, que são etiquetados ($r$, 1)...($r$, $r$) da esquerda para a direita. Cada bloco de espaço ($r$, $c$) nas fileiras 1...($N - 1$) fica em cima de dois blocos de espaço de apoio na fileira abaixo - bloco de espaços ($r + 1$, $c$) e ($r + 1$, $c + 1$). Por exemplo, uma pirâmide com 6 fileiras é ilustrada abaixo, com blocos de espaço (3, 1), (4, 4), e (6, 2) indicados em vermelho:
Agora, cada bloco de espaço pode conter dados, ou estar vazio. Um bloco de espaço contendo dados só é estável se estiver na linha inferior (linha $N$), ou se ambos os dois espaços de blocos de apoio também contiverem dados. A pirâmide inteira só é estável se todos os seus blocos de espaço não vazios forem estáveis.
Você sabe que há $M (1 \leq M \leq 10^5)$ diferentes blocos de espaços que devem conter dados - o i-ésimo destes é o bloco de espaço $(r_i, c_i) (1 \leq c_i \leq r_i \leq N)$. Todos os outros blocos de espaço na pirâmide podem ser preenchidos com dados arbitrários ou ser deixados vazios. Entretanto, todos sabem que os dados são caros. Como tal, você está interessado na menor quantidade de dados que os blocos de espaço da pirâmide podem conter, de modo que pelo menos os $M$ blocos de espaço necessários contenham dados, e toda a estrutura de dados seja estável.
#### Entrada
A primeira linha da entrada contém dois números inteiros, $N$ e $M$. As $M$ linhas restantes contêm dois inteiros cada, $r_i$ e $c_i$ para $i = 1...M$.
#### Saída
Imprima um único número inteiro, o número mínimo de blocos de espaço que podem conter dados de tal forma que a pirâmide inteira seja estável. Observe que este valor pode não caber em um inteiro 32 bits.
##### Explicação do Exemplo de Entrada/Saída 1:
O diagrama abaixo ilustra a pirâmide descrita pelo exemplo de entrada, onde os 3 blocos de espaço vermelhos devem conter dados, enquanto os 12 blocos de espaço laranja representam o conjunto ideal de blocos a serem preenchidos adicionalmente com dados para que toda a pirâmide seja estável.
 |
2,862 | 1952 | A pergunta que não quer calar | Difícil | Estruturas | Luiz Cláudio percebeu o quanto Reluew e Ovatsug gostam de desafios, cada hora propondo problemas mais difíceis e mais interessantes. Por isso ele resolveu dar um desafio aos dois que até o momento nenhum deles conseguiu resolver. Advinha para quem eles estão pedindo ajuda? Pra você, é claro, e o desafio é o seguinte:
Luiz Cláudio quer construir um array de $N$ números inteiros que respeite $M$ restrições. Essas restrições são da seguinte forma:
A operação bitwise and dos números contidos no intervalo que vai de $L$ a $R$ deve ser igual a $Q$. A operação “bitwise and” é aquela que executa um and bit a bit de dois números. **Tanto em C/C++, Python e Java, essa operação é realizada pelo operador ‘&’.**
Mas a pergunta que não quer calar é: dada as $M$ restrições de Luiz Cláudio, é possível construir um array que respeite todas elas?
#### Entrada
A entrada possui apenas um caso de teste. A primeira linha contém dois inteiros $N$ e $M(1 ≤ N, M ≤ 10^5)$.
Seguem $M$ linhas, cada uma contendo três inteiros: $L$, $R$ e $Q (1 ≤ L ≤ R ≤ N)$ e $(1 ≤ Q ≤ 2^{30})$, representando o início e fim do intervalo, e o valor que a operação bitwise and dos números do intervalo deve retornar, respectivamente.
#### Saída
A saída deve ser “SIM” (sem aspas) se for possível construir um array que respeite as restrições de Luiz Cláudio e “NAO” (sem aspas) caso contrário.
**Explicação dos casos de teste:**
**No primeiro caso**, poderia se pensar no seguinte _array_: {3, 7, 7}, pois 3 & 7 & 7 = 3. Portanto, é possível construir um _array_ que respeite a condição dada.
**No segundo caso**, poderia se pensar no seguinte _array_: {3, 7, 5, 5}, pois 3 & 7 = 3 (respeitando a primeira restrição) e 7 & 5 & 5 = 5 (respeitando a segunda restrição).
**No terceiro caso**, não há solução, pois é impossível que um mesmo intervalo retorne resultados diferentes.
|
2,863 | 1905 | Ficção Científica | Difícil | Estruturas | As artes e a literatura sempre foram influenciadas pela ciência. Isto aparece, por exemplo, nos filmes de Christopher Nolan. Mas, há um cientista que está fazendo sua pesquisa sobre uma hipótese baseada em romances fictícios.
O Dr. Khosro, um físico teórico, faz pesquisas sobre mundos paralelos com dimensões elevadas, inspirado nos romances de Isaac Asimov. Durante sua pesquisa, ele precisa de um método de ordenação em sua rede imaginária de planetas de alta dimensão. No mundo imaginário n-dimensional do Dr. Khosro, há $2^n$ planetas e uma rede de wormhole conectando-os. A rede é como um hipercubo n-dimensional. Os planetas são numerados com inteiros não negativos inferiores a $2^n$, e há um buraco de minhoca do planeta $a$ para o planeta $b$ se e somente se as representações binárias n-bit de $a$ e $b$ diferirem em exatamente uma posição bit-position. No modelo do Dr. Khosro, há um número escrito em cada planeta e só podemos trocar os números de dois planetas se houver um buraco de minhoca direto entre eles. Você recebe os números escritos em cada planeta, constrói uma sequência válida de trocas que faz com que a sequência de números seja classificada do menor para o maior. Formalmente, se o número escrito no planeta número $i \ (0 \leq \ i < 2^n)$ for denotado por $a_i$, você tem que construir uma sequência de swaps válidos em pares que faça a sequência $a = ⟨a_0, a_1, \ ... \ a_{2^n-1}⟩$ em ordem crescente.
#### Entrada
A primeira linha de entrada consiste em $n \ (1 \ \leq \ n \ \leq \ 10)$, a dimensão do mundo imaginário do Dr. Khosro. A linha seguinte contém $2^n$ inteiros distintos, indicando $a_0, \ a_1, \ ... \ , a_{2^n-1} \ (0 \ \leq \ a_i \ \leq \ 10^6)$.
#### Saída
Imprima os números de seus swaps na primeira linha. Sua resposta será considerada correta se este número for não-negativo e inferior a 12 000. Em seguida, nas linhas seguintes, imprima a sequência dos swaps. Em sua solução, cada troca deve ser feita entre dois planetas com um wormhole direto entre eles. |
2,864 | 1912 | Vacinação Contra o Corona | Difícil | Estruturas | Sempre que um bebê nasce na Terra do Nunca, um lugar na estrada principal da Terra do Nunca é designado a ela/ele. Em todas as atividades tradicionais, como os exercícios matinais, os cidadãos da Terra do Nunca são designados em seu próprio lugar na estrada principal. Infelizmente, durante a pandemia de Corona, todas as atividades tradicionais ao ar livre da Terra do Nunca são canceladas. Após a aprovação da vacina corona, o conselho da Terra do Nunca decidiu reabrir as atividades, mas é claro, com um regulamento de segurança da covid. O conselho da Terra do Nunca assumiu que uma pessoa vacinada está segura tanto para ser infectada quanto para a transmissão da infecção. Por outro lado, para as pessoas não vacinadas, existe uma distância segura para o corona, que mantendo esta distância entre cada duas pessoas as mantém seguras. Assim, uma situação segura é uma situação em que cada duas pessoas não vacinadas mantém a distância física segura do corona. Conhecendo os lugares atribuídos aos cidadãos que participam de atividades tradicionais, o conselho da Terra do Nunca decidiu vacinar um número mínimo de cidadãos para tornar sua atividade segura.
#### Entrada
A entrada consiste em duas linhas. A primeira linha contém dois números inteiros separados por um espaço de $n \ (1 \ \leq \ n \ \leq \ 10^5)$, o número de cidadãos da Terra do Nunca que participam das atividades, e a distância segura do Corona $L \ (1 \ \leq \ L \ \leq \ 10^5)$, ou seja, duas pessoas não receberão o vírus uma da outra se sua distância for de pelo menos $L$. A linha seguinte consiste em $n$ números inteiros na faixa de $[-10^5, 10^5]$, onde o i-ésimo número representa a localização do i-ésimo cidadão participante. A localização é calculada como a distância em metros desde o início da estrada principal da Terra do Nunca.
#### Saída
Imprimia o número mínimo de cidadãos que devem ser vacinados para poderem ter as atividades de forma segura na Terra do Nunca. |
2,865 | 1572 | Excelentes Vistas | Muito Difícil | Estruturas | Shiny City é uma bela cidade, famosa por três coisas: o fato de ter apenas uma rua, o fato de todos os edifícios terem alturas diferentes, e as vistas de tirar o fôlego do topo dos referidos edifícios.
Desde que a pandemia começou, a quantidade de turistas que visitam Shiny City diminuiu significativamente. Você está determinado a escrever um blog incrível para atrair mais turistas e impedir a condenação financeira de sua adorável, mas terrivelmente ineficiente cidade. Infelizmente, ainda faltam algumas informações no blog.
Na Shiny City há $N$ edifícios, e o $i$-ésimo edifício é identificado por sua posição $i$. Ir do edifício $i$ para o edifício $j$ leva $|i - j|$ minutos. Cada edifício tem uma altura diferente $H_i$, e quanto mais alto o edifício, melhor a vista de seu topo.
Se você estiver em um determinado edifício, pode valer a pena ir para um edifício diferente que tenha uma vista melhor. Devido aos custos de transporte, nunca vale a pena ir a um edifício se houver um mais alto que você possa alcançar sem usar mais tempo.
Formalmente, podemos dizer que ir de um edifício $i$ para outro edifício $j$ vale a pena se não houver $k$ tal que $|i - k| ≤ |i - j|$ e $H_j < H_k$. Note que $k$ pode ser igual a $i$.
Você quer escrever em seu blog, para cada edifício, para quantos outros edifícios vale a pena ir a partir dele. Por favor, recolha estas informações, caso contrário a Shiny City estará condenada para sempre.
#### Entrada
A primeira linha contém um número inteiro $N (1 ≤ N ≤ 10^5)$, o número de edifícios na Shiny City. A segunda linha contém $N$ inteiros diferentes $H_1, H_2, . . H_N (1 ≤ H_i ≤ 10^9$ para $i = 1, 2, . . . . , N$), onde $H_i$ é a altura do edifício $i$.
#### Saída
Produza uma única linha com $N$ inteiros, de tal forma que o $i$-ésimo deles represente o número de edifícios para os quais vale a pena ir da construção $i$.
|
2,866 | 411 | Hipótese Policial | Muito Difícil | Estruturas | O sistema de transporte público da Nlogônia conta com uma rede expressa conectando os principais pontos turísticos do país. São usados $N-1$ trens-bala para conectar $N$ atrações de modo que a partir de um dos pontos turísticos é possível alcançar qualquer outro ponto usando apenas essa rede expressa. Como em qualquer lugar do mundo, é comum que haja pichações nas estações de trem. O que chamou a atenção da polícia do país é o fato de que em cada uma das estações é possível encontrar exatamente uma letra pichada com um estilo específico. A hipótese é de que criminosos podem estar alterando as pichações como meio de comunicação e portanto decidiu-se criar um sistema capaz de monitorar as pichações e suas alterações. Dado um padrão $P$, a descrição das conexões entre as estações e as letras suspeitas em cada uma das estações, sua tarefa é escrever um programa capaz de lidar com as seguintes operações:
* 1 $u$ $v$: imprime quantas ocorrências do padrão $P$ existem no caminho de $u$ até $v$ se olharmos para os caracteres associados a vértices consecutivos do caminho;
* 2 $u$ $x$: Altera a letra suspeita na estação $u$ para $x$;
#### Entrada
A primeira linha contém dois inteiros $N$ e $Q$ ($1 \leq N$, $Q \leq 10^5$), representando o número de estações e a quantidade de operações que devem ser processadas. A segunda linha contém o padrão $P$ monitorado ($1 \leq |P| \leq 100$). A terceira linha contém uma string $S$ com $N$ caracteres representando as letras inicialmente associadas a cada uma das estações.
Cada uma das $N - 1$ linhas seguintes contém dois inteiros $u$ e $v$ indicando que existe um trem-bala entre as estações $u$ e $v$. As $Q$ linhas seguintes descrevem as operações que devem ser processadas conforme descrito acima.
#### Saída
Seu programa deve imprimir uma linha para cada operação do tipo 1 contendo um inteiro que representa o número de ocorrências do padrão $P$ no caminho analisado.
|
2,867 | 1569 | Belas Montanhas | Muito Difícil | Estruturas | Um subvetor de um vetor é uma porção contígua do vetor. Uma divisão de um vetor em subvetores é uma coleção de subvetores que cobrem todo o vetor sem sobreposições (cada elemento do vetor pertence a exatamente um subvetor). Por exemplo, se $A = [3, 1, 4, 1, 5]$ é um vetor, $[3, 1, 4]$ e $[1, 5]$ formam uma partição de $A$ em subvetores, enquanto $[3, 4, 5]$ não é um subvetor de $A$.
Estas são definições padrão que você pode ter lido em outros locais. Então, o que há de novo aqui? Bem, seguem mais algumas definições.
Dado um vetor $A$ de inteiros, um subvetor $[A_i, A_i+1, . . . , A_j ]$ de $A$ é chamado uma montanha se existir um índice $k$ tal que $i < k < j$, o subvetor de $A_i$ a $A_k$ é não-decrescente, e o subvetor de $A_k$ a $A_j$ é não-crescente. Em palavras simples, os valores no subvetor "sobem" até ao índice $k$ e depois "descem", assemelhando-se a uma montanha. Note que um subvetor com menos de três elementos não pode ser uma montanha.
Um conjunto de inteiros é chamado uma bela cadeia de montanhas se puder ser dividida em montanhas, tendo cada uma delas o mesmo número de elementos, salvo a última montanha que pode ter menos elementos.
Como exemplo, $[5, 10, 4, 1, 3, 2]$ é uma bela cadeia de montanhas porque pode ser dividida em $[5, 10, 4]$ e $[1, 3, 2]$, tendo ambas as montanhas o mesmo número de elementos. Outro exemplo é o vetor $[5, 10, 4, 4, 4, 10, 20, 30, 20, 2, 3, 1]$, que é também uma bela cadeia de montanhas porque pode ser dividida em $[5, 10, 4, 4]$, $[10, 20, 30, 20]$ e $[2, 3, 1]$.
Dado um vetor de inteiros positivos, onde alguns valores podem estar ausentes, determine se é possível completar o conjunto com inteiros positivos de modo a que se torne uma bela cadeia de montanhas.
#### Entrada
A primeira linha contém um número inteiro $N (3 ≤ N ≤ 10^5)$ indicando o número de elementos no vetor. A segunda linha contém $N$ números inteiros $A_1, A_2, . . A_N (Ai = -1$ ou $1 ≤ A_i ≤ 10^9$ para $ i = 1, 2, . . . . , N$), onde $A_i = -1$ indica que o $i$-ésimo elemento do vetor precisa ser determinado, e um valor positivo é o real $i$-ésimo elemento do vetor.
#### Saída
Produza uma única linha com a letra maiúscula "Y" se for possível completar o conjunto com inteiros positivos de tal forma que se torne uma bela cadeia de montanhas, e a letra maiúscula "N" caso contrário.
|
2,868 | 1910 | Rituais dos Pássaros | Difícil | Estruturas | As aves são animais estupendos. Muitas espécies delas realizam rituais diferentes ao longo de sua vida; desde danças de cortejo de pavões a moonwalking de manequins de capuchinho vermelho. Entre todos, estamos estudando a dança da permutação neste problema. Este ritual é realizado por um grupo de pássaros sentados em fila em um arame ou galho de árvore, como mostra a figura.
O ritual pode ser simplificado para uma performance baseada em uma sequência de ações destes tipos:
* inserção: Um novo pássaro se junta ao grupo e se insere em algum lugar na fila dos pássaros.
* partida: Um pássaro na fila deixa o grupo para o resto do ritual e voa para longe.
* realocação: Uma ave na fila voa de sua posição e se senta (se insere) em algum outro lugar da fila.
Dada a posição inicial das aves na fila e a sequência de ações, sua tarefa é calcular a posição final das aves no ritual.
#### Entrada
A entrada começa com uma linha contendo dois números inteiros separados por espaço $n \ (1 \ \leq \ n \ \leq \ 1000)$ e $s \ (1 \ \leq \ s \ \leq \ 5000)$. A segunda linha contém $n$ nomes de aves separadas por espaço, como a configuração inicial do ritual (posicionamento das aves na fila, da esquerda para a direita). Cada nome de ave é uma cadeia não vazia de no máximo 10 (minúsculas) caracteres alfanuméricos (de a a z, e de 0 a 9).
A sequência de ações é fornecida nas próximas $s$ linhas, uma ação por linha. Cada linha está em um dos seguintes formatos, com base no tipo de ação. O parâmetro do nome da ave nas ações tem o formato similar ao da segunda linha da entrada.
* inserção: inserir a posição do nome do pássaro
O parâmetro de posição é um número inteiro mostrando o número de aves à esquerda da posição de inserção. Este parâmetro está na faixa [0, $M$] onde $M$ é o número total de pássaros na fila antes da inserção. A posição 0 coloca a ave no início (posição mais à esquerda) da linha, e a posição $M$ coloca a ave no final (posição mais à direita).
* partida: partida nome do pássaro
* realocação: realocação de deslocamento de nome de pássaro
O parâmetro de deslocamento é um número inteiro que pode ser positivo, negativo ou zero. A ave voa para sua própria posição se o deslocamento for 0. Caso contrário, a ave voa sobre $k$ aves à sua direita (esquerda) se o deslocamento for positivo (negativo), onde $k$ é o valor absoluto do deslocamento. Este parâmetro está na faixa [$-L$, $+R$] onde $L$ e $R$ são respectivamente o número de aves à esquerda e à direita da ave em movimento na fila antes da recolocação. Deslocamento $-L$ coloca a ave no início (posição mais à esquerda) da fila, e deslocamento $+R$ coloca a ave no final (posição mais à direita).
Não há duas aves participantes com o mesmo nome. Além disso, é garantido que todas as ações são significativas no momento da execução e que há sempre pelo menos uma ave no galho durante todo o ritual.
#### Saída
Imprima uma única linha na saída contendo a configuração final do ritual. A linha deve conter a lista separada por espaço dos nomes dos pássaros na linha (da esquerda para a direita). |
2,869 | 1222 | Acabe com a Desigualdade | Muito Difícil | Estruturas | Complexidonia nem sempre foi a terra pacífica e igualitária que conhecemos hoje. Os prósperos Constantones eram os donos da mídia local e mergulharam Complexidonia na tirania de seu cruel sistema econômico: Nlogonialismo, um sistema que promovia extrema injustiça que, muito estranhamente, sempre beneficiava os Constantones.
Enquanto os Constantones possuíam a maior parte das riquezas, os Cuadradones viviam em extrema pobreza, e a desigualdade era justificada dizendo que os Cuadradones eram preguiçosos e ineficientes. Os Nlogones desprezavam os Cuadradones, mesmo trabalhando tanto quanto eles, acreditando que eles eram melhores por sua mistura de trabalho duro e astúcia. Para os Cubiones e Cuaterniones era ainda pior, vindos de países vizinhos, eles eram vistos como criminosos e, ao mesmo tempo, acusados de roubar trabalhos Complexidonianos.
Tudo mudou depois que o Internacional Congresso Popular Coletivista (ICPC) conseguiu derrubar os Constantones e colocar um novo sistema econômico no lugar, um sistema que preza pela justiça e leva em conta que cada habitante pode passar por períodos econômicos bons e ruins durante a vida.
No novo sistema foram estabelecidos um limite superior $U$ de quanta riqueza cada indivíduo pode acumular e um limite inferior $L$ representando a mínima riqueza requerida para um indivíduo manter um estilo de vida decente. No fim de cada mês cada habitante irá avaliar sua riqueza. Aqueles com mais de $U$ doarão o que possuem acima do limite superior para o ICPC enquanto os que infelizmente possuem menos que $L$ receberão o suficiente do ICPC para alcançar o limite inferior estabelecido.
Os Cuadradones, que são ótimos fazendeiros, precisam da sua ajuda para gerenciar suas finanças. A longa era do Nlogonialismo prejudicou seriamente o meio-ambiente e agora o clima em Complexidonia é muito volátil. Isso tem grande impacto na agricultura que flutua entre períodos bons e ruins.
Um fazendeiro mantém um longo registro $A_1, A_2, ... , A_N$ de sua receita líquida (renda deduzidas as despesas) em uma sequência de $N$ meses. Baseado nesses dados os fazendeiros querem planejar como investir suas riquezas de forma a evitar serem um peso para o ICPC no futuro. O fazendeiro quer saber, dada uma riqueza inicial $X$ no começo do mês $B$, quanto ele teria no fim de um mês $E$ (considerando que no fim de cada mês ele pode ou doar ou receber uma doação para que sua riqueza esteja entre $L$ e $U$, inclusive).
#### Entrada
A primeira linha contém três inteiros $N (1 \leq N \leq 10^5)$, $L$ and $U$ $(1 \leq L \leq U \leq 2 \times 10^6)$, indicando respectivamente o número de meses para os quais o fazendeiro tem registros de renda líquida, o limite inferior de riqueza e o limite superior de riqueza. A segunda linha contém $N$ inteiros $A_1, A_2, ... , A_N$ $(-10^6 \leq A_i \leq 10^6$ para $i = 1, 2, ... , N)$, onde $A_i$ é a renda mínima do $i$-ésimo mês. A terceira linha contém um inteiro $Q (1 \leq Q \leq 10^5)$ representando o número de cenários em que o fazendeiro está interessado. Cada uma das próximas $Q$ linhas descreve um cenário com três inteiros $B$, $E (1 \leq B \leq E \leq N)$ e $X (L \leq X \leq U)$, indicando que o fazendeiro gostaria de saber quanto ele teria no fim do mês $E$ se ele começasse tendo $X$ no começo do mês $B$, sendo que a cada mês $j = B, B + 1, ... , E$ sua renda líquida é $A_j$.
#### Saída
Imprima $Q$ linhas, cada uma contendo inteiro indicando quanto o fazendeiro teria no fim do período descrito no cenário correspondente.
No primeiro cenário a renda líquida do fazendeiro seria [10, 1, -1, -70] e começa com uma riqueza de 31:
* No fim do primeiro mês sua riqueza é 41. Como $1 \leq 41 \leq 41$ ele não doará nem receberá dinheiro.
* No fim do segundo mês sua riqueza é 42. Como $42 > 41$ ele doa 1, terminando o mês com uma riqueza de 41.
* No fim do terceiro mês sua riqueza é 40. Como $1 \leq 40 \leq 41$ novamente ele não doará nem receberá dinheiro.
* Finalmente, no fim do quarto mês sua riqueza é -30. Como $-30 < 1$ ele receberá uma doação do ICPC terminando o mês com uma riqueza de 1.
Portanto, nesse cenário, o fazendeiro termina possuindo uma riqueza de 1. |
2,870 | 1340 | Confederação | Médio | Estruturas |
A Confederação Galática resolveu fazer uma reforma administrativa, para melhor distribuir os recursos de sua frota. Para isso, ela dividiu todo o espaço em regiões. Para definir as regiões, inicialmente um conjunto de planos infinitos foi especificado, e as regiões foram definidas pelos cortes desses planos. Note que algumas regiões são ilimitadas, mas que também podem existir regiões limitadas. O conjunto de planos foi escolhido de tal maneira que nenhum dos planos intercepta a órbita de um planeta, e portanto cada planeta transita por apenas uma região durante sua órbita (ou seja, um planeta dentro de uma região nunca cruzará um plano para outra região).
Sua tarefa consiste em determinar, dadas as equações dos planos e as posições dos planetas, quantos planetas existem na região com o maior número de planetas (em outras palavras, qual o número máximo de planetas dentro de uma região).
#### Entrada
A primeira linha da entrada contém dois inteiros $M \ (1 \ \leq \ M \ \leq \ 500)$ e $N \ (1 \ \leq \ N \ \leq \ 10000)$, indicando respectivamente o número de planos e número de planetas. As $M$ linhas seguintes contêm cada uma quatro inteiros $A, \ B, \ C$ e $D \ (-10000 \ \leq \ A, B, C, D \ \leq \ 10000)$, os coeficientes e o termo livre da equação $Ax \ + \ By \ + \ Cz \ = \ D$ que define cada um dos planos. A seguir, cada uma das $N$ linhas seguintes contém três inteiros $X, \ Y$ e $Z \ (-10000 \ \leq \ X, Y, Z \ \leq \ 10000)$, indicando a posição $(X, Y, Z)$ de um planeta.
#### Saída
Seu programa deve produzir uma única linha contendo apenas um número inteiro, o número de planetas na região que contém o maior número de planetas.
|
2,871 | 1950 | Dividindo os grupos | Difícil | Estruturas | Ovatsug largou o seu emprego na editora e agora resolveu dar aula de programação num projeto bastante interessante chamado Uberhub Code Club.
Nesse projeto, crianças e adolescentes têm a chance de ter o primeiro contato com programação e chegar a um nível bastante satisfatório. O intuito do projeto é desenvolver a capacidade de raciocínio lógico-matemático dos alunos, ao mesmo tempo em que dá experiência com programação e com a área de tecnologia. Dessa forma, é possível que esses alunos se tornem, num futuro próximo, bons profissionais da área de TI (Tecnologia da Informação), caso se interessem de fato pela área.
Ao final do curso, será realizada uma minimaratona com os alunos. Geralmente, as maratonas são individuais ou em trios, mas Ovatsug está pensando em propor uma nova forma de composição dos times. Ao invés de formar times de três pessoas, ele quer dividir todos os alunos em três grupos.
Cada aluno possui uma pontuação, que está diretamente ligada ao nível de experiência que o aluno tem. Então, visando equilibrar os grupos, Ovatsug quer dividir os alunos de maneira que a soma das pontuações dos alunos de cada um dos três grupos seja a mesma.
Porém, antes de propor essa divisão, Ovatsug gostaria de saber se é possível fazê-la, porque caso não seja, ele não fará a proposta. O problema é que ele não está conseguindo decidir e pediu a sua ajuda.
#### Entrada
A entrada possui apenas um caso de teste. A primeira linha possui um inteiro $N (2 ≤ N ≤ 100)$ indicando a quantidade de alunos matriculados no Uberhub Code Club esse ano.
A segunda linha possui $N$ inteiros $A_i (1 ≤ A_i ≤ 60)$ indicando a pontuação do $i$-ésimo aluno.
#### Saída
A saída deverá ser “SIM” (sem aspas) se for possível dividir os alunos nos três grupos e “NAO” (sem aspas), caso contrário.
|
2,872 | 1765 | Soma de subconjuntos de subarray | Muito Difícil | Estruturas | Será dado a você um array com $N$ números positivos, que não são necessariamente distintos, e $Q$ consultas, para cada uma delas, você deve responder o seguinte:
Qual o menor valor que não pode ser formado com a soma de um subconjunto de um subarray formado com elementos que estão entre os índices $L$ e $R$ do array original?
Por exemplo, imagine o array $[1\ 4\ 6]$. Agora uma consulta com $L = 1$ e $R = 2$, portando a porção do array analisada é o subarray $[1\ 4]$. Os únicos subconjutos possíveis são: $[1]$, $[4]$, $[1\ 4]$, com valores iguais a $1$, $4$ e $5$, respectivamente. Portanto o menor valor que não pode ser formado é o $2$.
#### Entrada
A entrada é composta por um único caso de teste.
A primeira linha contém dois inteiros $N$ e $Q$ $(1 \leq N, Q \leq 10^5)$, representando a quantidade de elementos do array original e quantas consultas serão feitas, respectivamente.
Na próxima linha terá $N$ inteiros $X_i$ $(1 \leq X_i \leq 10^9)$, representando o valor elemento da $i$-ésima posição.
Nas próximas $Q$ linhas terão dois inteiros $L$ e $R$ $(1 \leq L \leq R \leq N)$, que são os limites do subarray analisado, conforme descrito no texto.
#### Saída
Para cada consulta imprima o valor do menor elemento que não pode ser formado.
|
2,873 | 57 | Toca do Saci | Médio | Grafos | Depois de muito procurar, Emília finalmente conseguiu encontrar a toca do Saci. A toca tem formato retangular, e é formada por um quadriculado de salas quadradas de mesmo tamanho, com $N$ salas em uma dimensão e $M$ salas na outra dimensão. A figura abaixo mostra um exemplo de mapa da toca, com cinco salas na dimensão horizontal e quatro salas na dimensão vertical. Há uma única entrada, pela sala marcada com o número 3 no mapa. As salas da toca são muito parecidas, para confundir quem tenta encontrar o Saci, e têm portas que comunicam-se apenas com salas vizinhas nas direções horizontal e vertical do mapa.
Emília entrou na toca seguindo o Saci com o objetivo de pegar o seu chapéu, e só vai devolvê-lo se o Saci prometer não fazer mais diabrites no Sítio. Muito esperta, ela foi deixando estrelinhas coloridas pelas salas que passou (marcadas com o número 1 no mapa), para saber o caminho de volta. Ela pegou o chapéu do Saci enquanto ele dormia, e começou o caminho de volta. Está muito escuro e ela precisa acender um fósforo em cada sala, para ver as estrelinhas que marcam o caminho. No meio do caminho, ela percebeu que seus fósforos estavam acabando e agora está com medo de não ter fósforos suficientes. Ela está na sala marcada com o número 2 no mapa. Você pode ajudá-la?
Dado o mapa da toca, como no exemplo acima, escreva um programa para saber por quantas salas Emília deve passar até encontrar a saída.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$. que indicam respectivamente os números de salas nas duas dimensões da toca. Cada uma das $N$ linhas seguintes contém $M$ números inteiros entre 0 e 3. O valor 0 indica uma sala sem estrelinhas; o valor 1 indica uma sala com estrelinhas deixadas por Emília; o valor 2 indica uma sala com estrelinhas que é a sala onde Emília está; finalmente, o valor 3 indica uma sala com estrelinhas que é a saída. Considere que, durante o trajeto da entrada até a sala marcada com o valor 2, Emília não passou mais do que uma vez por uma mesma sala, e não existe ambiguidade no caminho de volta (em outras palavras, a cada ponto do trajeto de volta, existe apenas uma sala marcada para Emília voltar).
#### Saída
Seu programa deve imprimir uma única linha, contendo o número de salas que Emília deve passar, seguindo as estrelinhas, até chegar à saída da toca.
#### Restrições
* $1\leq N\leq 1000$
* $1 \leq M \leq 1000$ |
2,874 | 309 | Gincana (OBI 2011) | Médio | Grafos |
Toda semana Juquinha tem aulas de ACM (Artes Cênicas e Musicais) no colégio em que estuda e, recentemente, sua professora anunciou que haverá uma gincana no final do semestre. No entanto, os times devem ser formados o mais breve possível para que os alunos possam ensaiar.
Cada time é constituído de um ou mais alunos, e cada aluno tem que pertencer a exatamente um time. Além disso, os times não podem ser formados de qualquer maneira: se um aluno é amigo de outro, esses alunos devem estar no mesmo time. A professora então pediu para que os alunos a informassem das relações de amizade na sala de aula.
Os alunos então se numeraram de 1 até $N$ e escreveram uma lista cujas linhas contém pares de números. Se dois alunos cujos números são $i$ e $j$ são amigos, haverá ao menos uma linha contendo $i$ e $j$ ou $j$ e $i$ na lista. Inversamente, se há uma linha contendo $i$ e $j$
na lista, então os alunos cujos números são $i$ e $j$ são amigos.
A professora então recolheu a lista e, na próxima aula, deverá decidir que times formar. Ela está pensando em formar o maior número possível
de times e gostaria de saber quantos times ela formaria. Ajude então a professora escrevendo um programa que, dada a lista de amizades, determina qual o maior número de
times que ela pode formar.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$ que representam, respectivamente, o número de alunos na turma e o número de linhas na lista. As próximas $M$ linhas contêm a lista de amizades. Cada linha contém dois inteiros $I$ e $J$ separados por exatamente um espaço.
#### Saída
Seu programa deve imprimir uma linha contendo o número máximo de times que podem ser formados pela professora.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq M \leq 5000$
* $1 \leq I, J \leq N$
|
2,875 | 289 | Tá Ligado? | Médio | Grafos | Daniel Lima acabou de ser eleito prefeito mais novo da história de Fortaleza, nas eleições de 2024. Com o aquecimento global, a cidade litorânea foi invadida pelo mar, e agora consiste de uma série de ilhas. Durante sua campanha, Daniel prometeu construir várias pontes entre as ilhas, e agora as está colocando em prática. Como ele não pode aparentar favorecer nenhuma ilha mais que as outras, nenhuma delas tem mais de $100$ pontes.
Como é um rapaz muito ocupado, o prefeito precisa de um sistema para checar se suas pontes já foram construídas. Para isso você deve escrever o programa usado tanto pelo secretário de infra-estrutura, que informa quando as pontes são construídas, e por Daniel, que pergunta acerca da existência de alguma ponte.
#### Entrada
Por comodidade, as ilhas são numeradas de $1$ a $N$, e o seu programa fará $M$ interações (com o prefeito ou com o secretário). A primeira linha da entrada contêm 2 inteiros: $N$ e $M$. As próximas $M$ linhas descreve, interações de alguém com o sistema. Na linha $i$ há exatamente três inteiros: $T_i$, $A_i$ e $B_i$ ($1\leq A_i,B_i \leq N$). $T_i$ define o tipo de interação (Daniel perguntando ou o secretário respondendo) e $A_i$ e $B_i$ são as cidades às quais a interação se refere. Se $T_i=0$, então Daniel está perguntando se existe alguma ponte entre $A_i$ e $B_i$ (a ordem de $A_i$ e $B_i$ não importa), e se $T_i=1$, então o secretário está informando ao sistema que foi construída uma ponte entre as duas cidades. Nenhuma ponte é informada mais que uma vez.
#### Saida
Seu programa deve gerar exatamente uma linha para cada pergunta do prefeito, na ordem em que foram feitas. Se as cidades por ele questionadas estiverem ligadas por uma ponte <b>no momento da pergunta</b>, o programa deve imprimir $1$, caso contrário, deve imprimir $0$
#### Subtask 1 (20 pontos)
* $1 \leq N,M \leq 100$
#### Subtask 2 (20 pontos)
* $1 \leq N \leq 10^3$
* $1 \leq M \leq 10^5$
#### Subtask 3 (20 pontos)
* $1 \leq N, M \leq 10^5$
* O prefeito só faz uma pergunta, depois que o secretário informa todas as ponte construídas
#### Subtask 4 (40 pontos)
* $1 \leq N, M \leq 10^5$
|
2,876 | 354 | Móbile | Médio | Grafos | Móbiles são objetos muito populares hoje em dia, sendo encontrados até em berços, para diversão de bebês, mas foram concebidos há muito tempo (em 1931) pelo então jovem artista americano Alexander Calder como esculturas em movimento. Um móbile é uma estrutura composta de peças unidas por fios.
O móbile é preso por um fio a uma argola pela qual ele é suspenso, permitindo que a estrutura movimente-se livremente. A argola é presa a uma única peça, chamada de peça-raiz do móbile. A peça-raiz pode ter zero ou mais sub-móbiles pendurados nela, cada sub-móbile sendo composto por uma peça-raiz na qual por sua vez podem estar pendurados zero ou mais sub-móbiles, e assim sucessivamente. Abaixo podemos ver dois exemplos de móbiles:
Victor é dono de uma fabrica de móbiles que emprega centenas de artesãos. Cada móbile produzido na fábrica é confeccionado por um artesão, que cria móbiles de acordo com o seu gosto pessoal, utilizando peças de formatos distintos. Entretanto, Victor tem notado que nem todos os seus artesãos possuem a mesma habilidade artística, de forma que às vezes o móbile produzido nem sempre é bem balanceado, segundo a sua concepção. Para Victor, um móbile é bem balanceado se, para cada peça, todos os sub-móbiles pendurados nela são compostos pelo mesmo número de peças. O número de peças de um sub-móbile é determinado contando-se o número de peças que o compõe, incluindo a sua peça-raiz. Note que cada peça do móbile, exceto a peça-raiz, é pendurada em exatamente uma outra peça.
Por exemplo, o móbile da figura (a) acima é um móbile bem balanceado: a peça-raiz possui um único sub-móbile, que por sua vez possui três sub-móbiles, todos com o mesmo número de peças (uma única). Já o móbile da figura (b) é um móbile mal balanceado: a peça-raiz possui dois sub-móbiles, um com o total de duas peças e outro com o total de uma peça.
Dada a descrição de um móbile, você deve escrever um programa para determinar se o móbile está bem balanceado ou não.
#### Entrada
A primeira linha da entrada contém um inteiro $N$ que indica o número de peças utilizadas no móbile. As peças são identificadas por inteiros de 1 a N . Cada uma das N linhas seguintes contém dois números inteiros I e J , indicando que a peça de número I está pendurada na peça de número J (a peça raiz está pendurada na argola, que é identificada pelo o número 0).
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo a palavra bem se o móbile estiver bem balanceado ou mal caso esteja mal balanceado. A palavra deve ser escrita com todas as letras em minúsculas.
#### Restrições
* $1 \leq N \leq 100000$ |
2,877 | 26 | Mapa (OBI 2017) | Médio | Grafos | Harry ganhou um mapa mágico no qual ele pode visualizar o trajeto realizado por seus amigos. Ele agora precisa de sua colaboração para, com a ajuda do mapa, determinar onde Hermione se encontra.
O mapa tem $L$ linhas e $C$ colunas de caracteres, que podem ser ‘.’ (ponto), a letra ‘o’ ( minúscula) ou a letra ‘H’ (maiúscula). A posição inicial de Hermione no mapa é indicada pela letra ‘o’, que aparece exatamente uma vez no mapa. A letra ‘H’ indica uma posição em que Hermione pode ter passado – o mapa é impreciso, e nem toda letra ‘H’ no mapa representa realmente uma posição pela qual Hermione passou. Mas todas as posições pelas quais Hermione passou são representadas pela letra ‘H’ no mapa.
A partir da posição inicial de Hermione, Harry sabe determinar a posição atual de sua amiga, apesar da imprecisão do mapa, porque eles combinaram que Hermione somente se moveria de forma que seu movimento apareceria no mapa como estritamente horizontal ou estritamente vertical (nunca diagonal). Além disso, Hermione combinou que não se moveria de forma a deixar que Harry tivesse dúvidas sobre seu caminho (por exemplo, Hermione não passa duas vezes pela mesma posição). Considere o mapa abaixo, com 6 linhas e 7 colunas:
A posição inicial de Hermione no mapa é $(5,3)$, e sua posição atual é $(4,6)$. As posições marcadas em negrito (‘<b>H</b>’) são erros no mapa.
Dado um mapa e a posição inicial de Herminone, você deve escrever um programa para determinar a posição atual de Herminone.
#### Entrada
A primeira linha contém dois números inteiros $L$ e $C$, indicando respectivamente o número de linhas e o número de colunas. Cada uma das seguintes $L$ linhas contém $C$ caracteres.
#### Saída
Seu programa deve produzir uma única linha na saída, contendo dois números inteiros: o número da linha e o número da coluna da posição atual de Hermione.
#### Restrições
* $2 \leq L \leq 100$
* $2 \leq C \leq 100$
* Apenas os caracteres ‘.’, ‘o’ e ‘H’ aparecem no mapa.
* A letra ‘o’ aparece exatamente uma vez no mapa.
* A letra ‘H’ aparece ao menos uma vez no mapa.
* O caminho de Hermione está totalmente contido no mapa.
* Na posição da letra ‘o’ no mapa, há apenas uma letra ‘H’ como vizinho imediato na vertical
ou horizontal.
* Na posição atual de Hermione no mapa, há apenas uma letra ‘H’ como vizinho imediato na
vertical ou horizontal.
* Em cada uma das posições intermediárias do caminho de Hermione, há exatamente duas letras
‘H’ como vizinhas imediatas na vertical ou horizontal.
#### Informações de Pontuação
* Em um conjunto de casos de teste somando 20 pontos, $N \leq 8$
|
2,878 | 297 | Caminho das Pontes | Difícil | Grafos | Pedrinho é um rapaz muito aventureiro, que nas férias viaja pelo mundo em busca de lugares afastados e com bonitas vistas.
Na sua viagem atual, Pedrinho está andando por uma escura floresta quando se depara com um perigoso desfiladeiro. Do outro lado do desfiladeiro ele sabe que existe um acampamento onde poderá descansar durante a noite para continuar suas aventuras no dia seguinte.
Para chegar até o acampamento, ele terá que utilizar pontes que estão suspensas sobre o desfiladeiro. As pontes foram construídas interligando altos pilares cravados no fundo do desfiladeiro.
O piso das pontes é feita de tábuas de tamanhos iguais. Mas as pontes são velhas, e algumas tábuas caíram. Felizmente, todas as tábuas que sobraram estão em perfeitas condições, ou seja, não existe o perigo de Pedrinho pisar em uma delas e a tábua cair. Além disso, em nenhuma das pontes duas tábuas consecutivas caíram, de forma que os buracos deixados pelas tábuas que caíram podem ser pulados com segurança.
No local onde Pedrinho se encontra existe uma placa mostrando as ligações entre as pontes e também quantas tábuas estão faltando em cada uma das pontes. Pedrinho está cansado e não há muita visibilidade durante a noite. Ele precisa, portanto, tomar muito cuidado para não cair em algum dos buracos.
Pedrinho possui um laptop na mochila, mas só o usa para comunicar-se com os amigos. Ele liga sua internet via satélite, encontra você on-line, e pede sua ajuda.
Sua tarefa é escrever um programa que receba as informações sobre as pontes (as ligações entre elas e a quantidade de tábuas faltando em cada uma) e calcule qual é o menor número de buracos que Pedrinho precisa pular para chegar ao outro lado do desfiladeiro.
#### Entrada
A primeira linha da entrada contém dois número inteiros $N$ e $M$ representando o número de pilares no desfiladeiro e o número de pontes, respectivamente. Cada uma das $M$ linhas seguintes contém 3 inteiros $S$, $T$, $B$, indicando que existe uma ponte ligando os pilares $S$ e $T$ , e que possui $B$ buracos. Não existe linha representando ponte com $S$ = $T$ . O valor de pilar 0 representa a borda do desfiladeiro onde Pedrinho está, e o valor de pilar $N + 1$ representa a borda do desfiladeiro onde está o acampamento. Não existem duas pontes distintas ligando o mesmo par de locais (pilares ou bordas do desfiladeiro).
Você pode supor que sempre existirá um caminho de pontes entre o lado do desfiladeiro em que Pedrinho se encontra até o lado do desfiladeiro onde está o acampamento.
#### Saída
Seu programa deve imprimir, na saída padrão, um número inteiro representando a menor quantidade de buracos que Pedrinho terá que pular para conseguir chegar ao acampamento.
#### Restrições
* $1 \leq N \leq 1000$
* $2 \leq M \leq 10000$
* $0 \leq S \leq N + 1$
* $0 \leq T \leq N + 1$
* $1 \leq B \leq 1000$
|
2,879 | 65 | Mina | Médio | Grafos | Nossa mina de ouro será representada por $N$ linhas e $N$ colunas de quadrados. O mineiro está no quadrado inicial (superior esquerdo) e precisa cavar até o quadrado final (inferior direito), onde existe a maior concentração de ouro da mina. Alguns quadrados, porém, estão bloqueados por pedras, o que dificulta o trabalho.
Sabendo que o mineiro pode realizar apenas movimentos ortogonais, seu programa deve calcular o número mínimo de quadrados bloqueados pelos quais o mineiro tem que passar para chegar no quadrado inferior direito. Os quadrados inicial e final nunca estão bloqueados. A figura abaixo ilustra três possíveis minas, para $N = 8$, para as quais os números mínimos de quadrados bloqueados são, respectivamente, três, zero e nove. A figura também mostra três possíveis trajetórias mínimas, como exemplo.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando as dimensões da mina. Cada uma das $N$ linhas seguintes contém $N$ inteiros, definindo os quadrados da mina. O inteiro 0 representa um quadrado livre e o inteiro 1, um quadrado bloqueado.
#### Saída
Seu programa deve produzir uma única linha, contendo um único inteiro, o número mínimo de quadrados bloqueados pelos quais o mineiro tem que passar para chegar no quadrado final.
#### Restrições
* $1 \leq N \leq 100$ |
2,880 | 469 | Chuva (OBI 2019) | Médio | Grafos | Está chovendo tanto na Obilândia que começaram a aparecer goteiras dentro da casa do prefeito. Uma dessas goteiras está fazendo escorrer água verticalmente, a partir de um ponto no teto, numa parede onde há várias prateleiras horizontais. Quando a água bate em uma prateleira, ela começa a escorrer horizontalmente para os dois lados, direita e esquerda, até as extremidades da prateleira, quando volta a escorrer verticalmente.
Vamos representar a parede por uma matriz de $N$ linhas e $M$ colunas de caracteres, como mostrado ao lado. As prateleiras serão representadas por “#” e a parede por “.”. Só existem prateleiras nas linhas pares e elas nunca encostam na borda da parede. Há apenas um ponto de vazamento representado pelo caractere “o” na primeira linha.
Para deixar mais rigorosa a forma como a água vai escorrer, seja $c(i, j)$ o caractere na linha $i$ coluna $j$. Se $c(i, j)=$ “.”, então ele deve virar “o” sempre que:
* $c(i - 1, j)=$“o”; ou
* $c(i, j - 1)=$“o” e $c(i + 1, j - 1)=$“#”; ou
* $c(i, j + 1)=$“o” e $c(i + 1, j + 1)=$“#”.
Neste problema, dada a matriz representando a parede no início do vazamento, seu programa deve imprimir na saída uma matriz representando a parede usando o caractere “o” exatamente nas posições que serão molhadas pelo vazamento, como ilustrado acima.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$, respectivamente o número de linhas e colunas da matriz. As $N$ linhas seguintes da entrada contêm, cada uma, uma sequência de $M$ caracteres entre três possíveis: “.”, “#” ou “o”.
#### Saída
Seu programa deve imprimir $N$ linhas, cada uma contendo uma sequência de $M$ caracteres, representando a matriz da entrada usando o caractere “o” exatamente nas posições que serão molhadas pelo vazamento.
#### Restrições
* $3 \leq N \leq 500$ e $3 \leq M \leq 500$;
* O número de linhas $N$ é ímpar;
* Há exatamente um caractere “o” na primeira linha;
* As linhas ímpares, a primeira coluna e a última coluna não possuem o caractere “#”. |
2,881 | 825 | Fissura Perigosa | Médio | Grafos | A erupção do vulcão Kilauea em 2018 no Havaí atraiu a atenção de todo o mundo. Inicialmente a força da erupção era menor e a lava avançou para o sul com relativamente poucos danos. Após algumas semanas, porém, a fissura 8 começou a jorrar com mais força e a lava avançou também para o norte trazendo muita destruição.
Você está ajudando na implementação de um sistema para simular a área por onde a lava avançaria, em função da força da erupção. O mapa será representado simplificadamente por uma matriz quadrada de caracteres, de 1 a 9, indicando a altitude do terreno em cada posição da matriz. Vamos considerar que a fissura 8, por onde a erupção se inicia, está sempre na posição do canto superior esquerdo da matriz. Dada a força da erupção, que será um valor inteiro, de 0 a 9, seu programa deve imprimir a matriz de caracteres representando o avanço final da lava. Se a lava consegue invadir uma posição da matriz, o caractere naquela posição deve ser trocado por um asterisco ('*'). Uma posição será invadida pela lava se seu valor for menor ou igual à força da erupção e
* for a posição inicial; ou
* estiver adjacente, ortogonalmente (abaixo, acima, à esquerda ou à direita), a uma posição invadida.
A figura abaixo mostra um exemplo de mapa e o avanço final da lava para quatro forças de erupção: 1, 3, 6 e 8, respectivamente da esquerda para a direita.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $F$ representando, respectivamente o número de linhas (que é igual ao de colunas) da matriz e a força da erupção. Cada uma das $N$ linhas seguintes contém uma string de $N$ caracteres, entre 1 e 9, indicando o mapa de entrada.
#### Saída
Seu programa deve imprimir $N$ linhas contendo, cada uma, $N$ caracteres representando o avanço final da lava de acordo com o enunciado.
#### Restrições:
* $1 \leq N \leq 500$
* $0 \leq F \leq 9$
#### Informações sobre a pontuação:
Em um conjunto de casos de teste somando 20 pontos, $N \leq 10$.
Em um conjunto de casos de teste somando 20 pontos, $10 < N \leq 100$.
Em um conjunto de casos de teste somando 60 pontos, nenhuma restrição adicional.
|
2,882 | 512 | Famílias de Troia | Médio | Grafos | A Guerra de Troia pode ter sido um grande conflito bélico entre gregos e troianos, possivelmente ocorrido entre 1300 a.C. e 1200 a.C. (fim da Idade do Bronze no Mediterrâneo). Recentemente foram encontradas inscrições numa caverna a respeito de sobreviventes. Após um trabalho árduo, arqueólogos descobriram que as inscrições descreviam relações de parentesco numa certa população. Cada item da inscrição indicavam duas pessoas que pertenciam a uma mesma família. Seu problema é determinar quantas famílias distintas existem.
#### Entrada
O arquivo de entrada consiste de $M + 1$ linhas. A primeira linha do arquivo de entrada contém um inteiro positivo $N$, que indica o número de elementos da comunidade, numerados de 1 a $N$. As demais $M$ linhas do arquivo de entrada contêm, cada uma, dois inteiros. Cada inteiro identifica um elemento da comunidade. Cada linha indica que os dois indivíduos pertencem a uma mesma família.
#### Saída
A saída deve conter apenas uma linha contendo um único inteiro, que é o número de famílias.
#### Restrições
* $1 \leq N \leq 5 * 10^4$
* $1 \leq M \leq 10^5$
|
2,883 | 298 | Reduzindo Detalhes de um Mapa | Difícil | Grafos | Leonardo Nascimento é um garoto de 13 anos apaixonado por cartografia. Durante as férias de janeiro de 2011, ele alternava seu tempo entre navegar na internet (pesquisando sobre mapas) e arrumar sua coleção de mapas. Navegando na internet, Leonardo descobriu um site especializado em mapas, o Google Maps. Depois de alguns dias usando o site, Leonardo percebeu que quando diminuía o zoom algumas ruas não eram mais exibidas no mapa, isto é, o zoom determinava também o nível de detalhe do mapa. A figura abaixo ilustra um dos testes feito por Leonardo.
Ele sabe que você participa da OBI e que você adora resolver os problemas que envolvem mapas. Então resolveu formular o seguinte problema: dado um mapa de cidades e rodovias que as ligam, selecione um subconjunto das rodovias tal que entre qualquer par de cidades exista uma rota ligando-as e a soma dos comprimentos das rodovias é mínimo. Na figura abaixo e à esquerda temos um exemplo com cinco cidades e seis rodovias ligando-as. A figura abaixo e à direita ilustra uma solução cuja soma dos comprimentos é 34.
Para facilitar um pouco sua vida, Leonardo, determinou que você só precisa dizer a soma dos comprimentos das
rodovias do subconjunto selecionado para um dado mapa.
#### Entrada
A primeira linha da entrada contém dois números $N$ e $M$ que representam o número de cidades e o número de rodovias respectivamente. Cada uma das próximas M linhas é composta por três inteiros $U$, $V$ e $C$ que indiciam que existe uma rodovia de comprimento $C$ que liga as cidades $U$ e $V$.
#### Saída
A saída consiste em apenas uma linha contendo a soma do comprimento das rodovias selecionadas.
#### Restrições
* $1 \leq N \leq 500$
* $1 \leq M \leq 124750$
* $1 \leq U, V \leq N$ e $U \ne V$
* $1 \leq C \leq 500$.
|
2,884 | 122 | Ladrilhos | Médio | Grafos | Avelino tem um mosaico em uma das paredes de sua casa. É uma mosaico muito antigo, composto por pequenos ladrilhos coloridos. Como é um mosaico antigo, alguns ladrilhos se soltaram ao longo dos anos formando buracos.
Agora, Avelino quer restaurar o mosaico cobrindo os buracos com novos ladrilhos. Entretanto, para economizar, Avelino quer comprar ladrilhos de uma única cor para tapar os buracos. Em particular, quer comprar ladrilhos de uma das cores originais ou de uma cor ainda não contida no mosaico.
Por ser um mosaico, não se deseja que hajam áreas muito grandes com a mesma cor. Avelino resolveu que vai escolher a cor dos ladrilhos tentando fazer com que o tamanho da menor área monocromática seja o menor possível, para que haja mais detalhes. Veja que pode existir mais de uma cor possível. Uma área é monocromática se todos os ladrilhos nela são da mesma cor. Dois ladrilhos adjacentes fazem parte da mesma área se possuem a mesma cor, e dois ladrilhos são adjacentes se compartilham um lado.
Veja o primeiro caso de exemplo, temos três áreas da cor 1 (uma de tamanho 3 e duas de tamanho 2), uma área da cor 2 (de tamanho 3) e uma área da cor 3 de tamanho 7. Uma resposta possível seria escolher a cor 1, fazendo com que a menor área monocromática seja de tamanho 2. Se escolhermos a cor 2 a menor área seria de tamanho 3.
Crie um programa que imprima o tamanho da menor área possível.
#### Entrada
A primeira linha contém dois inteiros $H$ e $L$, a altura e largura do mosaico, respectivamente. Em seguida, $H$ linhas conterão cada uma $L$ inteiros, separados por espaço, correspondendo às cores dos ladrilhos. Um inteiro 0 corresponde a um buraco e um inteiro $i \neq 0$ corresponde a um ladrilho com a i-ésima cor.
#### Saída
Seu programa deve produzir uma linha, contendo um inteiro, o tamanho da menor área possível.
#### Restrições
* $1 \leq H, L \leq 200$
* $1 \leq i \leq 40000$
|
2,885 | 28 | Frete | Médio | Grafos | O senhor Satoshi passou anos reclamando da empresa de correios do seu país, porque ela sempre transportava suas encomendas usando um caminho que passava pelo número mínimo de cidades entre a cidade onde o senhor Satoshi mora e a cidade destino da encomenda. A empresa alegava que essa estratégia levava ao menor tempo para a entrega final da encomenda. O problema é que ele notou que essa estratégia da empresa nem sempre levava ao menor preço para o frete total. Se ele pudesse escolher o caminho por onde a encomenda deveria passar para ir da sua cidade para a cidade destino, ele poderia economizar bastante com o frete, já que não havia muita urgência para a maioria de suas encomendas.
Depois de muita reclamação, a empresa finalmente está dando aos clientes a opção de determinar o caminho por onde a encomenda deve passar. O senhor Satoshi, feliz da vida, agora quer a sua ajuda para implementar um programa que, dado o custo de transporte de uma encomenda entre vários pares de cidades pelo país, para os quais a empresa realiza entregas diretas, determine qual é o preço total mínimo para o frete entre a cidade onde ele mora e a cidade destino da encomenda
O país tem $N$ cidades, identificadas pelos números de 1 a $N$. O senhor Satoshi mora na cidade 1 e o destino da encomenda será sempre a cidade $N$. É garantido que sempre haverá um caminho de 1 até $N$. No exemplo da figura, para $N = 5$, o custo mínimo será 7, para o caminho 1 → 2 → 4 → 5.
#### Entrada
A primeira linha da entrada contém dois números inteiros $N$ e $M$, representando o número de cidades e quantos pares de cidades possuem entrega direta de encomenda pela empresa. As $M$ linhas seguintes contêm, cada uma, três inteiros $A$, $B$ e $C$, indicando que a empresa realiza a entrega de uma encomenda diretamente entre as cidades $A$ e $B$, cobrando o preço $C$.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando o preço mínimo total para o frete entre a cidade onde o senhor Satoshi mora, a cidade 1, e a cidade destino da encomenda, a cidade $N$.
#### Restrições
* $2 \leq N \leq 100$ e $1 \leq M \leq 1000$
* $1 \leq A, B \leq N$ e $A \neq B$
* $1 \leq C \leq 1000$ |
2,886 | 303 | Reunião | Difícil | Grafos | Todos os anos, a SBC (Sociedade Brasileira de Caminhoneiros) reúne seus membros em alguma cidade para discutir sobre a profissão. Nessas reuniões são discutidos os problemas da categoria e são apresentadas sugestões sobre como melhorar as condições de trabalho.
O grande problema desse tipo de encontro é que os membros estão espalhados pelo país, uma vez que a profissão exige que eles viajem para diversos lugares todos os dias. Por isso, a escolha da cidade onde será feita a reunião sempre é feita de modo que não prejudique demais nenhum dos caminhoneiros. O critério para tal é que a maior das distâncias percorridas pelos caminhoneiros para chegar ao local da reunião deve ser a menor possível. Ou seja, a distância percorrida pelo caminhoneiro que vai percorrer a maior distância entre todos os caminhoneiros para chegar à reunião deve ser a menor possível.
Dadas as cidades onde se encontram os caminhoneiros e a descrição das estradas que interligam essas cidades, escreva um programa que determina qual será a menor distância máxima percorrida por um caminhoneiro para chegar até o local da reunião. Os caminhoneiros conhecem bem as estradas, e portando sempre fazem o menor caminho possível até a cidade da reunião. Sempre existe um caminho ligando quaisquer duas cidades.
#### Entrada
A primeira linha da entrada possui dois números inteiros $N$ e $M$, que representam, respectivamente, o número de cidades e o número de estradas que as interligam. As cidades são identificadas por números inteiros entre 0 e $N$ - 1. As próximas $M$ linhas da entrada possuem, cada uma, a descrição de uma estrada.
Cada descrição de entrada é composta por três números inteiros: $U$, $V$ e $W$, onde $U$ e $V$ representam cidades e $W$ representa o comprimento da estrada que une essas duas cidades (todas as estradas são mão dupla). É sempre possível viajar entre qualquer duas cidades com as estradas existentes, mas pode haver mais de uma estrada ligando o mesmo par de cidades.
#### Saída
Seu programa deve imprimir uma única linha contendo um número inteiro, a distância máxima percorrida por um caminhoneiro para ir até a reunião, obedecidas as restrições estabelecidas (ou seja, essa distância máxima deve ser a menor possível).
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq W \leq 100$
* $N - 1 \leq M \leq 10000$
* $0 \leq U, V \leq N - 1$
|
2,887 | 307 | Lanche na Empresa | Difícil | Grafos | Atualmente, uma empresa precisa oferecer mais que altos salários para manter seus melhores funcionários. Um dos benefícios comumente oferecidos é o acesso a um suprimento infinito de comida e bebida disponível em cozinhas, onde os funcionários podem preparar lanches e refeições.
Uma empresa de tecnologia decidiu posicionar uma cozinha em suas instalações; entretanto, essa tarefa requer um certo planejamento. Analisando a planta do prédio é possível criar um diagrama contendo todas as salas, todos os corredores que as ligam e os seus respectivos comprimentos, em metros. A cozinha deve ser posicionada em uma das salas de tal forma que a distância entre a cozinha e a sala mais distante da cozinha seja a menor possível.
Obviamente, a empresa deseja utilizar esse fato para anunciar que "nenhum de seus funcionários está a mais de X metros de uma cozinha". Eles contrataram o seu escritório de arquitetura para posicionar a cozinha na sala que minimiza X e você, como programador, deve escrever um programa que informa qual será essa distância.
#### Entrada
A entrada contém um único conjunto de testes. A primeira linha da entrada contém dois inteiros, $S$ e $C$, indicando, respectivamente, o número de salas e o número de corredores. As $C$ linhas seguintes contêm, cada uma, três inteiros, $A$, $B$ e $D$, indicando que existe um corredor de $D$ metros ligando a sala $A$ à sala $B$. Cada corredor é informado uma única vez na entrada.
Note que um corredor ligando as salas $A$ e $B$ pode ser percorrido nos dois sentidos (da sala $A$ para a sala $B$ e da sala $B$ para a sala $A$).
#### Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo um inteiro indicando a distância entre a cozinha e a sala mais distante, considerando que a cozinha foi posicionada na sala onde essa distância é mínima.
#### Restrições
* $1 \leq S \leq 250$
* $1 \leq C \leq 50000$
* $1 \leq A \ B \leq S$
* $A \neq B$
* $1 \leq D \leq 100$
|
2,888 | 318 | Copa do Mundo (OBI 2014) | Difícil | Grafos | A Nlogônia é atualmente um dos países com maior crescimento econômico no mundo, e seus governantes têm se esforçado para que o país seja mais conhecido e respeitado internacionalmente. Recentemente a Nlogônia foi escolhida para ser a sede da Copa do Mundo de Futebol Amador, e está se preparando para receber os milhares de torcedores que o evento atrai.
Como parte da preparação para a Copa, o governo planeja realizar uma reforma em todo o sistema de transporte intermunicipal, que é hoje composto de uma malha de rodovias e ferrovias, cada rodovia ou ferrovia interligando um par de cidades. Com as rodovias e ferrovias existentes já é possível viajar entre qualquer par de cidades (possivelmente passando por outras cidades no caminho), mas o governo quer oferecer melhores condições de transporte para os visitantes e a população.
Como não há recursos para reformar todas as rodovias e ferrovias, o governo quer escolher um conjunto de rodovias e ferrovias para ser reformado, e já realizou um estudo para estabelecer o custo de reforma de cada rodovia e ferrovia. A escolha deve obedecer aos seguintes critérios:
* ao final da reforma, deve ser possível viajar entre qualquer par de cidades (possivelmente passando por outras cidades) utilizando apenas rodovias ou ferrovias reformadas;
* para priorizar o transporte público, dentre as escolhas que satisfazem a restrição 1, deve-se escolher uma que minimize o número de rodovias reformadas;
* dentre as escolhas que satisfazem as restrições 1 e 2, deve-se escolher uma que minimize o custo total.
Você foi contratado para escrever um programa que, conhecidos os custos de reforma de cada rodovia e ferrovia, determine o menor custo possível para a reforma, obedecidos os critérios estabelecidos.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $F$ e $R$, indicando respectivamente o número de cidades, de ferrovias e de rodovias. As cidades são identificadas por inteiros de 1 a $N$. Cada uma das $F$ linhas seguintes descreve uma ferrovia e contém três inteiros $A$, $B$ e $C$, onde $A$ e $B$ representam cidades e $C$ representa o custo da reforma da ferrovia que interliga $A$ e $B$. Cada uma das $R$ linhas seguintes descreve uma rodovia e contém três inteiros $I$, $J$ e $K$, onde $I$ e $J$ representam cidades e $K$ representa o custo da reforma da rodovia que interliga $I$ e $J$.
#### Saída
Seu programa deve produzir uma única linha, contendo o menor custo possível para o conjunto de reformas de ferrovias e rodovias, obedecendo aos critérios estabelecidos.
#### Restrições
* $2 \leq N \leq 100$; $1 \leq F \leq N(N-1)/2$; $1 \leq R \leq N(N-1)/2$
* $1 \leq A < B \leq N$ e $1 \leq I < J \leq N$
* $1 \leq C \leq 1000$ e $1 \leq K \leq 1000$
* Para um conjunto de casos de testes totalizando 20 pontos, $2 \leq N \leq 6$.
|
2,889 | 305 | Frete da Família Silva | Difícil | Grafos | Houve uma determinada época no planeta Terra em que a população estava grande demais, e determinadas medidas foram tomadas para sanar esse problema. Uma vez que as primeiras colônias já haviam se estabelecido no planeta Marte, todos os países concordaram em mandar para lá algumas pessoas. O presidente de Pizzalândia, Lagosta da Silva, era uma pessoa que valorizava a família, e decidiu que não ia separar famílias em nome dessa atitude. Resolveu, então, mandar uma família inteira para Marte. No caso, a dele mesmo, a família Silva, provavelmente a mais numerosa do planeta.
Tal família estabeleceu-se em Marte sem problemas, ainda mais com novas invenções que havia por lá. Uma delas era a pílula de nanicolina, substância descoberta naquele planeta, próximo à uma região onde existem pedras voadoras, pedras macias e até pedras falantes. Lendas dizem que algum outro ser extra-terrestre depositou a nanicolina ali num passado distante, enquanto visitava o planeta. O efeito da pílula de nanicolina é a diminuição de tamanho de quem a toma, por um determinado tempo. Tal pílula foi, então, produzida em escala industrial e hoje em dia é distribuída pelos governos marcianos aos colonos que lá residem.
A família Silva, todos os anos, encontra-se em alguma das muitas colônias em Marte para celebrar o aniversário da chegada deles ao planeta. O chefe da família é quem sempre paga o transporte de todos. O transporte é feito através de ônibus-flutuadores fretados. Como todos podem tomar pílulas da nanicolina e ficarem minúsculos, podemos dizer que dentro de cada ônibus-flutuador cabem infinitas pessoas, e que o efeito da pílula vai durar durante toda a viagem.
Assim, o preço de uma viagem de ônibus-flutuador entre duas colônias não depende do número de pessoas que viajam, sendo um preço fixo. Isso permite que algumas economias sejam feitas. Suponha que existam quatro colônias dos Silvas em Marte, ilustrados abaixo:
Os círculos representam as colônias, e as conexões entre elas representam as estradas existentes. O número nas conexões representa o preço de uma viagem de ônibus-flutuador em qualquer direção. Ou seja, uma viagem da colônia <i>A</i> direto para a colônia <i>C</i> (ou de <i>C</i> para <i>A</i>), custa 5 moedas de silício, não importa o número de passageiros.
Suponha que o grande encontro seja na colônia <i>A</i>. Se o chefe da família pagar o frete de <i>B</i> para <i>A</i>, de <i>C</i> para <i>A</i> e de <i>D</i> para <i>A</i>, vai acabar gastando 25 moedas.
Mas uma coisa que poderia ser feita, também, é: os Silvas das colônias <i>B</i> e <i>D</i> vão para a <i>C</i>. Da <i>C</i>, todos vão para a colônia <i>A</i>. Isso tudo teria um gasto de somente 10 moedas.
Este ano o número de colônias dos Silvas aumentou muito em Marte, e o chefe da família está muito preocupado com o dinheiro que vai gastar para pagar todas as viagens. Então ele contratou você, que é o melhor programador daquele planeta, a fazer um programa que recebe as informações a respeito das colônias, das estradas e dos fretes de ônibus-flutuadores, e determine qual é a menor quantidade de dinheiro necessária para custear o transporte de todos os Silvas para o encontro. O desespero do chefe da família é tanto que ele não se importa em qual colônia será o encontro, desde que os custos sejam minimizados.
Você pode assumir que:
* Entre duas colônias diferentes existe no máximo uma estrada direta.
* Sempre existe um caminho (de uma ou mais estradas) entre quaisquer duas colônias.
#### Entrada
A entrada contém um único teste, a ser lido da <i>entrada padrão</i>. A primeira linha contém dois inteiros: $N$ e $M$ ($2 \leq N \leq 1000$, $1 \leq M \leq 10^4$), que representam, respectivamente, o número de colônias e o número de estradas existentes. Depois, seguem $M$ linhas com 3 inteiros: $P$, $Q$ e $U$ ($0 \leq P$, $Q \leq N - 1$, $1 \leq U \leq 1000$), indicando que existe uma estrada de mão dupla entre as colônias $P$ e $Q$, cujo custo do frete de viagem entre essas duas colônias é $U$ moedas.
#### Saída
Seu programa deve imprimir, na <i>saída padrão</i>, um único inteiro, representando o número mínimo de moedas necessárias para custear o transporte de todos os Silvas à colônia onde será realizada o encontro.
#### Informações sobre Potuação
* Em um conjunto de casos de teste que totaliza 30 pontos, $N \leq 10$ e $M \leq 100$.
* Em um conjunto de casos de teste que totaliza 55 pontos, $N \leq 100$ e $M \leq 1000$.
|
2,890 | 331 | Escalonamento Ótimo | Difícil | Grafos | O SBC (System for Batch Computing) é um sistema operacional voltado para a execução sequencial de tarefas. O operador do sistema cria tarefas e o sistema operacional é responsável por agendar a execução destas tarefas.
Cada tarefa pode depender da conclusão de algumas tarefas para poder começar. Se uma tarefa A depende de uma tarefa B, a tarefa B deve terminar antes que a tarefa A inicie sua execução.
Além disto, cada tarefa possui uma prioridade. É sempre mais vantajoso para o sistema começar executando uma tarefa de mais alta prioridade, depois continuar executando uma tarefa de mais alta prioridade dentre as que sobraram e assim por diante.
Neste problema, será dado um inteiro $N$, que irá representar o número de tarefas no sistema. As tarefas serão numeradas de 0 até $N$ - 1. Tarefas com índice menor possuem prioridade maior, de forma que a tarefa 0 é a tarefa de mais alta prioridade, a tarefa 1 é a tarefa com a segunda maior prioridade e assim por diante, até a tarefa $N$-1, que é a tarefa com a menor prioridade.
Além disso, serão dadas $M$ relações de dependência entre as tarefas.
Seu objetivo será decidir se é possível executar as tarefas em alguma ordem. Caso seja possível, você deverá produzir uma ordem de execução ótima para as tarefas, isto é, desempate as ordens possíveis pela prioridade da primeira tarefa. Se o empate ainda persistir, desempate pela prioridade da segunda tarefa, e assim por diante.
#### Entrada
A primeira linha da entrada contém inteiros $N$ e $M$. As próximas $M$ linhas descrevem, cada uma, uma dependência entre as tarefas da entrada. Cada uma dessas linhas irá conter dois inteiros $A$ e $B$ que indicam que a tarefa $B$ depende da tarefa $A$, isto é, que a tarefa $A$ deve terminar antes que a tarefa $B$ inicie.
#### Saída
Se não for possível ordenar as tarefas de forma que as dependências sejam satisfeitas, imprima uma única linha contendo o caracter "∗". Caso contrário, imprima $N$ linhas contendo cada uma um número inteiro. O inteiro na i-ésima linha deve ser o índice da i-ésima tarefa a ser executada na ordem ótima de execução das tarefas.
#### Restrições
* $0 \leq N \leq 50000$
* $0 \leq M \leq 200000$
* $0 \leq A, B \leq$ $N$
|
2,891 | 296 | Desvio de Rota | Difícil | Grafos | O sistema rodoviário de um país interliga todas as suas $N$ cidades de modo que, a partir de uma cidade qualquer, é possível chegar a cada uma das outras cidades trafegando pelas estradas existentes. Cada estrada liga duas cidades distintas, tem mão dupla e um único posto de pedágio (o pedágio é pago nos dois sentidos de tráfego). As estradas não se intersectam a não ser nas cidades. Nenhum par de cidades é interligado por duas ou mais estradas.
A Transportadora Dias oferece um serviço de transporte de encomendas entre as cidades. Cada encomenda deve ser levada de uma cidade $A$ para uma outra cidade $B$. A direção da Transportadora Dias define, para cada encomenda, uma rota de serviço, composta por $C$ cidades e $C$-1 estradas: a primeira cidade da rota de serviço é a origem da encomenda, a última o destino da encomenda. A rota de serviço não passa duas vezes pela mesma cidade, e o veículo escolhido para fazer o transporte de uma encomenda pode trafegar apenas pela rota de serviço definida.
Certo dia, no entanto, o veículo que executava uma entrega quebrou e precisou ser levado para conserto em uma cidade que não está entre as cidades de sua rota de serviço. A direção da Transportadora Dias quer saber qual é o menor custo total, em termos de pedágio, para que o veículo entregue a encomenda na cidade destino, a partir da cidade em que foi consertado, mas com uma restrição adicional: se em algum momento o veículo passar por uma das cidades que compõem a sua rota de serviço, ele deve voltar a obedecer a rota de serviço.
#### Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém quatro inteiros $N$, $M$, $C$ e $K$, representando, respectivamente, o número de cidades do país, o número de estradas, o número de cidades na rota de serviço e a cidade em que o veículo foi consertado. As cidades são identificadas por inteiros de 0 a $N$-1. A rota de serviço é $0, 1, \ldots , C-1$, ou seja, a origem é 0, de 0 passa para 1, de 1 para 2 e assim por diante, até o destino $C-1$.
As $M$ linhas seguintes descrevem o sistema rodoviário do país. Cada uma dessas linhas descreve uma estrada e contém três inteiros $U$, $V$ e $P$, indicando que há uma estrada interligando as cidades $U$ e $V$ com custo de pedágio $P$. O último caso de teste é seguido por uma linha contendo quatro zeros separados por espaço em branco.
#### Saída
Para cada caso de teste, o seu programa deve imprimir uma única linha, contendo um único inteiro $T$, o custo total mínimo necessário, em termos de pedágio, para que o veículo chegue ao destino.
#### Restrições
* $4 \leq N \leq 250$
* $3 \leq M \leq \frac{N \cdot (N - 1)}{2}$
* $2 \leq C \leq N - 1$
* $C \leq K \leq N - 1$
* $0 \leq U, V \leq N - 1$
* $0 \leq P \leq 250$
|
2,892 | 183 | Ilhas | Médio | Grafos | Os moradores das Ilhas Brasileiras Ocidentais (IBO) são assíduos jogadores do mais recente jogo online, Magos e Guerreiros. Tão competitivas se tornaram as partidas de Magos e Guerreiros na IBO, que a empresa criadora do jogo decidiu instalar em uma das ilhas um servidor dedicado apenas aos jogadores da IBO.
Entretanto, a empresa sabe que, se os jogadores acharem que o novo servidor é injusto, eles irão parar de jogar Magos e Guerreiros, gerando incontáveis perdas. Para avaliar se o novo servidor é justo, os jogadores vão comparar o desempenho do jogo na ilha que tem a conexão mais rápida e o desempenho na ilha que tem a conexão mais lenta com o novo servidor. Se a diferença de desempenho for muito grande, os residentes da ilha mais distante se sentirão injustiçados e abandonarão o jogo.
A conexão de internet da IBO funciona através de um sistema de cabos de fibra ótica. Pares de ilhas são conectados por cabos, e cada cabo toma um certo tempo (chamado de ping) para comunicar informação entre as duas partes. Quando duas ilhas se comunicam através de uma série de cabos (portanto, através de ilhas intermediárias), o ping entre elas é a soma dos pings de cada cabo no caminho. A rede da IBO foi implementada por ótimos programadores e, portanto, um par de ilhas sempre se comunica através do caminho com menor ping possível.
Dada a configuração da rede da IBO e a ilha em que a empresa deseja instalar o novo servidor, determine a diferença entre os pings da ilha com menor e maior pings até o servidor.
#### Entrada
A primeira linha contém $N$ e $M$, o número de ilhas e o número de cabos de fibra ótica, respectivamente.
As ilhas são numeradas de 1 a $N$. Cada uma das $M$ linhas seguintes contém três inteiros $U_i$, $V_i$ e $P_i$ e descreve um cabo entre as ilhas $U_i$ e $V_i$ com ping $P_i$ (note que cabos transmitem informação em ambas as direções). Finalmente, a última linha contém um inteiro $S$, o número da ilha em que o servidor será instalado.
#### Saída
Seu programa deve produzir um inteiro representando a diferença entre o ping da ilha com maior ping até o servidor, e o da ilha com menor ping até o servidor. Note que a ilha em que o servidor se encontra não é considerada no cálculo do menor ping.
#### Restrições
* $2 \leq N \leq 1000$
* $N - 1 \leq M \leq 10^5$
* $1 \leq U_i \leq N$
* $1 \leq V_i \leq N$
* $1 \leq S \leq N$
* $1 \leq P_i \leq 1000$
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 30 pontos, $2 \leq N \leq 100$ e $N - 1 \leq M \leq 1000$.
|
2,893 | 567 | Manchas de Pele | Médio | Grafos | O laboratório de dermatologia da Linearlândia está implementando um software para contar o número de manchas presentes numa imagem digital de $N$ por $M$ pixels. Cada pixel na imagem é preto ou branco e dois pixels pretos distintos $A$ e $B$ pertencem à mesma mancha se e somente se: existir uma sequência de pixels $[P_1, P_2, \ldots , P_k]$, onde $k \geq 2$, $A = P_1$, $B = P_k$ e para todo $1 \leq i < k$, $P_i$ é ortogonalmente adjacente a $P_{i+1}$ ($P_i$ imediatamente acima, abaixo, à esquerda ou à direita de $P_{i+1}$).
A figura acima, para $N = 8$ e $M = 9$, ilustra uma imagem digital onde existem oito manchas. Dada a imagem, seu programa deve contar o número de manchas presentes.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$, representando, respectivamente, o número de linhas e colunas da imagem. As $N$ linhas seguintes contêm, cada uma, $M$ inteiros $P$ representando os pixels da imagem.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro, o número de manchas na imagem.
#### Restrições
* $1 \leq N \leq 1000$
* $1 \leq M \leq 1000$
* O valor de $P$ é 1, representando um pixel preto, ou 0, representando um pixel branco.
#### Informações sobre a pontuação
* Para um conjunto de casos de testes valendo 10 pontos, $N = M = 2$.
* Para um conjunto de casos de testes valendo outros 20 pontos, $N = 1$.
* Para um conjunto de casos de testes valendo outros 20 pontos, $N, M \leq 100$.
* Para um conjunto de casos de testes valendo outros 50 pontos, nenhuma restrição adicional (Atenção, para essa parcial, não é recomendada uma implementação recursiva!) |
2,894 | 73 | Família Real | Médio | Grafos | O rei de um reino muito muito distante deu uma grande festa para reunir todas as gerações dos seus descendentes: filhos e filhas, netos e netas, bisnetos e bisnetas, e assim por diante. Ele, que gosta muito de estatísticas, agora quer saber, para cada geração, qual a porcentagem de descendentes daquela geração que compareceu à festa. Você foi contratado para escrever um programa de computador que calcule as porcentagens de todas as gerações!
O rei tem $N$ descendentes, identificados com os números de 1 a $N$. O próprio rei será identificado com o número 0. Será dada apenas a informação, para cada descendente, de quem é o seu pai ou sua mãe, na linha de descendência que começa no rei. Além disso, claro, será dada a lista de todos que compareceram à festa.
#### Entrada
A primeira linha da entrada contém dois inteiros $N$ e $M$, respectivamente, o número de descendentes e o número de participantes da festa. A segunda linha contém $N$ números, representando os pais ou mães dos $N$ descendentes, em ordem crescente: o primeiro número indica o pai ou a mãe do descendente de número 1, o segundo número indica o pai ou a mãe do descendente de número 2, e assim por diante. A terceira linha contém $M$ números, identificando todos os descendentes que compareceram à festa.
#### Saída
Seu programa deve imprimir uma linha com uma lista de números reais, com precisão de duas casas decimais, indicando a porcentagem, para cada geração, dos descendentes daquela geração que compareceram à festa. O primeiro número deve ser a porcentagem dos filhos e filhas, o segundo dos netos e netas, e assim por diante.
#### Restrições
* $1 \leq M \leq N \leq 10000$ |
2,895 | 36 | Ônibus | Médio | Grafos | A Linearlândia é composta de $N$ cidades, numeradas de 1 até $N$. Para alguns pares de cidades existe uma linha de ônibus que faz o trajeto de ida e volta diretamente entre as duas cidades do par. Os pares de cidades ligados diretamente por uma linha de ônibus são escolhidos de forma que sempre é possível ir de qualquer cidade para qualquer outra cidade por um, e somente um, caminho (um caminho é uma sequência de linhas de ônibus, sem repetição).
Dada a lista de pares de cidades ligados diretamente por linhas de ônibus, uma cidade origem e uma cidade destino, seu programa deve computar quantos ônibus é preciso pegar para ir da origem ao destino.
Por exemplo, na figura, para ir da cidade 2 para a cidade 12 é preciso pegar 4 ônibus
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $A$ e $B$, representando o número de cidades na Linearlândia, a cidade origem e a cidade destino, respectivamente. As $N-1$ linhas seguintes contém, cada uma, dois inteiros $P$ e $Q$, indicando que existe uma linha de ônibus ligando diretamente as cidades $P$ e $Q$.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando quantos ônibus é preciso pegar para ir de $A$ até $B$.
#### Restrições
* $2 \leq N \leq 10000$
* $1 \leq A \leq N$, $1 \leq B \leq N$, $A \neq B$
* $1 \leq P \leq N$, $1 \leq Q \leq N$ |
2,896 | 336 | Jogo da Memória (OBI 2014) | Difícil | Grafos | Pedro e Paulo resolveram complicar um pouco o tradicional Jogo da Memória, em que os jogadores precisam virar duas cartas iguais. Eles colocam as cartas no chão, viradas para baixo, e fazem algumas linhas ligando pares de cartas, usando giz, de modo que para qualquer par de cartas ($A$,$B$) existe uma e apenas uma sequência de cartas distintas que leva de $A$ até $B$ através das linhas que eles desenharam. Com isso, ao virar duas cartas, o jogador ganha uma quantidade de pontos igual ao tamanho da sequência de linhas entre as duas cartas, se elas forem iguais. Se forem diferentes, o jogador perde aquela quantidade de pontos.
Pedro e Paulo, agora, estão estudando qual é a melhor estratégia para esse jogo e precisam da sua ajuda para resolver uma tarefa específica: dadas as ligações entre as $N$ cartas, calcular a soma dos tamanhos das sequências entre todos os $N$/2 pares de cartas iguais!
O jogo possui $N$ cartas, de índices 1 até $N$. Cada carta possui a figura de um número de 1 até $N$/2 desenhada. Exatamente duas cartas possuem a figura de cada número entre 1 e $N/2$.
#### Entrada
A primeira linha da entrada contém o número de cartas $N$. A segunda linha da entrada contém $N$ inteiros $C_i$, indicando qual número está anotado na carta de índice $i$. Cada uma das $N$-1 linhas seguintes contém dois números $A$ e $B$, indicando que existe uma linha desenhada entre as cartas de índices $A$ e $B$.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro, a soma dos tamanhos das sequências entre todos os $N$/2 pares de cartas iguais.
#### Restrições
* $2 \leq N \leq 50000$, $N$ é par
* $1 \leq C_i \leq N/2$
* $1 \leq A, B \leq N$
|
2,897 | 38 | Visita entre cidades | Médio | Grafos | A Linearlândia é composta de $N$ cidades, numeradas de 1 até $N$. Para alguns pares de cidades existe exatamente uma estrada bidirecional entre as duas cidades do par. Os pares de cidades ligados diretamente por uma estrada são escolhidos de forma que sempre é possível ir de qualquer cidade para qualquer outra cidade por um, e somente um, caminho (um caminho é uma sequência de estradas, sem repetição).
Dada a lista de pares de cidades ligados diretamente por estradas, as distâncias entre os pares de cidades, uma cidade origem e uma cidade destino, seu programa deve computar qual a distância entre a cidade de origem e a cidade destino, usando as estradas. Por exemplo, na figura, a distância para ir da cidade 12 para a cidade 7 é 23; a distância da cidade 15 para a cidade 12 é 16; e a distância da cidade 7 para a cidade 15 é 33.
#### Entrada
A primeira linha da entrada contém três inteiros $N$, $A$ e $B$, representando o número de cidades na Linearlândia, a cidade origem e a cidade destino, respectivamente. As cidades são identificadas por inteiros de 1 a $N$. As $N-1$ linhas seguintes contém, cada uma, três inteiros $P$, $Q$ e $D$, indicando que existe uma estrada ligando diretamente as cidades $P$ e $Q$, com distância $D$.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando a distância para ir de $A$ até $B$ pelas estradas de Linearlândia.
#### Restrições
* $2 \leq N \leq 10000$
* $1 \leq A \leq N$, $1 \leq B \leq N$, $A \neq B$
* $1 \leq P \leq N$, $1 \leq Q \leq N$
* $1 \leq D \leq 100$
|
2,898 | 42 | Dividindo o império | Difícil | Grafos | Um grande Império é composto por $N$ cidades, numeradas de 1 até $N$. Alguns pares de cidades estão ligados diretamente por estradas bidirecionais e, por uma antiga tradição, esses pares são escolhidos de maneira que sempre é possível ir de qualquer cidade para qualquer outra cidade por exatamente um caminho (um caminho é uma sequência de estradas).
O imperador quer dividir seu império em dois para deixar de herança para seus dois filhos. Ele percebeu que basta destruir exatamente uma estrada, qualquer estrada, para dividir seu império em dois menores que, separadamente, preservam a antiga tradição. Ele agora precisa da sua ajuda para computar a menor diferença possível no número de cidades entre os dois impérios resultantes.
Por exemplo, na figura, se o imperador destruir a estrada entre as cidades 3 e 12, os impérios resultantes terão 5 e 11 cidades, uma diferença de 6 cidades. Porém, se ele destruir a estrada entre as cidades 3 e 5, a diferença será de apenas 4 cidades. Você consegue ver que essa é a menor diferença possível para esse exemplo da figura?
#### Entrada
A primeira linha da entrada contém um inteiro $N$, representando o número de cidades no império. As $N-1$ linhas seguintes contém, cada uma, dois inteiros $A$ e $B$, indicando que existe uma estrada bidirecional ligando diretamente as cidades $A$ e $B$.
#### Saída
Seu programa deve imprimir uma linha contendo um inteiro representando a menor diferença possível no número de cidades entre os dois impérios resultantes.
#### Restrições
* $2 \leq N \leq 10^5$
* $1 \leq A \leq N$, $1 \leq B \leq N$
#### Informações sobre a pontuação
* Em um conjunto de casos de teste somando 40 pontos, $N \leq 10000$ |
2,899 | 258 | Passa Bolinha | Médio | Grafos | O professor Miguel desafiou os alunos do colégio onde ele leciona com uma brincadeira que exige muita atenção! No pátio do colégio, os alunos formam um quadrado com N fileiras e N colunas, de modo que a primeira fileira esteja voltada para o norte. Cada um dos N2 alunos segura uma bandeira e tem um número colado na camiseta. Inicialmente, as bandeiras estão abaixadas e os alunos estão voltados para o norte. Todos os alunos têm que seguir exatamente o mesmo comportamento:
* Ao receber a bolinha, levanta sua bandeira e realiza a seguinte ação quatro vezes, em sequência: "Vira-se 90 graus no sentido horário. Se o colega que ficou à sua frente tiver um número na camiseta maior ou igual ao seu, e estiver com a bandeira abaixada, passa a bolinha ao colega e aguarda que ele lhe devolva a bolinha;"
* Devolve a bolinha a quem lhe passou a bolinha inicialmente.
Nesta tarefa, você deve escrever um programa que, dados os números nas camisetas de cada aluno, e a posição do aluno a quem o professor Miguel vai entregar a bolinha, calcule quantas bandeiras estarão levantadas ao final, quando esse aluno devolver a bolinha ao professor. Por exemplo, a parte direita da figura abaixo mostra que sete alunos vão levantar a bandeira se o professor entregar inicialmente a bolinha ao aluno na fileira 3, coluna 1, como indicado na parte esquerda da figura.
#### Entrada
A primeira linha da entrada contém um inteiro $N$, o número de fileiras (que é igual ao de colunas). A segunda linha contém dois números, $I$ e $J$, indicando respectivamente, a fileira e a coluna do aluno a quem o professor Miguel entregará a bolinha. As $N$ linhas seguintes contém $N$ inteiros cada uma, indicando os números que estão nas camisetas dos alunos.
#### Saída
Seu programa deve imprimir apenas uma linha contendo um inteiro, o número de bandeiras que estarão levantadas ao final.
#### Restrições
* $1 \leq N \leq 100$
* $1 \leq I \leq N$ e $1 \leq J \leq N$
* Os números nas camisetas estão entre 1 e 9, inclusive
|
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.