question_text
stringlengths 2
3.82k
| input_outputs
stringlengths 23
941
| algo_tags
sequence |
|---|---|---|
After defeating a Blacklist Rival, you get a chance to draw 1 reward slip out of x hidden valid slips. Initially, x=3 and these hidden valid slips are Cash Slip, Impound Strike Release Marker and Pink Slip of Rival's Car. Initially, the probability of drawing these in a random guess are c, m, and p, respectively. There is also a volatility factor v. You can play any number of Rival Races as long as you don't draw a Pink Slip. Assume that you win each race and get a chance to draw a reward slip. In each draw, you draw one of the x valid items with their respective probabilities. Suppose you draw a particular item and its probability of drawing before the draw was a. Then, If the item was a Pink Slip, the quest is over, and you will not play any more races. Otherwise, If a<=q v, the probability of the item drawn becomes 0 and the item is no longer a valid item for all the further draws, reducing x by 1. Moreover, the reduced probability a is distributed equally among the other remaining valid items. If a > v, the probability of the item drawn reduces by v and the reduced probability is distributed equally among the other valid items. For example, If (c,m,p)=(0.2,0.1,0.7) and v=0.1, after drawing Cash, the new probabilities will be (0.1,0.15,0.75). If (c,m,p)=(0.1,0.2,0.7) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,0.25,0.75). If (c,m,p)=(0.2,Invalid,0.8) and v=0.1, after drawing Cash, the new probabilities will be (0.1,Invalid,0.9). If (c,m,p)=(0.1,Invalid,0.9) and v=0.2, after drawing Cash, the new probabilities will be (Invalid,Invalid,1.0). You need the cars of Rivals. So, you need to find the expected number of races that you must play in order to draw a pink slip. | Input: ['4', '0.2 0.2 0.6 0.2', '0.4 0.2 0.4 0.8', '0.4998 0.4998 0.0004 0.1666', '0.3125 0.6561 0.0314 0.2048', ''] Output:['1.532000000000', '1.860000000000', '5.005050776521', '4.260163673896', ''] | [
0,
3
] |
Highway 201 is the most busy street in Rockport. Traffic cars cause a lot of hindrances to races, especially when there are a lot of them. The track which passes through this highway can be divided into n sub-tracks. You are given an array a where a_i represents the number of traffic cars in the i-th sub-track. You define the inconvenience of the track as \sum\limits_{i=1}^{n} \sum\limits_{j=i+1}^{n} \lvert a_i-a_j\rvert, where |x| is the absolute value of x. You can perform the following operation any (possibly zero) number of times: choose a traffic car and move it from its current sub-track to any other sub-track.Find the minimum inconvenience you can achieve. | Input: ['3', '3', '1 2 3', '4', '0 1 1 0', '10', '8 3 6 11 5 2 1 7 10 4', ''] Output:['0', '4', '21', ''] | [
2,
3
] |
Welcome to Rockport City!It is time for your first ever race in the game against Ronnie. To make the race interesting, you have bet a dollars and Ronnie has bet b dollars. But the fans seem to be disappointed. The excitement of the fans is given by gcd(a,b), where gcd(x, y) denotes the greatest common divisor (GCD) of integers x and y. To make the race more exciting, you can perform two types of operations: Increase both a and b by 1. Decrease both a and b by 1. This operation can only be performed if both a and b are greater than 0. In one move, you can perform any one of these operations. You can perform arbitrary (possibly zero) number of moves. Determine the maximum excitement the fans can get and the minimum number of moves required to achieve it.Note that gcd(x,0)=x for any x >= 0. | Input: ['4', '8 5', '1 2', '4 4', '3 9', ''] Output:['3 1', '1 0', '0 0', '6 3', ''] | [
2,
3
] |
This is the hard version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.A permutation of 1, 2, ..., n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.Recall that the number of inversions in a permutation a_1, a_2, ..., a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.Let p and q be two permutations of 1, 2, ..., n. Find the number of permutation pairs (p,q) that satisfy the following conditions: p is lexicographically smaller than q. the number of inversions in p is greater than the number of inversions in q. Print the number of such pairs modulo mod. Note that mod may not be a prime. | Input: ['4 403458273', ''] Output:['17'] | [
3
] |
This is the easy version of the problem. The only difference between the easy version and the hard version is the constraints on n. You can only make hacks if both versions are solved.A permutation of 1, 2, ..., n is a sequence of n integers, where each integer from 1 to n appears exactly once. For example, [2,3,1,4] is a permutation of 1, 2, 3, 4, but [1,4,2,2] isn't because 2 appears twice in it.Recall that the number of inversions in a permutation a_1, a_2, ..., a_n is the number of pairs of indices (i, j) such that i < j and a_i > a_j.Let p and q be two permutations of 1, 2, ..., n. Find the number of permutation pairs (p,q) that satisfy the following conditions: p is lexicographically smaller than q. the number of inversions in p is greater than the number of inversions in q. Print the number of such pairs modulo mod. Note that mod may not be a prime. | Input: ['4 403458273', ''] Output:['17'] | [
3
] |
You are given a sequence A, where its elements are either in the form + x or -, where x is an integer.For such a sequence S where its elements are either in the form + x or -, define f(S) as follows: iterate through S's elements from the first one to the last one, and maintain a multiset T as you iterate through it. for each element, if it's in the form + x, add x to T; otherwise, erase the smallest element from T (if T is empty, do nothing). after iterating through all S's elements, compute the sum of all elements in T. f(S) is defined as the sum. The sequence b is a subsequence of the sequence a if b can be derived from a by removing zero or more elements without changing the order of the remaining elements. For all A's subsequences B, compute the sum of f(B), modulo 998\,244\,353. | Input: ['4', '-', '+ 1', '+ 2', '-', ''] Output:['16'] | [
3,
4
] |
Let f(i) denote the minimum positive integer x such that x is not a divisor of i.Compute \sum_{i=1}^n f(i) modulo 10^9+7. In other words, compute f(1)+f(2)+...+f(n) modulo 10^9+7. | Input: ['6', '1', '2', '3', '4', '10', '10000000000000000', ''] Output:['2', '5', '7', '10', '26', '366580019', ''] | [
3
] |
There is an infinite set generated as follows: 1 is in this set. If x is in this set, x \cdot a and x+b both are in this set. For example, when a=3 and b=6, the five smallest elements of the set are: 1, 3 (1 is in this set, so 1\cdot a=3 is in this set), 7 (1 is in this set, so 1+b=7 is in this set), 9 (3 is in this set, so 3\cdot a=9 is in this set), 13 (7 is in this set, so 7+b=13 is in this set). Given positive integers a, b, n, determine if n is in this set. | Input: ['5', '24 3 5', '10 3 6', '2345 1 4', '19260817 394 485', '19260817 233 264', ''] Output:['Yes', 'No', 'Yes', 'No', 'Yes', ''] | [
3
] |
You are given a multiset (i. e. a set that can contain multiple equal integers) containing 2n integers. Determine if you can split it into exactly n pairs (i. e. each element should be in exactly one pair) so that the sum of the two elements in each pair is odd (i. e. when divided by 2, the remainder is 1). | Input: ['5', '2', '2 3 4 5', '3', '2 3 4 5 5 5', '1', '2 4', '1', '2 3', '4', '1 5 3 2 6 7 3 4', ''] Output:['Yes', 'No', 'No', 'Yes', 'No', ''] | [
3
] |
You are given an array a_1, a_2, ..., a_n consisting of n distinct integers. Count the number of pairs of indices (i, j) such that i < j and a_i \cdot a_j = i + j. | Input: ['3', '2', '3 1', '3', '6 1 5', '5', '3 1 5 9 2', ''] Output:['1', '1', '3', ''] | [
0,
3
] |
There are n cats in a line, labeled from 1 to n, with the i-th cat at position i. They are bored of gyrating in the same spot all day, so they want to reorder themselves such that no cat is in the same place as before. They are also lazy, so they want to minimize the total distance they move. Help them decide what cat should be at each location after the reordering.For example, if there are 3 cats, this is a valid reordering: [3, 1, 2]. No cat is in its original position. The total distance the cats move is 1 + 1 + 2 = 4 as cat 1 moves one place to the right, cat 2 moves one place to the right, and cat 3 moves two places to the left. | Input: ['2', '2', '3', ''] Output:['2 1 ', '3 1 2 ', ''] | [
2
] |
Note that the memory limit is unusual.There are n chefs numbered 1, 2, ..., n that must prepare dishes for a king. Chef i has skill i and initially has a dish of tastiness a_i where |a_i| <=q i. Each chef has a list of other chefs that he is allowed to copy from. To stop chefs from learning bad habits, the king makes sure that chef i can only copy from chefs of larger skill.There are a sequence of days that pass during which the chefs can work on their dish. During each day, there are two stages during which a chef can change the tastiness of their dish. At the beginning of each day, each chef can choose to work (or not work) on their own dish, thereby multiplying the tastiness of their dish of their skill (a_i := i \cdot a_i) (or doing nothing). After all chefs (who wanted) worked on their own dishes, each start observing the other chefs. In particular, for each chef j on chef i's list, chef i can choose to copy (or not copy) j's dish, thereby adding the tastiness of the j's dish to i's dish (a_i := a_i + a_j) (or doing nothing). It can be assumed that all copying occurs simultaneously. Namely, if chef i chooses to copy from chef j he will copy the tastiness of chef j's dish at the end of stage 1.All chefs work to maximize the tastiness of their own dish in order to please the king.Finally, you are given q queries. Each query is one of two types. 1 k l r β find the sum of tastiness a_l, a_{l+1}, ..., a_{r} after the k-th day. Because this value can be large, find it modulo 10^9 + 7. 2 i x β the king adds x tastiness to the i-th chef's dish before the 1-st day begins (a_i := a_i + x). Note that, because the king wants to see tastier dishes, he only adds positive tastiness (x > 0). Note that queries of type 1 are independent of each all other queries. Specifically, each query of type 1 is a scenario and does not change the initial tastiness a_i of any dish for future queries. Note that queries of type 2 are cumulative and only change the initial tastiness a_i of a dish. See notes for an example of queries. | Input: ['5', '1 0 -2 -2 4', '4 2 3 4 5', '1 3', '1 4', '1 5', '0', '7', '1 1 1 5', '2 4 3', '1 1 1 5', '2 3 2', '1 2 2 4', '2 5 1', '1 981 4 5', ''] Output:['57', '71', '316', '278497818', ''] | [
3
] |
You were playing with permutation p of length n, but you lost it in Blair, Alabama!Luckily, you remember some information about the permutation. More specifically, you remember an array b of length n, where b_i is the number of indices j such that j < i and p_j > p_i.You have the array b, and you want to find the permutation p. However, your memory isn't perfect, and you constantly change the values of b as you learn more. For the next q seconds, one of the following things happen: 1 i x β you realize that b_i is equal to x; 2 i β you need to find the value of p_i. If there's more than one answer, print any. It can be proven that there's always at least one possible answer under the constraints of the problem. Answer the queries, so you can remember the array! | Input: ['3', '0 0 0', '7', '2 1', '2 2', '2 3', '1 2 1', '2 1', '2 2', '2 3', ''] Output:['1', '2', '3', '2', '1', '3', ''] | [
0,
4
] |
This is the hard version of the problem. The only difference is that in this version 1 <= q <= 10^5. You can make hacks only if both versions of the problem are solved.There is a process that takes place on arrays a and b of length n and length n-1 respectively. The process is an infinite sequence of operations. Each operation is as follows: First, choose a random integer i (1 <= i <= n-1). Then, simultaneously set a_i = \min<=ft(a_i, \frac{a_i+a_{i+1}-b_i}{2}\right) and a_{i+1} = \max<=ft(a_{i+1}, \frac{a_i+a_{i+1}+b_i}{2}\right) without any rounding (so values may become non-integer). See notes for an example of an operation.It can be proven that array a converges, i. e. for each i there exists a limit a_i converges to. Let function F(a, b) return the value a_1 converges to after a process on a and b.You are given array b, but not array a. However, you are given a third array c. Array a is good if it contains only integers and satisfies 0 <=q a_i <=q c_i for 1 <=q i <=q n.Your task is to count the number of good arrays a where F(a, b) >=q x for q values of x. Since the number of arrays can be very large, print it modulo 10^9+7. | Input: ['3', '2 3 4', '2 1', '5', '-1 0 1 -100000 100000', ''] Output:['56', '28', '4', '60', '0', ''] | [
3
] |
This is the easy version of the problem. The only difference is that in this version q = 1. You can make hacks only if both versions of the problem are solved.There is a process that takes place on arrays a and b of length n and length n-1 respectively. The process is an infinite sequence of operations. Each operation is as follows: First, choose a random integer i (1 <= i <= n-1). Then, simultaneously set a_i = \min<=ft(a_i, \frac{a_i+a_{i+1}-b_i}{2}\right) and a_{i+1} = \max<=ft(a_{i+1}, \frac{a_i+a_{i+1}+b_i}{2}\right) without any rounding (so values may become non-integer). See notes for an example of an operation.It can be proven that array a converges, i. e. for each i there exists a limit a_i converges to. Let function F(a, b) return the value a_1 converges to after a process on a and b.You are given array b, but not array a. However, you are given a third array c. Array a is good if it contains only integers and satisfies 0 <=q a_i <=q c_i for 1 <=q i <=q n.Your task is to count the number of good arrays a where F(a, b) >=q x for q values of x. Since the number of arrays can be very large, print it modulo 10^9+7. | Input: ['3', '2 3 4', '2 1', '1', '-1', ''] Output:['56', ''] | [
3
] |
You are given a tree consisting of n nodes. You generate an array from the tree by marking nodes one by one.Initially, when no nodes are marked, a node is equiprobably chosen and marked from the entire tree. After that, until all nodes are marked, a node is equiprobably chosen and marked from the set of unmarked nodes with at least one edge to a marked node. It can be shown that the process marks all nodes in the tree. The final array a is the list of the nodes' labels in order of the time each node was marked.Find the expected number of inversions in the array that is generated by the tree and the aforementioned process.The number of inversions in an array a is the number of pairs of indices (i, j) such that i < j and a_i > a_j. For example, the array [4, 1, 3, 2] contains 4 inversions: (1, 2), (1, 3), (1, 4), (3, 4). | Input: ['3', '1 2', '1 3', ''] Output:['166666669', ''] | [
0,
3
] |
Farmer John has a farm that consists of n pastures connected by one-directional roads. Each road has a weight, representing the time it takes to go from the start to the end of the road. The roads could have negative weight, where the cows go so fast that they go back in time! However, Farmer John guarantees that it is impossible for the cows to get stuck in a time loop, where they can infinitely go back in time by traveling across a sequence of roads. Also, each pair of pastures is connected by at most one road in each direction.Unfortunately, Farmer John lost the map of the farm. All he remembers is an array d, where d_i is the smallest amount of time it took the cows to reach the i-th pasture from pasture 1 using a sequence of roads. The cost of his farm is the sum of the weights of each of the roads, and Farmer John needs to know the minimal cost of a farm that is consistent with his memory. | Input: ['3', '3', '0 2 3', '2', '0 1000000000', '1', '0', ''] Output:['-3', '0', '0', ''] | [
2
] |
Vasya has an array of n integers a_1, a_2, ..., a_n. Vasya thinks that all numbers in his array are strange for some reason. To calculate how strange the i-th number is, Vasya created the following algorithm.He chooses a subsegment a_l, a_{l+1}, ..., a_r, such that 1 <= l <= i <= r <= n, sort its elements in increasing order in his head (he can arrange equal elements arbitrary). After that he finds the center of the segment. The center of a segment is the element at position (l + r) / 2, if the length of the segment is odd, and at position (l + r + 1) / 2 otherwise. Now Vasya finds the element that was at position i before the sorting, and calculates the distance between its current position and the center of the subsegment (the distance between the elements with indices j and k is |j - k|).The strangeness of the number at position i is the maximum distance among all suitable choices of l and r. Vasya wants to calculate the strangeness of each number in his array. Help him to do it. | Input: ['5', '5 4 3 2 1', ''] Output:['2 1 1 2 2 ', ''] | [
2
] |
The Alice's computer is broken, so she can't play her favorite card game now. To help Alice, Bob wants to answer n her questions. Initially, Bob holds one card with number 0 in the left hand and one in the right hand. In the i-th question, Alice asks Bob to replace a card in the left or right hand with a card with number k_i (Bob chooses which of two cards he changes, Bob must replace exactly one card).After this action, Alice wants the numbers on the left and right cards to belong to given segments (segments for left and right cards can be different). Formally, let the number on the left card be x, and on the right card be y. Then after the i-th swap the following conditions must be satisfied: a_{l, i} <= x <= b_{l, i}, and a_{r, i} <= y <= b_{r,i}.Please determine if Bob can answer all requests. If it is possible, find a way to do it. | Input: ['2 10', '3', '0 3', '0 2', '2', '0 4', '0 2', ''] Output:['Yes', '0 1 '] | [
2,
4
] |
Lena is the most economical girl in Moscow. So, when her dad asks her to buy some food for a trip to the country, she goes to the best store β "PriceFixed". Here are some rules of that store: The store has an infinite number of items of every product. All products have the same price: 2 rubles per item. For every product i there is a discount for experienced buyers: if you buy b_i items of products (of any type, not necessarily type i), then for all future purchases of the i-th product there is a 50\% discount (so you can buy an item of the i-th product for 1 ruble!). Lena needs to buy n products: she must purchase at least a_i items of the i-th product. Help Lena to calculate the minimum amount of money she needs to spend if she optimally chooses the order of purchasing. Note that if she wants, she can buy more items of some product than needed. | Input: ['3', '3 4', '1 3', '1 5', ''] Output:['8', ''] | [
2,
4
] |
There are n students numerated from 1 to n. The level of the i-th student is a_i. You need to split the students into stable groups. A group of students is called stable, if in the sorted array of their levels no two neighboring elements differ by more than x.For example, if x = 4, then the group with levels [1, 10, 8, 4, 4] is stable (because 4 - 1 <= x, 4 - 4 <= x, 8 - 4 <= x, 10 - 8 <= x), while the group with levels [2, 10, 10, 7] is not stable (7 - 2 = 5 > x).Apart from the n given students, teachers can invite at most k additional students with arbitrary levels (at teachers' choice). Find the minimum number of stable groups teachers can form from all students (including the newly invited).For example, if there are two students with levels 1 and 5; x = 2; and k >= 1, then you can invite a new student with level 3 and put all the students in one stable group. | Input: ['8 2 3', '1 1 5 8 12 13 20 22', ''] Output:['2'] | [
2
] |
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 \cdot x, and so on.Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.Determine the sum of dissatisfaction of all participants. | Input: ['4', '4 2 5', '3 1 2', '3 3 10', '2000000000 1 2000000000', ''] Output:['5', '3', '3', '1999999999000000000', ''] | [
2,
3
] |
Polycarp has x of red and y of blue candies. Using them, he wants to make gift sets. Each gift set contains either a red candies and b blue candies, or a blue candies and b red candies. Any candy can belong to at most one gift set.Help Polycarp to find the largest number of gift sets he can create.For example, if x = 10, y = 12, a = 5, and b = 2, then Polycarp can make three gift sets: In the first set there will be 5 red candies and 2 blue candies; In the second set there will be 5 blue candies and 2 red candies; In the third set will be 5 blue candies and 2 red candies. Note that in this example there is one red candy that Polycarp does not use in any gift set. | Input: ['9', '10 12 2 5', '1 1 2 2', '52 311 13 27', '1000000000 1000000000 1 1', '1000000000 1 1 1000000000', '1 1000000000 1000000000 1', '1 2 1 1', '7 8 1 2', '4 1 2 3', ''] Output:['3', '0', '4', '1000000000', '1', '1', '1', '5', '0', ''] | [
2,
3,
4,
4
] |
You are given two integers l and r, where l < r. We will add 1 to l until the result is equal to r. Thus, there will be exactly r-l additions performed. For each such addition, let's look at the number of digits that will be changed after it.For example: if l=909, then adding one will result in 910 and 2 digits will be changed; if you add one to l=9, the result will be 10 and 2 digits will also be changed; if you add one to l=489999, the result will be 490000 and 5 digits will be changed. Changed digits always form a suffix of the result written in the decimal system.Output the total number of changed digits, if you want to get r from l, adding 1 each time. | Input: ['4', '1 9', '9 10', '10 20', '1 1000000000', ''] Output:['8', '2', '11', '1111111110', ''] | [
3,
4
] |
You are given two integers a and b. In one turn, you can do one of the following operations: Take an integer c (c > 1 and a should be divisible by c) and replace a with \frac{a}{c}; Take an integer c (c > 1 and b should be divisible by c) and replace b with \frac{b}{c}. Your goal is to make a equal to b using exactly k turns.For example, the numbers a=36 and b=48 can be made equal in 4 moves: c=6, divide b by c \Rightarrow a=36, b=8; c=2, divide a by c \Rightarrow a=18, b=8; c=9, divide a by c \Rightarrow a=2, b=8; c=4, divide b by c \Rightarrow a=2, b=2. For the given numbers a and b, determine whether it is possible to make them equal using exactly k turns. | Input: ['8', '36 48 2', '36 48 3', '36 48 4', '2 8 1', '2 8 2', '1000000000 1000000000 1000000000', '1 2 1', '2 2 1', ''] Output:['YES', 'YES', 'YES', 'YES', 'YES', 'NO', 'YES', 'NO', ''] | [
3
] |
You are given an array a of n integers. Find the number of pairs (i, j) (1 <= i < j <= n) where the sum of a_i + a_j is greater than or equal to l and less than or equal to r (that is, l <= a_i + a_j <= r).For example, if n = 3, a = [5, 1, 2], l = 4 and r = 7, then two pairs are suitable: i=1 and j=2 (4 <= 5 + 1 <= 7); i=1 and j=3 (4 <= 5 + 2 <= 7). | Input: ['4', '3 4 7', '5 1 2', '5 5 8', '5 1 2 4 3', '4 100 1000', '1 1 1 1', '5 9 13', '2 5 5 1 1', ''] Output:['2', '7', '0', '1', ''] | [
3,
4
] |
Polycarp has n friends, the i-th of his friends has a_i candies. Polycarp's friends do not like when they have different numbers of candies. In other words they want all a_i to be the same. To solve this, Polycarp performs the following set of actions exactly once: Polycarp chooses k (0 <= k <= n) arbitrary friends (let's say he chooses friends with indices i_1, i_2, ..., i_k); Polycarp distributes their a_{i_1} + a_{i_2} + ... + a_{i_k} candies among all n friends. During distribution for each of a_{i_1} + a_{i_2} + ... + a_{i_k} candies he chooses new owner. That can be any of n friends. Note, that any candy can be given to the person, who has owned that candy before the distribution process. Note that the number k is not fixed in advance and can be arbitrary. Your task is to find the minimum value of k.For example, if n=4 and a=[4, 5, 2, 5], then Polycarp could make the following distribution of the candies: Polycarp chooses k=2 friends with indices i=[2, 4] and distributes a_2 + a_4 = 10 candies to make a=[4, 4, 4, 4] (two candies go to person 3). Note that in this example Polycarp cannot choose k=1 friend so that he can redistribute candies so that in the end all a_i are equal.For the data n and a, determine the minimum value k. With this value k, Polycarp should be able to select k friends and redistribute their candies so that everyone will end up with the same number of candies. | Input: ['5', '4', '4 5 2 5', '2', '0 4', '5', '10 8 5 1 4', '1', '10000', '7', '1 1 1 1 1 1 1', ''] Output:['2', '1', '-1', '0', '0', ''] | [
2,
3
] |
Polycarp is playing a new computer game. This game has n stones in a row. The stone on the position i has integer power a_i. The powers of all stones are distinct.Each turn Polycarp can destroy either stone on the first position or stone on the last position (in other words, either the leftmost or the rightmost stone). When Polycarp destroys the stone it does not exist any more.Now, Polycarp wants two achievements. He gets them if he destroys the stone with the least power and the stone with the greatest power. Help Polycarp find out what is the minimum number of moves he should make in order to achieve his goal.For example, if n = 5 and a = [1, 5, 4, 3, 2], then Polycarp could make the following moves: Destroy the leftmost stone. After this move a = [5, 4, 3, 2]; Destroy the rightmost stone. After this move a = [5, 4, 3]; Destroy the leftmost stone. After this move a = [4, 3]. Polycarp destroyed the stones with the greatest and least power, so he can end the game. Please note that in the example above, you can complete the game in two steps. For example: Destroy the leftmost stone. After this move a = [5, 4, 3, 2]; Destroy the leftmost stone. After this move a = [4, 3, 2]. Polycarp destroyed the stones with the greatest and least power, so he can end the game. | Input: ['5', '5', '1 5 4 3 2', '8', '2 1 3 4 5 6 8 7', '8', '4 2 3 1 8 6 7 5', '4', '3 4 2 1', '4', '2 3 1 4', ''] Output:['2', '4', '5', '3', '2', ''] | [
0,
2
] |
You have a connected undirected graph made of n nodes and m edges. The i-th node has a value v_i and a target value t_i.In an operation, you can choose an edge (i, j) and add k to both v_i and v_j, where k can be any integer. In particular, k can be negative.Your task to determine if it is possible that by doing some finite number of operations (possibly zero), you can achieve for every node i, v_i = t_i. | Input: ['2', '4 4', '5 1 2 -3', '3 3 10 1', '1 2', '1 4', '3 2', '3 4', '4 4', '5 8 6 6', '-3 1 15 4', '1 2', '1 4', '3 2', '3 4', ''] Output:['YES', 'NO', ''] | [
2,
3
] |
This is the hard version of the problem. The only difference is the constraints on n and k. You can make hacks only if all versions of the problem are solved.You have a string s, and you can do two types of operations on it: Delete the last character of the string. Duplicate the string: s:=s+s, where + denotes concatenation. You can use each operation any number of times (possibly none).Your task is to find the lexicographically smallest string of length exactly k that can be obtained by doing these operations on string s.A string a is lexicographically smaller than a string b if and only if one of the following holds: a is a prefix of b, but a\ne b; In the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. | Input: ['8 16', 'dbcadabc', ''] Output:['dbcadabcdbcadabc', ''] | [
2,
4
] |
This is the easy version of the problem. The only difference is the constraints on n and k. You can make hacks only if all versions of the problem are solved.You have a string s, and you can do two types of operations on it: Delete the last character of the string. Duplicate the string: s:=s+s, where + denotes concatenation. You can use each operation any number of times (possibly none).Your task is to find the lexicographically smallest string of length exactly k that can be obtained by doing these operations on string s.A string a is lexicographically smaller than a string b if and only if one of the following holds: a is a prefix of b, but a\ne b; In the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. | Input: ['8 16', 'dbcadabc', ''] Output:['dbcadabcdbcadabc', ''] | [
0,
2,
4
] |
Alice and Bob are playing a game. They start with a positive integer n and take alternating turns doing operations on it. Each turn a player can subtract from n one of its divisors that isn't 1 or n. The player who cannot make a move on his/her turn loses. Alice always moves first.Note that they subtract a divisor of the current number in each turn.You are asked to find out who will win the game if both players play optimally. | Input: ['4', '1', '4', '12', '69', ''] Output:['Bob', 'Alice', 'Alice', 'Bob', ''] | [
3
] |
You are a game designer and want to make an obstacle course. The player will walk from left to right. You have n heights of mountains already selected and want to arrange them so that the absolute difference of the heights of the first and last mountains is as small as possible. In addition, you want to make the game difficult, and since walking uphill or flat is harder than walking downhill, the difficulty of the level will be the number of mountains i (1 <=q i < n) such that h_i <=q h_{i+1} where h_i is the height of the i-th mountain. You don't want to waste any of the mountains you modelled, so you have to use all of them. From all the arrangements that minimize |h_1-h_n|, find one that is the most difficult. If there are multiple orders that satisfy these requirements, you may find any. | Input: ['2', '4', '4 2 1 2', '2', '3 1', ''] Output:['2 4 1 2 ', '1 3', ''] | [
2,
3
] |
Riley is a very bad boy, but at the same time, he is a yo-yo master. So, he decided to use his yo-yo skills to annoy his friend Anton.Anton's room can be represented as a grid with n rows and m columns. Let (i, j) denote the cell in row i and column j. Anton is currently standing at position (i, j) in his room. To annoy Anton, Riley decided to throw exactly two yo-yos in cells of the room (they can be in the same cell).Because Anton doesn't like yo-yos thrown on the floor, he has to pick up both of them and return back to the initial position. The distance travelled by Anton is the shortest path that goes through the positions of both yo-yos and returns back to (i, j) by travelling only to adjacent by side cells. That is, if he is in cell (x, y) then he can travel to the cells (x + 1, y), (x - 1, y), (x, y + 1) and (x, y - 1) in one step (if a cell with those coordinates exists).Riley is wondering where he should throw these two yo-yos so that the distance travelled by Anton is maximized. But because he is very busy, he asked you to tell him. | Input: ['7', '2 3 1 1', '4 4 1 2', '3 5 2 2', '5 1 2 1', '3 1 3 1', '1 1 1 1', '1000000000 1000000000 1000000000 50', ''] Output:['1 2 2 3', '4 1 4 4', '3 1 1 5', '5 1 1 1', '1 1 2 1', '1 1 1 1', '50 1 1 1000000000', ''] | [
2,
3
] |
An array b of length k is called good if its arithmetic mean is equal to 1. More formally, if \frac{b_1 + \cdots + b_k}{k}=1.Note that the value \frac{b_1+\cdots+b_k}{k} is not rounded up or down. For example, the array [1,1,1,2] has an arithmetic mean of 1.25, which is not equal to 1.You are given an integer array a of length n. In an operation, you can append a non-negative integer to the end of the array. What's the minimum number of operations required to make the array good?We have a proof that it is always possible with finitely many operations. | Input: ['4', '3', '1 1 1', '2', '1 2', '4', '8 4 6 2', '1', '-2', ''] Output:['0', '1', '16', '1', ''] | [
2,
3
] |
Omkar and Akmar are playing a game on a circular board with n (2 <=q n <=q 10^6) cells. The cells are numbered from 1 to n so that for each i (1 <=q i <=q n-1) cell i is adjacent to cell i+1 and cell 1 is adjacent to cell n. Initially, each cell is empty.Omkar and Akmar take turns placing either an A or a B on the board, with Akmar going first. The letter must be placed on an empty cell. In addition, the letter cannot be placed adjacent to a cell containing the same letter. A player loses when it is their turn and there are no more valid moves.Output the number of possible distinct games where both players play optimally modulo 10^9+7. Note that we only consider games where some player has lost and there are no more valid moves.Two games are considered distinct if the number of turns is different or for some turn, the letter or cell number that the letter is placed on were different.A move is considered optimal if the move maximizes the player's chance of winning, assuming the other player plays optimally as well. More formally, if the player who has to move has a winning strategy, they have to make a move after which they will still have a winning strategy. If they do not, they can make any move. | Input: ['2', ''] Output:['4', ''] | [
3
] |
Omkar's most recent follower, Ajit, has entered the Holy Forest. Ajit realizes that Omkar's forest is an n by m grid (1 <=q n, m <=q 2000) of some non-negative integers. Since the forest is blessed by Omkar, it satisfies some special conditions: For any two adjacent (sharing a side) cells, the absolute value of the difference of numbers in them is at most 1. If the number in some cell is strictly larger than 0, it should be strictly greater than the number in at least one of the cells adjacent to it. Unfortunately, Ajit is not fully worthy of Omkar's powers yet. He sees each cell as a "0" or a "#". If a cell is labeled as "0", then the number in it must equal 0. Otherwise, the number in it can be any nonnegative integer.Determine how many different assignments of elements exist such that these special conditions are satisfied. Two assignments are considered different if there exists at least one cell such that the numbers written in it in these assignments are different. Since the answer may be enormous, find the answer modulo 10^9+7. | Input: ['4', '3 4', '0000', '00#0', '0000', '2 1', '#', '#', '1 2', '##', '6 29', '#############################', '#000##0###0##0#0####0####000#', '#0#0##00#00##00####0#0###0#0#', '#0#0##0#0#0##00###00000##00##', '#000##0###0##0#0##0###0##0#0#', '#############################', ''] Output:['2', '3', '3', '319908071', ''] | [
3
] |
Uh oh! Ray lost his array yet again! However, Omkar might be able to help because he thinks he has found the OmkArray of Ray's array. The OmkArray of an array a with elements a_1, a_2, ..., a_{2k-1}, is the array b with elements b_1, b_2, ..., b_{k} such that b_i is equal to the median of a_1, a_2, ..., a_{2i-1} for all i. Omkar has found an array b of size n (1 <=q n <=q 2 \cdot 10^5, -10^9 <=q b_i <=q 10^9). Given this array b, Ray wants to test Omkar's claim and see if b actually is an OmkArray of some array a. Can you help Ray?The median of a set of numbers a_1, a_2, ..., a_{2i-1} is the number c_{i} where c_{1}, c_{2}, ..., c_{2i-1} represents a_1, a_2, ..., a_{2i-1} sorted in nondecreasing order. | Input: ['5', '4', '6 2 1 3', '1', '4', '5', '4 -8 5 6 -7', '2', '3 3', '4', '2 1 2 3', ''] Output:['NO', 'YES', 'NO', 'YES', 'YES', ''] | [
2
] |
I, Fischl, Prinzessin der Verurteilung, descend upon this land by the call of fate an β Oh, you are also a traveler from another world? Very well, I grant you permission to travel with me.It is no surprise Fischl speaks with a strange choice of words. However, this time, not even Oz, her raven friend, can interpret her expressions! Maybe you can help us understand what this young princess is saying?You are given a string of n lowercase Latin letters, the word that Fischl just spoke. You think that the MEX of this string may help you find the meaning behind this message. The MEX of the string is defined as the shortest string that doesn't appear as a contiguous substring in the input. If multiple strings exist, the lexicographically smallest one is considered the MEX. Note that the empty substring does NOT count as a valid MEX.A string a is lexicographically smaller than a string b if and only if one of the following holds: a is a prefix of b, but a!=b; in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.Find out what the MEX of the string is! | Input: ['3', '28', 'qaabzwsxedcrfvtgbyhnujmiklop', '13', 'cleanairactbd', '10', 'aannttoonn', ''] Output:['ac', 'f', 'b', ''] | [
0
] |
Omkar has received a message from Anton saying "Your story for problem A is confusing. Just make a formal statement." Because of this, Omkar gives you an array a = [a_1, a_2, ..., a_n] of n distinct integers. An array b = [b_1, b_2, ..., b_k] is called nice if for any two distinct elements b_i, b_j of b, |b_i-b_j| appears in b at least once. In addition, all elements in b must be distinct. Can you add several (maybe, 0) integers to a to create a nice array b of size at most 300? If a is already nice, you don't have to add any elements.For example, array [3, 6, 9] is nice, as |6-3|=|9-6| = 3, which appears in the array, and |9-3| = 6, which appears in the array, while array [4, 2, 0, 6, 9] is not nice, as |9-4| = 5 is not present in the array.For integers x and y, |x-y| = x-y if x > y and |x-y| = y-x otherwise. | Input: ['4', '3', '3 0 9', '2', '3 4', '5', '-7 3 13 -2 8', '4', '4 8 12 6', ''] Output:['yes', '4', '6 0 3 9', 'yEs', '5', '5 3 1 2 4', 'NO', 'Yes', '6', '8 12 6 2 4 10', ''] | [
0
] |
Suppose you are given two strings a and b. You can apply the following operation any number of times: choose any contiguous substring of a or b, and sort the characters in it in non-descending order. Let f(a, b) the minimum number of operations you have to apply in order to make them equal (or f(a, b) = 1337 if it is impossible to make a and b equal using these operations).For example: f(\text{ab}, \text{ab}) = 0; f(\text{ba}, \text{ab}) = 1 (in one operation, we can sort the whole first string); f(\text{ebcda}, \text{ecdba}) = 1 (in one operation, we can sort the substring of the second string starting from the 2-nd character and ending with the 4-th character); f(\text{a}, \text{b}) = 1337. You are given n strings s_1, s_2, ..., s_k having equal length. Calculate \sum \limits_{i = 1}^{n} \sum\limits_{j = i + 1}^{n} f(s_i, s_j). | Input: ['4', 'zzz', 'bac', 'abc', 'acb', ''] Output:['4015', ''] | [
0,
4
] |
You are given a rooted tree. Each vertex contains a_i tons of gold, which costs c_i per one ton. Initially, the tree consists only a root numbered 0 with a_0 tons of gold and price c_0 per ton.There are q queries. Each query has one of two types: Add vertex i (where i is an index of query) as a son to some vertex p_i; vertex i will have a_i tons of gold with c_i per ton. It's guaranteed that c_i > c_{p_i}. For a given vertex v_i consider the simple path from v_i to the root. We need to purchase w_i tons of gold from vertices on this path, spending the minimum amount of money. If there isn't enough gold on the path, we buy all we can. If we buy x tons of gold in some vertex v the remaining amount of gold in it decreases by x (of course, we can't buy more gold that vertex has at the moment). For each query of the second type, calculate the resulting amount of gold we bought and the amount of money we should spend.Note that you should solve the problem in online mode. It means that you can't read the whole input at once. You can read each query only after writing the answer for the last query, so don't forget to flush output after printing answers. You can use functions like fflush(stdout) in C++ and BufferedWriter.flush in Java or similar after each writing in your program. In standard (if you don't tweak I/O), endl flushes cout in C++ and System.out.println in Java (or println in Kotlin) makes automatic flush as well. | Input: ['5 5 2', '2 0 2', '1 0 3 4', '2 2 4', '1 0 1 3', '2 4 2', ''] Output:['2 4', '4 10', '1 3', ''] | [
2,
4
] |
You are given a string s consisting of the characters 0, 1, and ?.Let's call a string unstable if it consists of the characters 0 and 1 and any two adjacent characters are different (i. e. it has the form 010101... or 101010...).Let's call a string beautiful if it consists of the characters 0, 1, and ?, and you can replace the characters ? to 0 or 1 (for each character, the choice is independent), so that the string becomes unstable.For example, the strings 0??10, 0, and ??? are beautiful, and the strings 00 and ?1??1 are not.Calculate the number of beautiful contiguous substrings of the string s. | Input: ['3', '0?10', '???', '?10??1100', ''] Output:['8', '6', '25', ''] | [
2,
4
] |
You are given an array a consisting of n integers.Let's call a pair of indices i, j good if 1 <= i < j <= n and \gcd(a_i, 2a_j) > 1 (where \gcd(x, y) is the greatest common divisor of x and y).Find the maximum number of good index pairs if you can reorder the array a in an arbitrary way. | Input: ['3', '4', '3 6 5 3', '2', '1 7', '5', '1 4 2 4 1', ''] Output:['4', '0', '9', ''] | [
0,
2,
3
] |
Four players participate in the playoff tournament. The tournament is held according to the following scheme: the first player will play with the second, and the third player with the fourth, then the winners of the pairs will play in the finals of the tournament.It is known that in a match between two players, the one whose skill is greater will win. The skill of the i-th player is equal to s_i and all skill levels are pairwise different (i.βe. there are no two identical values in the array s).The tournament is called fair if the two players with the highest skills meet in the finals.Determine whether the given tournament is fair. | Input: ['4', '3 7 9 5', '4 5 6 9', '5 3 8 1', '6 5 3 2', ''] Output:['YES', 'NO', 'YES', 'NO', ''] | [
0
] |
This is the hard version of the problem. The difference between the versions is the constraints on a_i. You can make hacks only if all versions of the problem are solved.Little Dormi has recently received a puzzle from his friend and needs your help to solve it. The puzzle consists of an upright board with n rows and m columns of cells, some empty and some filled with blocks of sand, and m non-negative integers a_1,a_2,...,a_m (0 <=q a_i <=q n). In this version of the problem, a_i will always be not greater than the number of blocks of sand in column i.When a cell filled with a block of sand is disturbed, the block of sand will fall from its cell to the sand counter at the bottom of the column (each column has a sand counter). While a block of sand is falling, other blocks of sand that are adjacent at any point to the falling block of sand will also be disturbed and start to fall. Specifically, a block of sand disturbed at a cell (i,j) will pass through all cells below and including the cell (i,j) within the column, disturbing all adjacent cells along the way. Here, the cells adjacent to a cell (i,j) are defined as (i-1,j), (i,j-1), (i+1,j), and (i,j+1) (if they are within the grid). Note that the newly falling blocks can disturb other blocks.In one operation you are able to disturb any piece of sand. The puzzle is solved when there are at least a_i blocks of sand counted in the i-th sand counter for each column from 1 to m.You are now tasked with finding the minimum amount of operations in order to solve the puzzle. Note that Little Dormi will never give you a puzzle that is impossible to solve. | Input: ['5 7', '#....#.', '.#.#...', '#....#.', '#....##', '#.#....', '4 1 1 1 0 3 1', ''] Output:['3', ''] | [
2
] |
This is the easy version of the problem. The difference between the versions is the constraints on a_i. You can make hacks only if all versions of the problem are solved.Little Dormi has recently received a puzzle from his friend and needs your help to solve it. The puzzle consists of an upright board with n rows and m columns of cells, some empty and some filled with blocks of sand, and m non-negative integers a_1,a_2,...,a_m (0 <=q a_i <=q n). In this version of the problem, a_i will be equal to the number of blocks of sand in column i.When a cell filled with a block of sand is disturbed, the block of sand will fall from its cell to the sand counter at the bottom of the column (each column has a sand counter). While a block of sand is falling, other blocks of sand that are adjacent at any point to the falling block of sand will also be disturbed and start to fall. Specifically, a block of sand disturbed at a cell (i,j) will pass through all cells below and including the cell (i,j) within the column, disturbing all adjacent cells along the way. Here, the cells adjacent to a cell (i,j) are defined as (i-1,j), (i,j-1), (i+1,j), and (i,j+1) (if they are within the grid). Note that the newly falling blocks can disturb other blocks.In one operation you are able to disturb any piece of sand. The puzzle is solved when there are at least a_i blocks of sand counted in the i-th sand counter for each column from 1 to m.You are now tasked with finding the minimum amount of operations in order to solve the puzzle. Note that Little Dormi will never give you a puzzle that is impossible to solve. | Input: ['5 7', '#....#.', '.#.#...', '#....#.', '#....##', '#.#....', '4 1 1 1 0 3 1', ''] Output:['3', ''] | [
2
] |
This is an interactive problem.Note: the XOR-sum of an array a_1, a_2, ..., a_n (1 <= a_i <= 10^9) is defined as a_1 \oplus a_2 \oplus ... \oplus a_n, where \oplus denotes the bitwise XOR operation.Little Dormi received an array of n integers a_1, a_2, ..., a_n for Christmas. However, while playing with it over the winter break, he accidentally dropped it into his XOR machine, and the array got lost.The XOR machine is currently configured with a query size of k (which you cannot change), and allows you to perform the following type of query: by giving the machine k distinct indices x_1, x_2, ..., x_k, it will output a_{x_1} \oplus a_{x_2} \oplus ... \oplus a_{x_k}.As Little Dormi's older brother, you would like to help him recover the XOR-sum of his array a_1, a_2, ..., a_n by querying the XOR machine.Little Dormi isn't very patient, so to be as fast as possible, you must query the XOR machine the minimum number of times to find the XOR-sum of his array. Formally, let d be the minimum number of queries needed to find the XOR-sum of any array of length n with a query size of k. Your program will be accepted if you find the correct XOR-sum in at most d queries.Lastly, you also noticed that with certain configurations of the machine k and values of n, it may not be possible to recover the XOR-sum of Little Dormi's lost array. If that is the case, you should report it as well.The array a_1, a_2, ..., a_n is fixed before you start querying the XOR machine and does not change with the queries. | Input: ['5 3', '', '4', '', '0', '', '1', ''] Output:['? 1 2 3', '', '? 2 3 5', '', '? 4 1 5', '', '! 7', ''] | [
2
] |
When he's not training for IOI, Little Alawn enjoys playing with puzzles of various types to stimulate his brain. Today, he's playing with a puzzle that consists of a 2 * n grid where each row is a permutation of the numbers 1,2,3,...,n.The goal of Little Alawn's puzzle is to make sure no numbers on the same column or row are the same (we'll call this state of the puzzle as solved), and to achieve this he is able to swap the numbers in any column. However, after solving the puzzle many times, Little Alawn got bored and began wondering about the number of possible solved configurations of the puzzle he could achieve from an initial solved configuration only by swapping numbers in a column.Unfortunately, Little Alawn got stuck while trying to solve this harder problem, so he was wondering if you could help him with it. Find the answer modulo 10^9+7. | Input: ['2', '4', '1 4 2 3', '3 2 1 4', '8', '2 6 5 1 4 3 7 8', '3 8 7 5 1 2 4 6', ''] Output:['2', '8', ''] | [
3
] |
Little Dormi received a histogram with n bars of height a_1, a_2, ..., a_n for Christmas. However, the more he played with his new histogram, the more he realized its imperfections, so today he wanted to modify it to his liking.To modify the histogram, Little Dormi is able to perform the following operation an arbitrary number of times: Select an index i (1 <= i <= n) where a_i>0, and assign a_i := a_i-1.Little Dormi defines the ugliness score of his histogram (after performing some number of operations) as the sum of the vertical length of its outline and the number of operations he performed on it. And to make the histogram as perfect as possible, he would like to minimize the ugliness score after modifying it with some number of operations.However, as his histogram is very large, Little Dormi is having trouble minimizing the ugliness score, so as Little Dormi's older brother, help him find the minimal ugliness.Consider the following example where the histogram has 4 columns of heights 4,8,9,6: The blue region represents the histogram, and the red lines represent the vertical portion of the outline. Currently, the vertical length of the outline is 4+4+1+3+6 = 18, so if Little Dormi does not modify the histogram at all, the ugliness would be 18.However, Little Dormi can apply the operation once on column 2 and twice on column 3, resulting in a histogram with heights 4,7,7,6: Now, as the total vertical length of the outline (red lines) is 4+3+1+6=14, the ugliness is 14+3=17 dollars. It can be proven that this is optimal. | Input: ['2', '4', '4 8 9 6', '6', '2 1 7 4 0 0', ''] Output:['17', '12', ''] | [
2,
3
] |
Today we will be playing a red and white colouring game (no, this is not the Russian Civil War; these are just the colours of the Canadian flag).You are given an n * m grid of "R", "W", and "." characters. "R" is red, "W" is white and "." is blank. The neighbours of a cell are those that share an edge with it (those that only share a corner do not count).Your job is to colour the blank cells red or white so that every red cell only has white neighbours (and no red ones) and every white cell only has red neighbours (and no white ones). You are not allowed to recolour already coloured cells. | Input: ['3', '4 6', '.R....', '......', '......', '.W....', '4 4', '.R.W', '....', '....', '....', '5 1', 'R', 'W', 'R', 'W', 'R', ''] Output:['YES', 'WRWRWR', 'RWRWRW', 'WRWRWR', 'RWRWRW', 'NO', 'YES', 'R', 'W', 'R', 'W', 'R', ''] | [
0
] |
Let's call a string t consisting of characters 0 and/or 1 beautiful, if either the number of occurrences of character 0 in this string does not exceed k, or the number of occurrences of characters 1 in this string does not exceed k (or both). For example, if k = 3, the strings 101010, 111, 0, 00000, 1111111000 are beautiful, and the strings 1111110000, 01010101 are not beautiful.You are given a string s. You have to divide it into the minimum possible number of beautiful strings, i.βe., find a sequence of strings t_1, t_2, ..., t_m such that every t_i is beautiful, t_1 + t_2 + ... + t_m = s (where + is the concatenation operator), and m is minimum possible.For every k from 1 to |s|, find the minimum possible number of strings such that s can be divided into them (i.βe. the minimum possible m in the partition). | Input: ['00100010', ''] Output:['2 1 1 1 1 1 1 1', ''] | [
2,
4
] |
Polycarp is coaching a team for an upcoming game at the chess tournament. A complete team for the tournament should consist of n+1 members.There are n members in his team, the i-th member's skill value is a_i. Polycarp is yet to choose the final member for the team.The opposing team has n+1 members, the j-th member's skill value is b_j.Polycarp has m options for the final player of the team. The k-th of them has a skill value c_k.Before the game starts, Polycarp pairs up the members of his team with the members of the opposing team. Every member of both teams is in exactly one pair. The difficulty of a game for a certain player is the difference between his paired opponent's skill and his own skill. So if the i-th player of the Polycarp's team is paired up with the j-th member of the opposing team, then the difficulty is equal to b_j - a_i. The difficulty of the game for a team is the maximum difficulty of all its players.So, before the game starts, Polycarp wants to pair up the players in such a way that the difficulty of the game for his team is minimized.For each of the m options for the final player print the smallest difficulty of the game for the team Polycarp can achieve. | Input: ['5', '10 3 4 6 1', '9 4 2 5 9 8', '5', '1 7 6 4 8', ''] Output:['4 2 3 4 2', ''] | [
2,
4
] |
Vika has decided to go on a trip to Bertown. She comes to Bertown on the k-th day. Vika does not want to spend money on hotels, fortunately she has n friends who live in Bertown and allow Vika to stay at their houses. The i-th friend told Vika that she could stay at their house from the l_i-th day till the r_i-th day, inclusive.Vika decided that she would stay at no more than one friend's house. Help Vika determine the maximum number of days that she will be able to stay in Bertown. | Input: ['3', '3 3', '1 4', '2 6', '4 10', '2 4', '2 3', '5 8', '2 4', '4 4', '1 3', ''] Output:['4', '0', '1', ''] | [
3
] |
A frog is currently at the point 0 on a coordinate axis Ox. It jumps by the following algorithm: the first jump is a units to the right, the second jump is b units to the left, the third jump is a units to the right, the fourth jump is b units to the left, and so on.Formally: if the frog has jumped an even number of times (before the current jump), it jumps from its current position x to position x+a; otherwise it jumps from its current position x to position x-b. Your task is to calculate the position of the frog after k jumps.But... One more thing. You are watching t different frogs so you have to answer t independent queries. | Input: ['6', '5 2 3', '100 1 4', '1 10 5', '1000000000 1 6', '1 1 1000000000', '1 1 999999999', ''] Output:['8', '198', '-17', '2999999997', '0', '1', ''] | [
3
] |
Π Π°ΡΡΠΌΠΎΡΡΠΈΠΌ ΡΠ»Π΅Π΄ΡΡΡΠΈΠΉ ΠΊΠΎΠ΄ ΡΠΎΡΡΠΈΡΠΎΠ²ΠΊΠΈ ΡΠ»ΠΈΡΠ½ΠΈΠ΅ΠΌ Π½Π° ΡΠ·ΡΠΊΠ΅ Python: def sort(a): n = len(a) b = [0 for i in range(n)] log = [] def mergeSort(l, r): if r - l <= 1: return m = (l + r) >> 1 mergeSort(l, m) mergeSort(m, r) i, j, k = l, m, l while i < m and j < r: if a[i] < a[j]: log.append('0') b[k] = a[i] i += 1 else: log.append('1') b[k] = a[j] j += 1 k += 1 while i < m: b[k] = a[i] i += 1 k += 1 while j < r: b[k] = a[j] j += 1 k += 1 for p in range(l, r): a[p] = b[p] mergeSort(0, n) return "".join(log)ΠΠ°ΠΊ ΠΌΠΎΠΆΠ½ΠΎ Π·Π°ΠΌΠ΅ΡΠΈΡΡ, ΡΡΠΎΡ ΠΊΠΎΠ΄ ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅Ρ Π»ΠΎΠ³ΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ β Π²Π°ΠΆΠ½Π΅ΠΉΡΠΈΠΉ ΠΈΠ½ΡΡΡΡΠΌΠ΅Π½Ρ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠΊΠΈ.Π‘ΡΠ°ΡΡΠΈΠΉ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊ ΠΠΠΎΠ½ΡΠ°ΠΊΡΠ΅ ΠΠ°ΡΡ ΡΠ³Π΅Π½Π΅ΡΠΈΡΠΎΠ²Π°Π» ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΡ a (ΠΌΠ°ΡΡΠΈΠ² ΠΈΠ· n ΡΠ°Π·Π»ΠΈΡΠ½ΡΡ
ΡΠ΅Π»ΡΡ
ΡΠΈΡΠ΅Π» ΠΎΡ 1 Π΄ΠΎ n), Π΄Π°Π» Π΅Ρ Π½Π° Π²Ρ
ΠΎΠ΄ ΡΡΠ½ΠΊΡΠΈΠΈ sort ΠΈ ΠΏΠΎΠ»ΡΡΠΈΠ» Π½Π° Π²ΡΡ
ΠΎΠ΄Π΅ ΡΡΡΠΎΠΊΡ s. ΠΠ° ΡΠ»Π΅Π΄ΡΡΡΠΈΠΉ Π΄Π΅Π½Ρ ΡΡΡΠΎΠΊΡ s ΠΠ°ΡΡ Π½Π°ΡΡΠ», Π° ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΠ° a ΠΏΠΎΡΠ΅ΡΡΠ»Π°ΡΡ. ΠΠ°ΡΡ Ρ
ΠΎΡΠ΅Ρ Π²ΠΎΡΡΡΠ°Π½ΠΎΠ²ΠΈΡΡ Π»ΡΠ±ΡΡ ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΡ a ΡΠ°ΠΊΡΡ, ΡΡΠΎ Π²ΡΠ·ΠΎΠ² ΡΡΠ½ΠΊΡΠΈΠΈ sort ΠΎΡ Π½Π΅Ρ Π΄Π°ΡΡ ΡΡ ΠΆΠ΅ ΡΡΡΠΎΠΊΡ s. ΠΠΎΠΌΠΎΠ³ΠΈΡΠ΅ Π΅ΠΌΡ! | Input: ['00000000000000000000000000000000', ''] Output:['16', '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16', ''] | [
4
] |
Π Π°ΡΡΠΌΠΎΡΡΠΈΠΌ ΡΠ»Π΅Π΄ΡΡΡΠΈΠΉ ΠΊΠΎΠ΄ ΡΠΎΡΡΠΈΡΠΎΠ²ΠΊΠΈ ΡΠ»ΠΈΡΠ½ΠΈΠ΅ΠΌ Π½Π° ΡΠ·ΡΠΊΠ΅ Python: def sort(a): n = len(a) b = [0 for i in range(n)] log = [] def mergeSort(l, r): if r - l <= 1: return m = (l + r) >> 1 mergeSort(l, m) mergeSort(m, r) i, j, k = l, m, l while i < m and j < r: if a[i] < a[j]: log.append('0') b[k] = a[i] i += 1 else: log.append('1') b[k] = a[j] j += 1 k += 1 while i < m: b[k] = a[i] i += 1 k += 1 while j < r: b[k] = a[j] j += 1 k += 1 for p in range(l, r): a[p] = b[p] mergeSort(0, n) return "".join(log)ΠΠ°ΠΊ ΠΌΠΎΠΆΠ½ΠΎ Π·Π°ΠΌΠ΅ΡΠΈΡΡ, ΡΡΠΎΡ ΠΊΠΎΠ΄ ΠΈΡΠΏΠΎΠ»ΡΠ·ΡΠ΅Ρ Π»ΠΎΠ³ΠΈΡΠΎΠ²Π°Π½ΠΈΠ΅ β Π²Π°ΠΆΠ½Π΅ΠΉΡΠΈΠΉ ΠΈΠ½ΡΡΡΡΠΌΠ΅Π½Ρ ΡΠ°Π·ΡΠ°Π±ΠΎΡΠΊΠΈ.Π‘ΡΠ°ΡΡΠΈΠΉ ΡΠ°Π·ΡΠ°Π±ΠΎΡΡΠΈΠΊ ΠΠΠΎΠ½ΡΠ°ΠΊΡΠ΅ ΠΠ°ΡΡ ΡΠ³Π΅Π½Π΅ΡΠΈΡΠΎΠ²Π°Π» ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΡ a (ΠΌΠ°ΡΡΠΈΠ² ΠΈΠ· n ΡΠ°Π·Π»ΠΈΡΠ½ΡΡ
ΡΠ΅Π»ΡΡ
ΡΠΈΡΠ΅Π» ΠΎΡ 1 Π΄ΠΎ n), Π΄Π°Π» Π΅Ρ Π½Π° Π²Ρ
ΠΎΠ΄ ΡΡΠ½ΠΊΡΠΈΠΈ sort ΠΈ ΠΏΠΎΠ»ΡΡΠΈΠ» Π½Π° Π²ΡΡ
ΠΎΠ΄Π΅ ΡΡΡΠΎΠΊΡ s. ΠΠ° ΡΠ»Π΅Π΄ΡΡΡΠΈΠΉ Π΄Π΅Π½Ρ ΡΡΡΠΎΠΊΡ s ΠΠ°ΡΡ Π½Π°ΡΡΠ», Π° ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΠ° a ΠΏΠΎΡΠ΅ΡΡΠ»Π°ΡΡ. ΠΠ°ΡΡ Ρ
ΠΎΡΠ΅Ρ Π²ΠΎΡΡΡΠ°Π½ΠΎΠ²ΠΈΡΡ Π»ΡΠ±ΡΡ ΠΏΠ΅ΡΠ΅ΡΡΠ°Π½ΠΎΠ²ΠΊΡ a ΡΠ°ΠΊΡΡ, ΡΡΠΎ Π²ΡΠ·ΠΎΠ² ΡΡΠ½ΠΊΡΠΈΠΈ sort ΠΎΡ Π½Π΅Ρ Π΄Π°ΡΡ ΡΡ ΠΆΠ΅ ΡΡΡΠΎΠΊΡ s. ΠΠΎΠΌΠΎΠ³ΠΈΡΠ΅ Π΅ΠΌΡ! | Input: ['00000000000000000000000000000000', ''] Output:['16', '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16', ''] | [
0
] |
Getting ready for VK Fest 2021, you prepared a table with n rows and n columns, and filled each cell of this table with some event related with the festival that could either happen or not: for example, whether you will win a prize on the festival, or whether it will rain.Forecasting algorithms used in VK have already estimated the probability for each event to happen. Event in row i and column j will happen with probability a_{i, j} \cdot 10^{-4}. All of the events are mutually independent.Let's call the table winning if there exists a line such that all n events on it happen. The line could be any horizontal line (cells (i, 1), (i, 2), ..., (i, n) for some i), any vertical line (cells (1, j), (2, j), ..., (n, j) for some j), the main diagonal (cells (1, 1), (2, 2), ..., (n, n)), or the antidiagonal (cells (1, n), (2, n - 1), ..., (n, 1)).Find the probability of your table to be winning, and output it modulo 31\,607 (see Output section). | Input: ['2', '5000 5000', '5000 5000', ''] Output:['5927', ''] | [
3
] |
Prefix function of string t = t_1 t_2 ... t_n and position i in it is defined as the length k of the longest proper (not equal to the whole substring) prefix of substring t_1 t_2 ... t_i which is also a suffix of the same substring.For example, for string t = abacaba the values of the prefix function in positions 1, 2, ..., 7 are equal to [0, 0, 1, 0, 1, 2, 3].Let f(t) be equal to the maximum value of the prefix function of string t over all its positions. For example, f(abacaba) = 3.You are given a string s. Reorder its characters arbitrarily to get a string t (the number of occurrences of any character in strings s and t must be equal). The value of f(t) must be minimized. Out of all options to minimize f(t), choose the one where string t is the lexicographically smallest. | Input: ['3', 'vkcup', 'abababa', 'zzzzzz', ''] Output:['ckpuv', 'aababab', 'zzzzzz', ''] | [
2
] |
Every December, VK traditionally holds an event for its employees named "Secret Santa". Here's how it happens.n employees numbered from 1 to n take part in the event. Each employee i is assigned a different employee b_i, to which employee i has to make a new year gift. Each employee is assigned to exactly one other employee, and nobody is assigned to themselves (but two employees may be assigned to each other). Formally, all b_i must be distinct integers between 1 and n, and for any i, b_i!=i must hold.The assignment is usually generated randomly. This year, as an experiment, all event participants have been asked who they wish to make a gift to. Each employee i has said that they wish to make a gift to employee a_i.Find a valid assignment b that maximizes the number of fulfilled wishes of the employees. | Input: ['2', '3', '2 1 2', '7', '6 4 6 2 4 5 6', ''] Output:['2', '3 1 2', '4', '6 4 7 2 3 5 1', ''] | [
2,
3
] |
You and your friend Ilya are participating in an individual programming contest consisting of multiple stages. A contestant can get between 0 and 100 points, inclusive, for each stage, independently of other contestants.Points received by contestants in different stages are used for forming overall contest results. Suppose that k stages of the contest are completed. For each contestant, k - \lfloor \frac{k}{4} \rfloor stages with the highest scores are selected, and these scores are added up. This sum is the overall result of the contestant. (Here \lfloor t \rfloor denotes rounding t down.)For example, suppose 9 stages are completed, and your scores are 50, 30, 50, 50, 100, 10, 30, 100, 50. First, 7 stages with the highest scores are chosen β for example, all stages except for the 2-nd and the 6-th can be chosen. Then your overall result is equal to 50 + 50 + 50 + 100 + 30 + 100 + 50 = 430.As of now, n stages are completed, and you know the points you and Ilya got for these stages. However, it is unknown how many more stages will be held. You wonder what the smallest number of additional stages is, after which your result might become greater than or equal to Ilya's result, at least in theory. Find this number! | Input: ['5', '1', '100', '0', '1', '0', '100', '4', '20 30 40 50', '100 100 100 100', '4', '10 20 30 40', '100 100 100 100', '7', '7 59 62 52 27 31 55', '33 35 50 98 83 80 64', ''] Output:['0', '1', '3', '4', '2', ''] | [
0,
2,
4
] |
Let's call a number a binary decimal if it's a positive integer and all digits in its decimal notation are either 0 or 1. For example, 1\,010\,111 is a binary decimal, while 10\,201 and 787\,788 are not.Given a number n, you are asked to represent n as a sum of some (not necessarily distinct) binary decimals. Compute the smallest number of binary decimals required for that. | Input: ['3', '121', '5', '1000000000', ''] Output:['2', '5', '1', ''] | [
2,
3
] |
A sequence (b_1, b_2, ..., b_k) is called strange, if the absolute difference between any pair of its elements is greater than or equal to the maximum element in the sequence. Formally speaking, it's strange if for every pair (i, j) with 1 <= i<j <= k, we have |a_i-a_j|>=q MAX, where MAX is the largest element of the sequence. In particular, any sequence of length at most 1 is strange.For example, the sequences (-2021, -1, -1, -1) and (-1, 0, 1) are strange, but (3, 0, 1) is not, because |0 - 1| < 3.Sifid has an array a of n integers. Sifid likes everything big, so among all the strange subsequences of a, he wants to find the length of the longest one. Can you help him?A sequence c is a subsequence of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements. | Input: ['6', '4', '-1 -2 0 0', '7', '-3 4 -2 0 -4 6 1', '5', '0 5 -3 2 -5', '3', '2 3 1', '4', '-3 0 2 0', '6', '-3 -2 -1 1 1 1', ''] Output:['4', '5', '4', '1', '3', '4', ''] | [
2,
3
] |
Eshag has an array a consisting of n integers.Eshag can perform the following operation any number of times: choose some subsequence of a and delete every element from it which is strictly larger than AVG, where AVG is the average of the numbers in the chosen subsequence.For example, if a = [1 , 4 , 3 , 2 , 4] and Eshag applies the operation to the subsequence containing a_1, a_2, a_4 and a_5, then he will delete those of these 4 elements which are larger than \frac{a_1+a_2+a_4+a_5}{4} = \frac{11}{4}, so after the operation, the array a will become a = [1 , 3 , 2].Your task is to find the maximum number of elements Eshag can delete from the array a by applying the operation described above some number (maybe, zero) times.A sequence b is a subsequence of an array c if b can be obtained from c by deletion of several (possibly, zero or all) elements. | Input: ['3', '6', '1 1 1 2 2 3', '6', '9 9 9 9 9 9', '6', '6 4 1 1 4 1', ''] Output:['3', '0', '3', ''] | [
2,
3
] |
To AmShZ, all arrays are equal, but some arrays are more-equal than others. Specifically, the arrays consisting of n elements from 1 to n that can be turned into permutations of numbers from 1 to n by adding a non-negative integer to each element.Mashtali who wants to appear in every problem statement thinks that an array b consisting of k elements is compatible with a more-equal array a consisting of n elements if for each 1 <= i <= k we have 1 <= b_i <= n and also a_{b_1} = a_{b_2} = ... = a_{b_k}.Find the number of pairs of arrays a and b such that a is a more-equal array consisting of n elements and b is an array compatible with a consisting of k elements modulo 998244353.Note that the elements of b are not necessarily distinct, same holds for a. | Input: ['1 1', ''] Output:['1', ''] | [
3
] |
Soroush and Keshi each have a labeled and rooted tree on n vertices. Both of their trees are rooted from vertex 1.Soroush and Keshi used to be at war. After endless decades of fighting, they finally became allies to prepare a Codeforces round. To celebrate this fortunate event, they decided to make a memorial graph on n vertices.They add an edge between vertices u and v in the memorial graph if both of the following conditions hold: One of u or v is the ancestor of the other in Soroush's tree. Neither of u or v is the ancestor of the other in Keshi's tree. Here vertex u is considered ancestor of vertex v, if u lies on the path from 1 (the root) to the v.Popping out of nowhere, Mashtali tried to find the maximum clique in the memorial graph for no reason. He failed because the graph was too big. Help Mashtali by finding the size of the maximum clique in the memorial graph.As a reminder, clique is a subset of vertices of the graph, each two of which are connected by an edge. | Input: ['4', '4', '1 2 3', '1 2 3', '5', '1 2 3 4', '1 1 1 1', '6', '1 1 1 1 2', '1 2 1 2 2', '7', '1 1 3 4 4 5', '1 2 1 4 2 5', ''] Output:['1', '4', '1', '3', ''] | [
2
] |
Kavi has 2n points lying on the OX axis, i-th of which is located at x = i.Kavi considers all ways to split these 2n points into n pairs. Among those, he is interested in good pairings, which are defined as follows:Consider n segments with ends at the points in correspondent pairs. The pairing is called good, if for every 2 different segments A and B among those, at least one of the following holds: One of the segments A and B lies completely inside the other. A and B have the same length. Consider the following example: A is a good pairing since the red segment lies completely inside the blue segment.B is a good pairing since the red and the blue segment have the same length.C is not a good pairing since none of the red or blue segments lies inside the other, neither do they have the same size.Kavi is interested in the number of good pairings, so he wants you to find it for him. As the result can be large, find this number modulo 998244353.Two pairings are called different, if some two points are in one pair in some pairing and in different pairs in another. | Input: ['1', ''] Output:['1'] | [
3
] |
Parsa has a humongous tree on n vertices.On each vertex v he has written two integers l_v and r_v.To make Parsa's tree look even more majestic, Nima wants to assign a number a_v (l_v <= a_v <= r_v) to each vertex v such that the beauty of Parsa's tree is maximized.Nima's sense of the beauty is rather bizarre. He defines the beauty of the tree as the sum of |a_u - a_v| over all edges (u, v) of the tree.Since Parsa's tree is too large, Nima can't maximize its beauty on his own. Your task is to find the maximum possible beauty for Parsa's tree. | Input: ['3', '2', '1 6', '3 8', '1 2', '3', '1 3', '4 6', '7 9', '1 2', '2 3', '6', '3 14', '12 20', '12 19', '2 12', '10 17', '3 17', '3 2', '6 5', '1 5', '2 6', '4 6', ''] Output:['7', '8', '62', ''] | [
2
] |
You are given an array a of n integers. Define the cost of some array t as follows:cost(t) = \sum_{x \in set(t) } last(x) - first(x), where set(t) is the set of all values in t without repetitions, first(x), and last(x) are the indices of the first and last occurrence of x in t, respectively. In other words, we compute the distance between the first and last occurrences for each distinct element and sum them up.You need to split the array a into k consecutive segments such that each element of a belongs to exactly one segment and the sum of the cost of individual segments is minimum. | Input: ['7 2', '1 6 6 4 6 6 6', ''] Output:['3', ''] | [
4
] |
You are given a tree with n nodes, numerated from 0 to n-1. For each k between 0 and n, inclusive, you have to count the number of unordered pairs (u,v), u \neq v, such that the MEX of all the node labels in the shortest path from u to v (including end points) is k.The MEX of a sequence of integers is the smallest non-negative integer that does not belong to the sequence. | Input: ['2', '4', '0 1', '0 2', '2 3', '2', '1 0', ''] Output:['1 2 1 1 1 ', '0 0 1 ', ''] | [
3
] |
The weight of a sequence is defined as the number of unordered pairs of indexes (i,j) (here i \lt j) with same value (a_{i} = a_{j}). For example, the weight of sequence a = [1, 1, 2, 2, 1] is 4. The set of unordered pairs of indexes with same value are (1, 2), (1, 5), (2, 5), and (3, 4).You are given a sequence a of n integers. Print the sum of the weight of all subsegments of a. A sequence b is a subsegment of a sequence a if b can be obtained from a by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end. | Input: ['2', '4', '1 2 1 1', '4', '1 2 3 4', ''] Output:['6', '0', ''] | [
3
] |
Once upon a time, Oolimry saw a suffix array. He wondered how many strings can produce this suffix array. More formally, given a suffix array of length n and having an alphabet size k, count the number of strings that produce such a suffix array. Let s be a string of length n. Then the i-th suffix of s is the substring s[i ... n-1]. A suffix array is the array of integers that represent the starting indexes of all the suffixes of a given string, after the suffixes are sorted in the lexicographic order. For example, the suffix array of oolimry is [3,2,4,1,0,5,6] as the array of sorted suffixes is [\texttt{imry},\texttt{limry},\texttt{mry},\texttt{olimry},\texttt{oolimry},\texttt{ry},\texttt{y}]. A string x is lexicographically smaller than string y, if either x is a prefix of y (and x\neq y), or there exists such i that x_i < y_i, and for any 1<=q j < i , x_j = y_j. | Input: ['3 2', '0 2 1', ''] Output:['1'] | [
3
] |
After rejecting 10^{100} data structure problems, Errorgorn is very angry at Anton and decided to kill him.Anton's DNA can be represented as a string a which only contains the characters "ANTON" (there are only 4 distinct characters). Errorgorn can change Anton's DNA into string b which must be a permutation of a. However, Anton's body can defend against this attack. In 1 second, his body can swap 2 adjacent characters of his DNA to transform it back to a. Anton's body is smart and will use the minimum number of moves.To maximize the chance of Anton dying, Errorgorn wants to change Anton's DNA the string that maximizes the time for Anton's body to revert his DNA. But since Errorgorn is busy making more data structure problems, he needs your help to find the best string B. Can you help him? | Input: ['4', 'ANTON', 'NAAN', 'AAAAAA', 'OAANTTON', ''] Output:['NNOTA', 'AANN', 'AAAAAA', 'TNNTAOOA', ''] | [
0,
3
] |
This is the hard version of the problem. The only difference is that in this version n <=q 200000. You can make hacks only if both versions of the problem are solved.There are n potions in a line, with potion 1 on the far left and potion n on the far right. Each potion will increase your health by a_i when drunk. a_i can be negative, meaning that potion will decrease will health.You start with 0 health and you will walk from left to right, from first potion to the last one. At each potion, you may choose to drink it or ignore it. You must ensure that your health is always non-negative.What is the largest number of potions you can drink? | Input: ['6', '4 -4 1 -3 1 -3', ''] Output:['5'] | [
2
] |
This is the easy version of the problem. The only difference is that in this version n <=q 2000. You can make hacks only if both versions of the problem are solved.There are n potions in a line, with potion 1 on the far left and potion n on the far right. Each potion will increase your health by a_i when drunk. a_i can be negative, meaning that potion will decrease will health.You start with 0 health and you will walk from left to right, from first potion to the last one. At each potion, you may choose to drink it or ignore it. You must ensure that your health is always non-negative.What is the largest number of potions you can drink? | Input: ['6', '4 -4 1 -3 1 -3', ''] Output:['5'] | [
0,
2
] |
You are given an integer x. Can you make x by summing up some number of 11, 111, 1111, 11111, ...? (You can use any number among them any number of times).For instance, 33=11+11+11 144=111+11+11+11 | Input: ['3', '33', '144', '69', ''] Output:['YES', 'YES', 'NO', ''] | [
3
] |
Monocarp plays a computer game called "Goblins and Gnomes". In this game, he manages a large underground city of gnomes and defends it from hordes of goblins.The city consists of n halls and m one-directional tunnels connecting them. The structure of tunnels has the following property: if a goblin leaves any hall, he cannot return to that hall. The city will be attacked by k waves of goblins; during the i-th wave, i goblins attack the city. Monocarp's goal is to pass all k waves.The i-th wave goes as follows: firstly, i goblins appear in some halls of the city and pillage them; at most one goblin appears in each hall. Then, goblins start moving along the tunnels, pillaging all the halls in their path. Goblins are very greedy and cunning, so they choose their paths so that no two goblins pass through the same hall. Among all possible attack plans, they choose a plan which allows them to pillage the maximum number of halls. After goblins are done pillaging, they leave the city.If all halls are pillaged during the wave β Monocarp loses the game. Otherwise, the city is restored. If some hall is pillaged during a wave, goblins are still interested in pillaging it during the next waves.Before each wave, Monocarp can spend some time preparing to it. Monocarp doesn't have any strict time limits on his preparations (he decides when to call each wave by himself), but the longer he prepares for a wave, the fewer points he gets for passing it. If Monocarp prepares for the i-th wave for t_i minutes, then he gets \max(0, x_i - t_i \cdot y_i) points for passing it (obviously, if he doesn't lose in the process).While preparing for a wave, Monocarp can block tunnels. He can spend one minute to either block all tunnels leading from some hall or block all tunnels leading to some hall. If Monocarp blocks a tunnel while preparing for a wave, it stays blocked during the next waves as well.Help Monocarp to defend against all k waves of goblins and get the maximum possible amount of points! | Input: ['5 4 4', '1 2', '2 3', '4 3', '5 3', '100 1', '200 5', '10 10', '100 1', ''] Output:['6', '-2 -3 0 0 0 0 ', ''] | [
0
] |
Monocarp is playing a game "Assimilation IV". In this game he manages a great empire: builds cities and conquers new lands.Monocarp's empire has n cities. In order to conquer new lands he plans to build one Monument in each city. The game is turn-based and, since Monocarp is still amateur, he builds exactly one Monument per turn.Monocarp has m points on the map he'd like to control using the constructed Monuments. For each point he knows the distance between it and each city. Monuments work in the following way: when built in some city, a Monument controls all points at distance at most 1 to this city. Next turn, the Monument controls all points at distance at most 2, the turn after β at distance at most 3, and so on. Monocarp will build n Monuments in n turns and his empire will conquer all points that are controlled by at least one Monument.Monocarp can't figure out any strategy, so during each turn he will choose a city for a Monument randomly among all remaining cities (cities without Monuments). Monocarp wants to know how many points (among m of them) he will conquer at the end of turn number n. Help him to calculate the expected number of conquered points! | Input: ['3 5', '1 4 4 3 4', '1 4 1 4 2', '1 4 4 4 3', ''] Output:['166374062', ''] | [
3
] |
There are n armchairs, numbered from 1 to n from left to right. Some armchairs are occupied by people (at most one person per armchair), others are not. The number of occupied armchairs is not greater than \frac{n}{2}.For some reason, you would like to tell people to move from their armchairs to some other ones. If the i-th armchair is occupied by someone and the j-th armchair is not, you can tell the person sitting in the i-th armchair to move to the j-th armchair. The time it takes a person to move from the i-th armchair to the j-th one is |i - j| minutes. You may perform this operation any number of times, but these operations must be done sequentially, i.βe. you cannot tell a person to move until the person you asked to move in the last operation has finished moving to their destination armchair.You want to achieve the following situation: every seat that was initially occupied must be free. What is the minimum time you need to do it? | Input: ['7', '1 0 0 1 0 0 1', ''] Output:['3', ''] | [
2
] |
There are n robots driving along an OX axis. There are also two walls: one is at coordinate 0 and one is at coordinate m.The i-th robot starts at an integer coordinate x_i~(0 < x_i < m) and moves either left (towards the 0) or right with the speed of 1 unit per second. No two robots start at the same coordinate.Whenever a robot reaches a wall, it turns around instantly and continues his ride in the opposite direction with the same speed.Whenever several robots meet at the same integer coordinate, they collide and explode into dust. Once a robot has exploded, it doesn't collide with any other robot. Note that if several robots meet at a non-integer coordinate, nothing happens.For each robot find out if it ever explodes and print the time of explosion if it happens and -1 otherwise. | Input: ['5', '7 12', '1 2 3 4 9 10 11', 'R R L L R R R', '2 10', '1 6', 'R R', '2 10', '1 3', 'L L', '1 10', '5', 'R', '7 8', '6 1 7 2 3 5 4', 'R L R L L L L', ''] Output:['1 1 1 1 2 -1 2 ', '-1 -1 ', '2 2 ', '-1 ', '-1 2 7 3 2 7 3 ', ''] | [
2
] |
You are given a permutation a consisting of n numbers 1, 2, ..., n (a permutation is an array in which each element from 1 to n occurs exactly once).You can perform the following operation: choose some subarray (contiguous subsegment) of a and rearrange the elements in it in any way you want. But this operation cannot be applied to the whole array.For example, if a = [2, 1, 4, 5, 3] and we want to apply the operation to the subarray a[2, 4] (the subarray containing all elements from the 2-nd to the 4-th), then after the operation, the array can become a = [2, 5, 1, 4, 3] or, for example, a = [2, 1, 5, 4, 3].Your task is to calculate the minimum number of operations described above to sort the permutation a in ascending order. | Input: ['3', '4', '1 3 2 4', '3', '1 2 3', '5', '2 1 4 5 3', ''] Output:['1', '0', '2', ''] | [
2
] |
You have an initially empty cauldron, and you want to brew a potion in it. The potion consists of two ingredients: magic essence and water. The potion you want to brew should contain exactly k\ \% magic essence and (100 - k)\ \% water.In one step, you can pour either one liter of magic essence or one liter of water into the cauldron. What is the minimum number of steps to brew a potion? You don't care about the total volume of the potion, only about the ratio between magic essence and water in it.A small reminder: if you pour e liters of essence and w liters of water (e + w > 0) into the cauldron, then it contains \frac{e}{e + w} \cdot 100\ \% (without rounding) magic essence and \frac{w}{e + w} \cdot 100\ \% water. | Input: ['3', '3', '100', '25', ''] Output:['100', '1', '4', ''] | [
3
] |
To monitor cryptocurrency exchange rates trader William invented a wonderful device consisting of n lights arranged in a row. The device functions in the following way:Initially, all lights on William's device are turned off. At the beginning of a new iteration the device randomly, with a uniform distribution, picks a light that is turned off and turns it on, telling William which cryptocurrency he should invest in. After this iteration if any k consecutive lights contain more than one turned on light, then the device finishes working.William doesn't like uncertainty, so he wants you to calculate the expected value of the number of lights that are turned on in the device after it finishes working. | Input: ['3', '3 2', '15 2', '40 15', ''] Output:['333333338', '141946947', '329622137', ''] | [
3
] |
William is hosting a party for n of his trader friends. They started a discussion on various currencies they trade, but there's an issue: not all of his trader friends like every currency. They like some currencies, but not others.For each William's friend i it is known whether he likes currency j. There are m currencies in total. It is also known that a trader may not like more than p currencies.Because friends need to have some common topic for discussions they need to find the largest by cardinality (possibly empty) subset of currencies, such that there are at least \lceil \frac{n}{2} \rceil friends (rounded up) who like each currency in this subset. | Input: ['3 4 3', '1000', '0110', '1001', ''] Output:['1000', ''] | [
0
] |
William is a huge fan of planning ahead. That is why he starts his morning routine by creating a nested list of upcoming errands.A valid nested list is any list which can be created from a list with one item "1" by applying some operations. Each operation inserts a new item into the list, on a new line, just after one of existing items a_1 \,.\, a_2 \,.\, a_3 \,.\, \,\cdots\, \,.\,a_k and can be one of two types: Add an item a_1 \,.\, a_2 \,.\, a_3 \,.\, \cdots \,.\, a_k \,.\, 1 (starting a list of a deeper level), or Add an item a_1 \,.\, a_2 \,.\, a_3 \,.\, \cdots \,.\, (a_k + 1) (continuing the current level). Operation can only be applied if the list does not contain two identical items afterwards. And also, if we consider every item as a sequence of numbers, then the sequence of items should always remain increasing in lexicographical order. Examples of valid and invalid lists that are shown in the picture can found in the "Notes" section.When William decided to save a Word document with the list of his errands he accidentally hit a completely different keyboard shortcut from the "Ctrl-S" he wanted to hit. It's not known exactly what shortcut he pressed but after triggering it all items in the list were replaced by a single number: the last number originally written in the item number.William wants you to help him restore a fitting original nested list. | Input: ['2', '4', '1', '1', '2', '3', '9', '1', '1', '1', '2', '2', '1', '2', '1', '2', ''] Output:['1', '1.1', '1.2', '1.3', '1', '1.1', '1.1.1', '1.1.2', '1.2', '1.2.1', '2', '2.1', '2.2', ''] | [
0,
2
] |
You like numbers, don't you? Nastia has a lot of numbers and she wants to share them with you! Isn't it amazing?Let a_i be how many numbers i (1 <= i <= k) you have.An n * n matrix is called beautiful if it contains all the numbers you have, and for each 2 * 2 submatrix of the original matrix is satisfied: The number of occupied cells doesn't exceed 3; The numbers on each diagonal are distinct. Make a beautiful matrix of minimum size. | Input: ['2', '3 4', '2 0 0 1', '15 4', '2 4 8 1', ''] Output:['2', '4 1', '0 1', '5', '3 0 0 2 2', '3 2 3 3 0', '0 1 0 4 0', '3 0 0 0 0', '2 1 3 3 3'] | [
2,
4
] |
Nastia has an unweighted tree with n vertices and wants to play with it!The girl will perform the following operation with her tree, as long as she needs: Remove any existing edge. Add an edge between any pair of vertices. What is the minimum number of operations Nastia needs to get a bamboo from a tree? A bamboo is a tree in which no node has a degree greater than 2. | Input: ['2', '7', '1 2', '1 3', '2 4', '2 5', '3 6', '3 7', '4', '1 2', '1 3', '3 4', ''] Output:['2', '2 5 6 7', '3 6 4 5', '0'] | [
2
] |
Nastia has received an array of n positive integers as a gift.She calls such an array a good that for all i (2 <= i <= n) takes place gcd(a_{i - 1}, a_{i}) = 1, where gcd(u, v) denotes the greatest common divisor (GCD) of integers u and v.You can perform the operation: select two different indices i, j (1 <= i, j <= n, i \neq j) and two integers x, y (1 <= x, y <= 2 \cdot 10^9) so that \min{(a_i, a_j)} = \min{(x, y)}. Then change a_i to x and a_j to y.The girl asks you to make the array good using at most n operations.It can be proven that this is always possible. | Input: ['2', '5', '9 6 3 11 15', '3', '7 5 13', ''] Output:['2', '1 5 11 9', '2 5 7 6', '0'] | [
3
] |
Nastia has 2 positive integers A and B. She defines that: The integer is good if it is divisible by A \cdot B; Otherwise, the integer is nearly good, if it is divisible by A. For example, if A = 6 and B = 4, the integers 24 and 72 are good, the integers 6, 660 and 12 are nearly good, the integers 16, 7 are neither good nor nearly good.Find 3 different positive integers x, y, and z such that exactly one of them is good and the other 2 are nearly good, and x + y = z. | Input: ['3', '5 3', '13 2', '7 11', ''] Output:['YES', '10 50 60', 'YES', '169 39 208', 'YES', '28 154 182'] | [
3
] |
Dima overslept the alarm clock, which was supposed to raise him to school.Dima wonders if he will have time to come to the first lesson. To do this, he needs to know the minimum time it will take him to get from home to school.The city where Dima lives is a rectangular field of n * m size. Each cell (i, j) on this field is denoted by one number a_{ij}: The number -1 means that the passage through the cell is prohibited; The number 0 means that the cell is free and Dima can walk though it. The number x (1 <= x <= 10^9) means that the cell contains a portal with a cost of x. A cell with a portal is also considered free. From any portal, Dima can go to any other portal, while the time of moving from the portal (i, j) to the portal (x, y) corresponds to the sum of their costs a_{ij} + a_{xy}.In addition to moving between portals, Dima can also move between unoccupied cells adjacent to one side in time w. In particular, he can enter a cell with a portal and not use it.Initially, Dima is in the upper-left cell (1, 1), and the school is in the lower right cell (n, m). | Input: ['5 5 1', '0 -1 0 1 -1', '0 20 0 0 -1', '-1 -1 -1 -1 -1', '3 0 0 0 0', '-1 0 0 0 0', ''] Output:['14'] | [
0,
2
] |
This is an interactive problem.This is a hard version of the problem. The difference from the easy version is that in the hard version 1 <= t <= \min(n, 10^4) and the total number of queries is limited to 6 \cdot 10^4.Polycarp is playing a computer game. In this game, an array consisting of zeros and ones is hidden. Polycarp wins if he guesses the position of the k-th zero from the left t times.Polycarp can make no more than 6 \cdot 10^4 requests totally of the following type: ? l r β find out the sum of all elements in positions from l to r (1 <= l <= r <= n) inclusive. To make the game more interesting, each guessed zero turns into one and the game continues on the changed array. More formally, if the position of the k-th zero was x, then after Polycarp guesses this position, the x-th element of the array will be replaced from 0 to 1.Help Polycarp win the game. | Input: ['6 2', '', '2', '', '2', '', '1', '', '1', '', '0', '', '1', '', '0'] Output:['? 4 6', '', '? 1 1', '', '? 1 2', '', '? 5 5', '', '! 5', '', '? 2 2', '', '! 2', '', ''] | [
4
] |
This is an interactive problem.This is an easy version of the problem. The difference from the hard version is that in the easy version t=1 and the number of queries is limited to 20.Polycarp is playing a computer game. In this game, an array consisting of zeros and ones is hidden. Polycarp wins if he guesses the position of the k-th zero from the left t times.Polycarp can make no more than 20 requests of the following type: ? l r β find out the sum of all elements in positions from l to r (1 <= l <= r <= n) inclusive. In this (easy version) of the problem, this paragraph doesn't really make sense since t=1 always. To make the game more interesting, each guessed zero turns into one and the game continues on the changed array. More formally, if the position of the k-th zero was x, then after Polycarp guesses this position, the x-th element of the array will be replaced from 0 to 1. Of course, this feature affects something only for t>1.Help Polycarp win the game. | Input: ['6 1', '2', '', '2', '', '1', '', '1', '', '0', '', '0'] Output:['? 4 6', '', '? 1 1', '', '? 1 2', '', '? 2 2', '', '? 5 5', '', '! 5'] | [
4
] |
You are playing the game "Arranging The Sheep". The goal of this game is to make the sheep line up. The level in the game is described by a string of length n, consisting of the characters '.' (empty space) and '*' (sheep). In one move, you can move any sheep one square to the left or one square to the right, if the corresponding square exists and is empty. The game ends as soon as the sheep are lined up, that is, there should be no empty cells between any sheep.For example, if n=6 and the level is described by the string "**.*..", then the following game scenario is possible: the sheep at the 4 position moves to the right, the state of the level: "**..*."; the sheep at the 2 position moves to the right, the state of the level: "*.*.*."; the sheep at the 1 position moves to the right, the state of the level: ".**.*."; the sheep at the 3 position moves to the right, the state of the level: ".*.**."; the sheep at the 2 position moves to the right, the state of the level: "..***."; the sheep are lined up and the game ends. For a given level, determine the minimum number of moves you need to make to complete the level. | Input: ['5', '6', '**.*..', '5', '*****', '3', '.*.', '3', '...', '10', '*.*...*.**', ''] Output:['1', '0', '0', '0', '9', ''] | [
2,
3
] |
You are given an array a of n integers. Count the number of pairs of indices (i, j) such that i < j and a_j - a_i = j - i. | Input: ['4', '6', '3 5 1 4 6 6', '3', '1 2 3', '4', '1 3 3 4', '6', '1 6 3 4 5 6', ''] Output:['1', '3', '3', '10', ''] | [
3
] |
Let's call a positive integer n ordinary if in the decimal notation all its digits are the same. For example, 1, 2 and 99 are ordinary numbers, but 719 and 2021 are not ordinary numbers.For a given number n, find the number of ordinary numbers among the numbers from 1 to n. | Input: ['6', '1', '2', '3', '4', '5', '100', ''] Output:['1', '2', '3', '4', '5', '18', ''] | [
0,
3
] |
Polycarp has 26 tasks. Each task is designated by a capital letter of the Latin alphabet.The teacher asked Polycarp to solve tasks in the following way: if Polycarp began to solve some task, then he must solve it to the end, without being distracted by another task. After switching to another task, Polycarp cannot return to the previous task.Polycarp can only solve one task during the day. Every day he wrote down what task he solved. Now the teacher wants to know if Polycarp followed his advice.For example, if Polycarp solved tasks in the following order: "DDBBCCCBBEZ", then the teacher will see that on the third day Polycarp began to solve the task 'B', then on the fifth day he got distracted and began to solve the task 'C', on the eighth day Polycarp returned to the task 'B'. Other examples of when the teacher is suspicious: "BAB", "AABBCCDDEEBZZ" and "AAAAZAAAAA".If Polycarp solved the tasks as follows: "FFGZZZY", then the teacher cannot have any suspicions. Please note that Polycarp is not obligated to solve all tasks. Other examples of when the teacher doesn't have any suspicious: "BA", "AFFFCC" and "YYYYY".Help Polycarp find out if his teacher might be suspicious. | Input: ['5', '3', 'ABA', '11', 'DDBBCCCBBEZ', '7', 'FFGZZZY', '1', 'Z', '2', 'AB', ''] Output:['NO', 'NO', 'YES', 'YES', 'YES', ''] | [
0
] |
Alice and Bob play a game. Alice has got n treasure chests (the i-th of which contains a_i coins) and m keys (the j-th of which she can sell Bob for b_j coins).Firstly, Alice puts some locks on the chests. There are m types of locks, the locks of the j-th type can only be opened with the j-th key. To put a lock of type j on the i-th chest, Alice has to pay c_{i,j} dollars. Alice can put any number of different types of locks on each chest (possibly, zero).Then, Bob buys some of the keys from Alice (possibly none, possibly all of them) and opens each chest he can (he can open a chest if he has the keys for all of the locks on this chest). Bob's profit is the difference between the total number of coins in the opened chests and the total number of coins he spends buying keys from Alice. If Bob's profit is strictly positive (greater than zero), he wins the game. Otherwise, Alice wins the game.Alice wants to put some locks on some chests so no matter which keys Bob buys, she always wins (Bob cannot get positive profit). Of course, she wants to spend the minimum possible number of dollars on buying the locks. Help her to determine whether she can win the game at all, and if she can, how many dollars she has to spend on the locks. | Input: ['2 3', '3 3', '1 1 4', '10 20 100', '20 15 80', ''] Output:['205', ''] | [
0
] |
You are given two integer arrays a and b of length n.You can reverse at most one subarray (continuous subsegment) of the array a. Your task is to reverse such a subarray that the sum \sum\limits_{i=1}^n a_i \cdot b_i is maximized. | Input: ['5', '2 3 2 1 3', '1 3 2 4 2', ''] Output:['29', ''] | [
0,
3
] |
Polycarp is an organizer of a Berland ICPC regional event. There are n universities in Berland numbered from 1 to n. Polycarp knows all competitive programmers in the region. There are n students: the i-th student is enrolled at a university u_i and has a programming skill s_i.Polycarp has to decide on the rules now. In particular, the number of members in the team.Polycarp knows that if he chooses the size of the team to be some integer k, each university will send their k strongest (with the highest programming skill s) students in the first team, the next k strongest students in the second team and so on. If there are fewer than k students left, then the team can't be formed. Note that there might be universities that send zero teams.The strength of the region is the total skill of the members of all present teams. If there are no teams present, then the strength is 0.Help Polycarp to find the strength of the region for each choice of k from 1 to n. | Input: ['4', '7', '1 2 1 2 1 2 1', '6 8 3 1 5 1 5', '10', '1 1 1 2 2 2 2 3 3 3', '3435 3014 2241 2233 2893 2102 2286 2175 1961 2567', '6', '3 3 3 3 3 3', '5 9 6 7 9 7', '1', '1', '3083', ''] Output:['29 28 26 19 0 0 0 ', '24907 20705 22805 9514 0 0 0 0 0 0 ', '43 43 43 32 38 43 ', '3083 ', ''] | [
0,
2
] |
There is a n * m grid. You are standing at cell (1, 1) and your goal is to finish at cell (n, m).You can move to the neighboring cells to the right or down. In other words, suppose you are standing at cell (x, y). You can: move right to the cell (x, y + 1) β it costs x burles; move down to the cell (x + 1, y) β it costs y burles. Can you reach cell (n, m) spending exactly k burles? | Input: ['6', '1 1 0', '2 2 2', '2 2 3', '2 2 4', '1 4 3', '100 100 10000', ''] Output:['YES', 'NO', 'YES', 'NO', 'YES', 'NO', ''] | [
3
] |
Subsets and Splits