index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
3,900 | 9 |
Santa has to send presents to the kids. He has a large stack of n presents, numbered from 1 to n; the topmost present has number a_1, the next present is a_2, and so on; the bottom present has number a_n. All numbers are distinct.
Santa has a list of m distinct presents he has to send: b_1, b_2, ..., b_m. He will send them in the order they appear in the list.
To send a present, Santa has to find it in the stack by removing all presents above it, taking this present and returning all removed presents on top of the stack. So, if there are k presents above the present Santa wants to send, it takes him 2k + 1 seconds to do it. Fortunately, Santa can speed the whole process up β when he returns the presents to the stack, he may reorder them as he wishes (only those which were above the present he wanted to take; the presents below cannot be affected in any way).
What is the minimum time required to send all of the presents, provided that Santa knows the whole list of presents he has to send and reorders the presents optimally? Santa cannot change the order of presents or interact with the stack of presents in any other way.
Your program has to answer t different test cases.
Input
The first line contains one integer t (1 β€ t β€ 100) β the number of test cases.
Then the test cases follow, each represented by three lines.
The first line contains two integers n and m (1 β€ m β€ n β€ 10^5) β the number of presents in the stack and the number of presents Santa wants to send, respectively.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ n, all a_i are unique) β the order of presents in the stack.
The third line contains m integers b_1, b_2, ..., b_m (1 β€ b_i β€ n, all b_i are unique) β the ordered list of presents Santa has to send.
The sum of n over all test cases does not exceed 10^5.
Output
For each test case print one integer β the minimum number of seconds which Santa has to spend sending presents, if he reorders the presents optimally each time he returns them into the stack.
Example
Input
2
3 3
3 1 2
3 2 1
7 2
2 1 7 3 4 5 6
3 1
Output
5
8
|
import sys
def get_ints(): return (map(int, sys.stdin.readline().strip().split()))
for ad in range(int(input())):
n,m=get_ints()
a=list(get_ints())
b=list(get_ints())
pos=[-1]*(n+1)
x=-1
ans=0
for i in range(n):
pos[a[i]]=i
for i in range(m):
if pos[b[i]]<x:
ans+=1
else:
ans+=2*(pos[b[i]]-i)+1
x=pos[b[i]]
print(ans)
|
{
"input": [
"2\n3 3\n3 1 2\n3 2 1\n7 2\n2 1 7 3 4 5 6\n3 1\n"
],
"output": [
"5\n8\n"
]
}
|
3,901 | 7 |
Olga came to visit the twins Anna and Maria and saw that they have many cookies. The cookies are distributed into bags. As there are many cookies, Olga decided that it's no big deal if she steals a bag. However, she doesn't want the sisters to quarrel because of nothing when they divide the cookies. That's why Olga wants to steal a bag with cookies so that the number of cookies in the remaining bags was even, that is, so that Anna and Maria could evenly divide it into two (even 0 remaining cookies will do, just as any other even number). How many ways there are to steal exactly one cookie bag so that the total number of cookies in the remaining bags was even?
Input
The first line contains the only integer n (1 β€ n β€ 100) β the number of cookie bags Anna and Maria have. The second line contains n integers ai (1 β€ ai β€ 100) β the number of cookies in the i-th bag.
Output
Print in the only line the only number β the sought number of ways. If there are no such ways print 0.
Examples
Input
1
1
Output
1
Input
10
1 2 2 3 4 4 4 2 2 2
Output
8
Input
11
2 2 2 2 2 2 2 2 2 2 99
Output
1
Note
In the first sample Olga should take the only bag so that the twins ended up with the even number of cookies.
In the second sample Olga can take any of five bags with two cookies or any of three bags with four cookies β 5 + 3 = 8 ways in total.
In the third sample, no matter which bag with two cookies Olga chooses, the twins are left with 2 * 9 + 99 = 117 cookies. Thus, Olga has only one option: to take the bag with 99 cookies.
|
def main():
n = int(input())
odd = sum(int(c) % 2 for c in input().split())
print(odd if odd % 2 else n - odd)
if __name__ == "__main__":
main()
|
{
"input": [
"1\n1\n",
"11\n2 2 2 2 2 2 2 2 2 2 99\n",
"10\n1 2 2 3 4 4 4 2 2 2\n"
],
"output": [
"1\n",
"1\n",
"8\n"
]
}
|
3,902 | 9 |
Denis was very sad after Nastya rejected him. So he decided to walk through the gateways to have some fun. And luck smiled at him! When he entered the first courtyard, he met a strange man who was selling something.
Denis bought a mysterious item and it was... Random permutation generator! Denis could not believed his luck.
When he arrived home, he began to study how his generator works and learned the algorithm. The process of generating a permutation consists of n steps. At the i-th step, a place is chosen for the number i (1 β€ i β€ n). The position for the number i is defined as follows:
* For all j from 1 to n, we calculate r_j β the minimum index such that j β€ r_j β€ n, and the position r_j is not yet occupied in the permutation. If there are no such positions, then we assume that the value of r_j is not defined.
* For all t from 1 to n, we calculate count_t β the number of positions 1 β€ j β€ n such that r_j is defined and r_j = t.
* Consider the positions that are still not occupied by permutation and among those we consider the positions for which the value in the count array is maximum.
* The generator selects one of these positions for the number i. The generator can choose any position.
Let's have a look at the operation of the algorithm in the following example:
<image>
Let n = 5 and the algorithm has already arranged the numbers 1, 2, 3 in the permutation. Consider how the generator will choose a position for the number 4:
* The values of r will be r = [3, 3, 3, 4, Γ], where Γ means an indefinite value.
* Then the count values will be count = [0, 0, 3, 1, 0].
* There are only two unoccupied positions in the permutation: 3 and 4. The value in the count array for position 3 is 3, for position 4 it is 1.
* The maximum value is reached only for position 3, so the algorithm will uniquely select this position for number 4.
Satisfied with his purchase, Denis went home. For several days without a break, he generated permutations. He believes that he can come up with random permutations no worse than a generator. After that, he wrote out the first permutation that came to mind p_1, p_2, β¦, p_n and decided to find out if it could be obtained as a result of the generator.
Unfortunately, this task was too difficult for him, and he asked you for help. It is necessary to define whether the written permutation could be obtained using the described algorithm if the generator always selects the position Denis needs.
Input
The first line contains a single integer t (1 β€ t β€ 10^5) β the number of test cases. Then the descriptions of the test cases follow.
The first line of the test case contains a single integer n (1 β€ n β€ 10^5) β the size of the permutation.
The second line of the test case contains n different integers p_1, p_2, β¦, p_n (1 β€ p_i β€ n) β the permutation written by Denis.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
Print "Yes" if this permutation could be obtained as a result of the generator. Otherwise, print "No".
All letters can be displayed in any case.
Example
Input
5
5
2 3 4 5 1
1
1
3
1 3 2
4
4 2 3 1
5
1 5 2 4 3
Output
Yes
Yes
No
Yes
No
Note
Let's simulate the operation of the generator in the first test.
At the 1 step, r = [1, 2, 3, 4, 5], count = [1, 1, 1, 1, 1]. The maximum value is reached in any free position, so the generator can choose a random position from 1 to 5. In our example, it chose 5.
At the 2 step, r = [1, 2, 3, 4, Γ], count = [1, 1, 1, 1, 0]. The maximum value is reached in positions from 1 to 4, so the generator can choose a random position among them. In our example, it chose 1.
At the 3 step, r = [2, 2, 3, 4, Γ], count = [0, 2, 1, 1, 0]. The maximum value is 2 and is reached only at the 2 position, so the generator will choose this position.
At the 4 step, r = [3, 3, 3, 4, Γ], count = [0, 0, 3, 1, 0]. The maximum value is 3 and is reached only at the 3 position, so the generator will choose this position.
At the 5 step, r = [4, 4, 4, 4, Γ], count = [0, 0, 0, 4, 0]. The maximum value is 4 and is reached only at the 4 position, so the generator will choose this position.
In total, we got a permutation of 2, 3, 4, 5, 1, that is, a generator could generate it.
|
t = int(input())
def sol():
n = int(input())
a = list(map(int, input().split()))
for i in range(n-1):
if a[i] + 1 != a[i+1] and a[i] < a[i+1]:
return False
return True
for i in range(t):
print('Yes' if sol() else 'No')
|
{
"input": [
"5\n5\n2 3 4 5 1\n1\n1\n3\n1 3 2\n4\n4 2 3 1\n5\n1 5 2 4 3\n"
],
"output": [
"Yes\nYes\nNo\nYes\nNo\n"
]
}
|
3,903 | 9 |
Ayush and Ashish play a game on an unrooted tree consisting of n nodes numbered 1 to n. Players make the following move in turns:
* Select any leaf node in the tree and remove it together with any edge which has this node as one of its endpoints. A leaf node is a node with degree less than or equal to 1.
A tree is a connected undirected graph without cycles.
There is a special node numbered x. The player who removes this node wins the game.
Ayush moves first. Determine the winner of the game if each player plays optimally.
Input
The first line of the input contains a single integer t (1 β€ t β€ 10) β the number of testcases. The description of the test cases follows.
The first line of each testcase contains two integers n and x (1β€ n β€ 1000, 1 β€ x β€ n) β the number of nodes in the tree and the special node respectively.
Each of the next n-1 lines contain two integers u, v (1 β€ u, v β€ n, u β v), meaning that there is an edge between nodes u and v in the tree.
Output
For every test case, if Ayush wins the game, print "Ayush", otherwise print "Ashish" (without quotes).
Examples
Input
1
3 1
2 1
3 1
Output
Ashish
Input
1
3 2
1 2
1 3
Output
Ayush
Note
For the 1st test case, Ayush can only remove node 2 or 3, after which node 1 becomes a leaf node and Ashish can remove it in his turn.
For the 2nd test case, Ayush can remove node 2 in the first move itself.
|
t = int(input())
def solve():
n, x = map(int, input().split())
d = 0
for i in range(n-1):
a, b = map(int, input().split())
if a == x or b == x:
d += 1
if d <= 1 or n % 2 == 0:
print("Ayush")
else:
print("Ashish")
for i in range(t):
solve()
|
{
"input": [
"1\n3 1\n2 1\n3 1\n",
"1\n3 2\n1 2\n1 3\n"
],
"output": [
"Ashish\n",
"Ayush\n"
]
}
|
3,904 | 11 |
Koa the Koala has a binary string s of length n. Koa can perform no more than n-1 (possibly zero) operations of the following form:
In one operation Koa selects positions i and i+1 for some i with 1 β€ i < |s| and sets s_i to max(s_i, s_{i+1}). Then Koa deletes position i+1 from s (after the removal, the remaining parts are concatenated).
Note that after every operation the length of s decreases by 1.
How many different binary strings can Koa obtain by doing no more than n-1 (possibly zero) operations modulo 10^9+7 (1000000007)?
Input
The only line of input contains binary string s (1 β€ |s| β€ 10^6). For all i (1 β€ i β€ |s|) s_i = 0 or s_i = 1.
Output
On a single line print the answer to the problem modulo 10^9+7 (1000000007).
Examples
Input
000
Output
3
Input
0101
Output
6
Input
0001111
Output
16
Input
00101100011100
Output
477
Note
In the first sample Koa can obtain binary strings: 0, 00 and 000.
In the second sample Koa can obtain binary strings: 1, 01, 11, 011, 101 and 0101. For example:
* to obtain 01 from 0101 Koa can operate as follows: 0101 β 0(10)1 β 011 β 0(11) β 01.
* to obtain 11 from 0101 Koa can operate as follows: 0101 β (01)01 β 101 β 1(01) β 11.
Parentheses denote the two positions Koa selected in each operation.
|
MOD = 1000000007
def main():
s = input()
n = len(s)
zero = [0] * n
for i in range(n):
if s[i] == '0':
zero[i] = zero[i-1] + 1 if i else 1
nxt, dp = [0] * (n+2), [0] * (n+2)
for i in range(n+1):
nxt[i] = n
for i in range(n-1, -1, -1):
dp[i] = ((zero[i] <= zero[n-1]) + dp[nxt[0]] + dp[nxt[zero[i] + 1]]) % MOD
nxt[zero[i]] = i
ans = n if nxt[0] >= n else dp[nxt[0]] * (nxt[0] + 1) % MOD
print(ans)
main()
|
{
"input": [
"000\n",
"0101\n",
"00101100011100\n",
"0001111\n"
],
"output": [
"3\n",
"6\n",
"477\n",
"16\n"
]
}
|
3,905 | 8 |
Masha has n types of tiles of size 2 Γ 2. Each cell of the tile contains one integer. Masha has an infinite number of tiles of each type.
Masha decides to construct the square of size m Γ m consisting of the given tiles. This square also has to be a symmetric with respect to the main diagonal matrix, and each cell of this square has to be covered with exactly one tile cell, and also sides of tiles should be parallel to the sides of the square. All placed tiles cannot intersect with each other. Also, each tile should lie inside the square. See the picture in Notes section for better understanding.
Symmetric with respect to the main diagonal matrix is such a square s that for each pair (i, j) the condition s[i][j] = s[j][i] holds. I.e. it is true that the element written in the i-row and j-th column equals to the element written in the j-th row and i-th column.
Your task is to determine if Masha can construct a square of size m Γ m which is a symmetric matrix and consists of tiles she has. Masha can use any number of tiles of each type she has to construct the square. Note that she can not rotate tiles, she can only place them in the orientation they have in the input.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow.
The first line of the test case contains two integers n and m (1 β€ n β€ 100, 1 β€ m β€ 100) β the number of types of tiles and the size of the square Masha wants to construct.
The next 2n lines of the test case contain descriptions of tiles types. Types of tiles are written one after another, each type is written on two lines.
The first line of the description contains two positive (greater than zero) integers not exceeding 100 β the number written in the top left corner of the tile and the number written in the top right corner of the tile of the current type. The second line of the description contains two positive (greater than zero) integers not exceeding 100 β the number written in the bottom left corner of the tile and the number written in the bottom right corner of the tile of the current type.
It is forbidden to rotate tiles, it is only allowed to place them in the orientation they have in the input.
Output
For each test case print the answer: "YES" (without quotes) if Masha can construct the square of size m Γ m which is a symmetric matrix. Otherwise, print "NO" (withtout quotes).
Example
Input
6
3 4
1 2
5 6
5 7
7 4
8 9
9 8
2 5
1 1
1 1
2 2
2 2
1 100
10 10
10 10
1 2
4 5
8 4
2 2
1 1
1 1
1 2
3 4
1 2
1 1
1 1
Output
YES
NO
YES
NO
YES
YES
Note
The first test case of the input has three types of tiles, they are shown on the picture below.
<image>
Masha can construct, for example, the following square of size 4 Γ 4 which is a symmetric matrix:
<image>
|
def gt():
return list(map(int, input().split()))
def test():
a,b=gt();c,d=gt();
return b==c
t ,= gt()
while t:
t -= 1
n, m = gt()
if True in [test() for _ in range(n)] and not m&1:
print("YES")
else:
print("NO")
|
{
"input": [
"6\n3 4\n1 2\n5 6\n5 7\n7 4\n8 9\n9 8\n2 5\n1 1\n1 1\n2 2\n2 2\n1 100\n10 10\n10 10\n1 2\n4 5\n8 4\n2 2\n1 1\n1 1\n1 2\n3 4\n1 2\n1 1\n1 1\n"
],
"output": [
"YES\nNO\nYES\nNO\nYES\nYES\n"
]
}
|
3,906 | 7 |
A Ministry for Defense sent a general to inspect the Super Secret Military Squad under the command of the Colonel SuperDuper. Having learned the news, the colonel ordered to all n squad soldiers to line up on the parade ground.
By the military charter the soldiers should stand in the order of non-increasing of their height. But as there's virtually no time to do that, the soldiers lined up in the arbitrary order. However, the general is rather short-sighted and he thinks that the soldiers lined up correctly if the first soldier in the line has the maximum height and the last soldier has the minimum height. Please note that the way other solders are positioned does not matter, including the case when there are several soldiers whose height is maximum or minimum. Only the heights of the first and the last soldier are important.
For example, the general considers the sequence of heights (4, 3, 4, 2, 1, 1) correct and the sequence (4, 3, 1, 2, 2) wrong.
Within one second the colonel can swap any two neighboring soldiers. Help him count the minimum time needed to form a line-up which the general will consider correct.
Input
The first input line contains the only integer n (2 β€ n β€ 100) which represents the number of soldiers in the line. The second line contains integers a1, a2, ..., an (1 β€ ai β€ 100) the values of the soldiers' heights in the order of soldiers' heights' increasing in the order from the beginning of the line to its end. The numbers are space-separated. Numbers a1, a2, ..., an are not necessarily different.
Output
Print the only integer β the minimum number of seconds the colonel will need to form a line-up the general will like.
Examples
Input
4
33 44 11 22
Output
2
Input
7
10 10 58 31 63 40 76
Output
10
Note
In the first sample the colonel will need to swap the first and second soldier and then the third and fourth soldier. That will take 2 seconds. The resulting position of the soldiers is (44, 33, 22, 11).
In the second sample the colonel may swap the soldiers in the following sequence:
1. (10, 10, 58, 31, 63, 40, 76)
2. (10, 58, 10, 31, 63, 40, 76)
3. (10, 58, 10, 31, 63, 76, 40)
4. (10, 58, 10, 31, 76, 63, 40)
5. (10, 58, 31, 10, 76, 63, 40)
6. (10, 58, 31, 76, 10, 63, 40)
7. (10, 58, 31, 76, 63, 10, 40)
8. (10, 58, 76, 31, 63, 10, 40)
9. (10, 76, 58, 31, 63, 10, 40)
10. (76, 10, 58, 31, 63, 10, 40)
11. (76, 10, 58, 31, 63, 40, 10)
|
def test():
n = int(input())
i = list(map(int, input().split(' ')))
b = i[::-1]
c = i.index(max(i)) + b.index(min(b))
print(c - (0, 1)[c >= n])
test()
|
{
"input": [
"7\n10 10 58 31 63 40 76\n",
"4\n33 44 11 22\n"
],
"output": [
"10\n",
"2\n"
]
}
|
3,907 | 7 |
You have an array a_1, a_2, ..., a_n. All a_i are positive integers.
In one step you can choose three distinct indices i, j, and k (i β j; i β k; j β k) and assign the sum of a_j and a_k to a_i, i. e. make a_i = a_j + a_k.
Can you make all a_i lower or equal to d using the operation above any number of times (possibly, zero)?
Input
The first line contains a single integer t (1 β€ t β€ 2000) β the number of test cases.
The first line of each test case contains two integers n and d (3 β€ n β€ 100; 1 β€ d β€ 100) β the number of elements in the array a and the value d.
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 100) β the array a.
Output
For each test case, print YES, if it's possible to make all elements a_i less or equal than d using the operation above. Otherwise, print NO.
You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
3
5 3
2 3 2 5 4
3 4
2 4 4
5 4
2 1 5 3 6
Output
NO
YES
YES
Note
In the first test case, we can prove that we can't make all a_i β€ 3.
In the second test case, all a_i are already less or equal than d = 4.
In the third test case, we can, for example, choose i = 5, j = 1, k = 2 and make a_5 = a_1 + a_2 = 2 + 1 = 3. Array a will become [2, 1, 5, 3, 3].
After that we can make a_3 = a_5 + a_2 = 3 + 1 = 4. Array will become [2, 1, 4, 3, 3] and all elements are less or equal than d = 4.
|
def solve():
n,d=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
if a[0]+a[1]<=d or a[-1]<=d:
print('YES')
else:
print('NO')
tc = int(input())
for _ in range(tc):
solve()
|
{
"input": [
"3\n5 3\n2 3 2 5 4\n3 4\n2 4 4\n5 4\n2 1 5 3 6\n"
],
"output": [
"\nNO\nYES\nYES\n"
]
}
|
3,908 | 9 |
Let's say you are standing on the XY-plane at point (0, 0) and you want to reach point (n, n).
You can move only in two directions:
* to the right, i. e. horizontally and in the direction that increase your x coordinate,
* or up, i. e. vertically and in the direction that increase your y coordinate.
In other words, your path will have the following structure:
* initially, you choose to go to the right or up;
* then you go some positive integer distance in the chosen direction (distances can be chosen independently);
* after that you change your direction (from right to up, or from up to right) and repeat the process.
You don't like to change your direction too much, so you will make no more than n - 1 direction changes.
As a result, your path will be a polygonal chain from (0, 0) to (n, n), consisting of at most n line segments where each segment has positive integer length and vertical and horizontal segments alternate.
Not all paths are equal. You have n integers c_1, c_2, ..., c_n where c_i is the cost of the i-th segment.
Using these costs we can define the cost of the path as the sum of lengths of the segments of this path multiplied by their cost, i. e. if the path consists of k segments (k β€ n), then the cost of the path is equal to β_{i=1}^{k}{c_i β
length_i} (segments are numbered from 1 to k in the order they are in the path).
Find the path of the minimum cost and print its cost.
Input
The first line contains the single integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains the single integer n (2 β€ n β€ 10^5).
The second line of each test case contains n integers c_1, c_2, ..., c_n (1 β€ c_i β€ 10^9) β the costs of each segment.
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
For each test case, print the minimum possible cost of the path from (0, 0) to (n, n) consisting of at most n alternating segments.
Example
Input
3
2
13 88
3
2 3 1
5
4 3 2 1 4
Output
202
13
19
Note
In the first test case, to reach (2, 2) you need to make at least one turn, so your path will consist of exactly 2 segments: one horizontal of length 2 and one vertical of length 2. The cost of the path will be equal to 2 β
c_1 + 2 β
c_2 = 26 + 176 = 202.
In the second test case, one of the optimal paths consists of 3 segments: the first segment of length 1, the second segment of length 3 and the third segment of length 2.
The cost of the path is 1 β
2 + 3 β
3 + 2 β
1 = 13.
In the third test case, one of the optimal paths consists of 4 segments: the first segment of length 1, the second one β 1, the third one β 4, the fourth one β 4. The cost of the path is 1 β
4 + 1 β
3 + 4 β
2 + 4 β
1 = 19.
|
import sys
def solve(n, costs):
pref = [costs[0]]
for i in costs[1:]:
pref.append(i + pref[-1])
i0 = 0
i1 = 0
min0 = costs[0]
min1 = costs[1]
m = n*(min0+min1)
for i in range(2, n):
if i & 1:
i1 += 1
min1 = min(min1, costs[i])
else:
i0 += 1
min0 = min(min0, costs[i])
newm = pref[i]-min0-min1 + (n-i0)*min0 + (n-i1)*min1
m = min(m, newm)
return m
for _ in range(int(input())):
n = int(input())
cost = list(map(int, input().split()))
print(solve(n, cost))
|
{
"input": [
"3\n2\n13 88\n3\n2 3 1\n5\n4 3 2 1 4\n"
],
"output": [
"\n202\n13\n19\n"
]
}
|
3,909 | 7 |
Nastia has 2 positive integers A and B. She defines that:
* The integer is good if it is divisible by A β
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
The first line contains a single integer t (1 β€ t β€ 10 000) β the number of test cases.
The first line of each test case contains two integers A and B (1 β€ A β€ 10^6, 1 β€ B β€ 10^6) β numbers that Nastia has.
Output
For each test case print:
* "YES" and 3 different positive integers x, y, and z (1 β€ x, y, z β€ 10^{18}) such that exactly one of them is good and the other 2 are nearly good, and x + y = z.
* "NO" if no answer exists.
You can print each character of "YES" or "NO" in any case.
If there are multiple answers, print any.
Example
Input
3
5 3
13 2
7 11
Output
YES
10 50 60
YES
169 39 208
YES
28 154 182
Note
In the first test case: 60 β good number; 10 and 50 β nearly good numbers.
In the second test case: 208 β good number; 169 and 39 β nearly good numbers.
In the third test case: 154 β good number; 28 and 182 β nearly good numbers.
|
def solve(a, b):
if b == 1:
return "NO"
return f"YES\n{a} {a*(b*2-1)} {a*b*2}"
for _ in range(int(input())):
a, b = map(int, input().split())
print(solve(a, b))
|
{
"input": [
"3\n5 3\n13 2\n7 11\n"
],
"output": [
"\nYES\n10 50 60\nYES\n169 39 208\nYES\n28 154 182"
]
}
|
3,910 | 7 |
Let's call an array a consisting of n positive (greater than 0) integers beautiful if the following condition is held for every i from 1 to n: either a_i = 1, or at least one of the numbers a_i - 1 and a_i - 2 exists in the array as well.
For example:
* the array [5, 3, 1] is beautiful: for a_1, the number a_1 - 2 = 3 exists in the array; for a_2, the number a_2 - 2 = 1 exists in the array; for a_3, the condition a_3 = 1 holds;
* the array [1, 2, 2, 2, 2] is beautiful: for a_1, the condition a_1 = 1 holds; for every other number a_i, the number a_i - 1 = 1 exists in the array;
* the array [1, 4] is not beautiful: for a_2, neither a_2 - 2 = 2 nor a_2 - 1 = 3 exists in the array, and a_2 β 1;
* the array [2] is not beautiful: for a_1, neither a_1 - 1 = 1 nor a_1 - 2 = 0 exists in the array, and a_1 β 1;
* the array [2, 1, 3] is beautiful: for a_1, the number a_1 - 1 = 1 exists in the array; for a_2, the condition a_2 = 1 holds; for a_3, the number a_3 - 2 = 1 exists in the array.
You are given a positive integer s. Find the minimum possible size of a beautiful array with the sum of elements equal to s.
Input
The first line contains one integer t (1 β€ t β€ 5000) β the number of test cases.
Then t lines follow, the i-th line contains one integer s (1 β€ s β€ 5000) for the i-th test case.
Output
Print t integers, the i-th integer should be the answer for the i-th testcase: the minimum possible size of a beautiful array with the sum of elements equal to s.
Example
Input
4
1
8
7
42
Output
1
3
3
7
Note
Consider the example test:
1. in the first test case, the array [1] meets all conditions;
2. in the second test case, the array [3, 4, 1] meets all conditions;
3. in the third test case, the array [1, 2, 4] meets all conditions;
4. in the fourth test case, the array [1, 4, 6, 8, 10, 2, 11] meets all conditions.
|
from math import ceil, sqrt
def solve(n):
return ceil(sqrt(n))
for _ in range(int(input())):
n = int(input())
print(solve(n))
|
{
"input": [
"4\n1\n8\n7\n42\n"
],
"output": [
"1\n3\n3\n7\n"
]
}
|
3,911 | 7 |
You've got a rectangular table with length a and width b and the infinite number of plates of radius r. Two players play the following game: they take turns to put the plates on the table so that the plates don't lie on each other (but they can touch each other), and so that any point on any plate is located within the table's border. During the game one cannot move the plates that already lie on the table. The player who cannot make another move loses. Determine which player wins, the one who moves first or the one who moves second, provided that both players play optimally well.
Input
A single line contains three space-separated integers a, b, r (1 β€ a, b, r β€ 100) β the table sides and the plates' radius, correspondingly.
Output
If wins the player who moves first, print "First" (without the quotes). Otherwise print "Second" (without the quotes).
Examples
Input
5 5 2
Output
First
Input
6 7 4
Output
Second
Note
In the first sample the table has place for only one plate. The first player puts a plate on the table, the second player can't do that and loses.
<image>
In the second sample the table is so small that it doesn't have enough place even for one plate. So the first player loses without making a single move.
<image>
|
def main(a, b, r):
return "First" if 2 * r <= min(a, b) else "Second"
(a, b, r) = map(int, input().split(' '))
print(main(a, b, r))
|
{
"input": [
"6 7 4\n",
"5 5 2\n"
],
"output": [
"Second",
"First"
]
}
|
3,912 | 8 |
The Little Elephant loves playing with arrays. He has array a, consisting of n positive integers, indexed from 1 to n. Let's denote the number with index i as ai.
Additionally the Little Elephant has m queries to the array, each query is characterised by a pair of integers lj and rj (1 β€ lj β€ rj β€ n). For each query lj, rj the Little Elephant has to count, how many numbers x exist, such that number x occurs exactly x times among numbers alj, alj + 1, ..., arj.
Help the Little Elephant to count the answers to all queries.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 105) β the size of array a and the number of queries to it. The next line contains n space-separated positive integers a1, a2, ..., an (1 β€ ai β€ 109). Next m lines contain descriptions of queries, one per line. The j-th of these lines contains the description of the j-th query as two space-separated integers lj and rj (1 β€ lj β€ rj β€ n).
Output
In m lines print m integers β the answers to the queries. The j-th line should contain the answer to the j-th query.
Examples
Input
7 2
3 1 2 2 3 3 7
1 7
3 4
Output
3
1
|
import sys
def get_ints(): return map(int, sys.stdin.readline().split())
n,m=map(int,input().split())
arr=list(get_ints())
arr=[0]+arr
summ=[0]*(100001)
freq=[0]*(100001)
#print(l)
l=[0]*(100001)
r=[0]*(100001)
for ii in arr:
if ii<=n:freq[ii]+=1
for i in range(1,m+1):
x,y=get_ints()
l[i]=x
r[i]=y
ans=[0]*(m+1)
for i in range(1,n+1):
if freq[i]>=i:
for j in range(1,n+1):
summ[j]=summ[j-1]
if arr[j]==i:
summ[j]+=1
for k in range(1,m+1):
if summ[r[k]]-summ[l[k]-1]==i:
ans[k]+=1
for i in range(1,m+1):
print(ans[i])
|
{
"input": [
"7 2\n3 1 2 2 3 3 7\n1 7\n3 4\n"
],
"output": [
"3\n1\n"
]
}
|
3,913 | 7 |
A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.
Input
Input contains one integer number n (1 β€ n β€ 3000).
Output
Output the amount of almost prime numbers between 1 and n, inclusive.
Examples
Input
10
Output
2
Input
21
Output
8
|
a=int(input())
def okp(n):
return len([i for i in range(1,n+1)if n%i==0])<=2
def cp(n):
ans=len([i for i in range(2,n+1)if n%i==0 and okp(i)])
return ans
ans=0
for i in range(1,a+1):
if cp(i)==2:
ans+=1
print(ans)
|
{
"input": [
"10\n",
"21\n"
],
"output": [
"2\n",
"8\n"
]
}
|
3,914 | 7 |
Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub has the following scheme of painting: he skips x - 1 consecutive bricks, then he paints the x-th one. That is, he'll paint bricks x, 2Β·x, 3Β·x and so on red. Similarly, Floyd skips y - 1 consecutive bricks, then he paints the y-th one. Hence he'll paint bricks y, 2Β·y, 3Β·y and so on pink.
After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number a and Floyd has a lucky number b. Boys wonder how many bricks numbered no less than a and no greater than b are painted both red and pink. This is exactly your task: compute and print the answer to the question.
Input
The input will have a single line containing four integers in this order: x, y, a, b. (1 β€ x, y β€ 1000, 1 β€ a, b β€ 2Β·109, a β€ b).
Output
Output a single integer β the number of bricks numbered no less than a and no greater than b that are painted both red and pink.
Examples
Input
2 3 6 18
Output
3
Note
Let's look at the bricks from a to b (a = 6, b = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.
|
x,y,a,b=map(int,input().split())
from math import gcd
def lcm(a1,b1):
return a1*b1//gcd(a1,b1)
l=lcm(x,y)
print(b//l-(a-1)//l)
|
{
"input": [
"2 3 6 18\n"
],
"output": [
"3\n"
]
}
|
3,915 | 9 |
Many modern text editors automatically check the spelling of the user's text. Some editors even suggest how to correct typos.
In this problem your task to implement a small functionality to correct two types of typos in a word. We will assume that three identical letters together is a typo (for example, word "helllo" contains a typo). Besides, a couple of identical letters immediately followed by another couple of identical letters is a typo too (for example, words "helloo" and "wwaatt" contain typos).
Write a code that deletes the minimum number of letters from a word, correcting described typos in the word. You are allowed to delete letters from both ends and from the middle of the word.
Input
The single line of the input contains word s, its length is from 1 to 200000 characters. The given word s consists of lowercase English letters.
Output
Print such word t that it doesn't contain any typos described in the problem statement and is obtained from s by deleting the least number of letters.
If there are multiple solutions, print any of them.
Examples
Input
helloo
Output
hello
Input
woooooow
Output
woow
Note
The second valid answer to the test from the statement is "heloo".
|
def go():
o = ''
for c in input():
if len(o) > 2 and o[-1] == c and o[-2] == o[-3]:
continue
if len(o) > 1 and o[-2] == o[-1] == c:
continue
o += c
return o
print(go())
|
{
"input": [
"woooooow\n",
"helloo\n"
],
"output": [
"woow\n",
"hello\n"
]
}
|
3,916 | 8 |
George decided to prepare a Codesecrof round, so he has prepared m problems for the round. Let's number the problems with integers 1 through m. George estimates the i-th problem's complexity by integer bi.
To make the round good, he needs to put at least n problems there. Besides, he needs to have at least one problem with complexity exactly a1, at least one with complexity exactly a2, ..., and at least one with complexity exactly an. Of course, the round can also have problems with other complexities.
George has a poor imagination. It's easier for him to make some already prepared problem simpler than to come up with a new one and prepare it. George is magnificent at simplifying problems. He can simplify any already prepared problem with complexity c to any positive integer complexity d (c β₯ d), by changing limits on the input data.
However, nothing is so simple. George understood that even if he simplifies some problems, he can run out of problems for a good round. That's why he decided to find out the minimum number of problems he needs to come up with in addition to the m he's prepared in order to make a good round. Note that George can come up with a new problem of any complexity.
Input
The first line contains two integers n and m (1 β€ n, m β€ 3000) β the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers a1, a2, ..., an (1 β€ a1 < a2 < ... < an β€ 106) β the requirements for the complexity of the problems in a good round. The third line contains space-separated integers b1, b2, ..., bm (1 β€ b1 β€ b2... β€ bm β€ 106) β the complexities of the problems prepared by George.
Output
Print a single integer β the answer to the problem.
Examples
Input
3 5
1 2 3
1 2 2 3 3
Output
0
Input
3 5
1 2 3
1 1 1 1 1
Output
2
Input
3 1
2 3 4
1
Output
3
Note
In the first sample the set of the prepared problems meets the requirements for a good round.
In the second sample, it is enough to come up with and prepare two problems with complexities 2 and 3 to get a good round.
In the third sample it is very easy to get a good round if come up with and prepare extra problems with complexities: 2, 3, 4.
|
def f(): return [int(i) for i in input().split()]
[n, m], a, b = f(), f(), f()
for ai in a:
for bi in b:
if ai <= bi:
n -= 1
b.remove(bi)
break
print(n if n > 0 else 0)
|
{
"input": [
"3 5\n1 2 3\n1 1 1 1 1\n",
"3 1\n2 3 4\n1\n",
"3 5\n1 2 3\n1 2 2 3 3\n"
],
"output": [
"2\n",
"3\n",
"0\n"
]
}
|
3,917 | 7 |
It's that time of the year when the Russians flood their countryside summer cottages (dachas) and the bus stop has a lot of people. People rarely go to the dacha on their own, it's usually a group, so the people stand in queue by groups.
The bus stop queue has n groups of people. The i-th group from the beginning has ai people. Every 30 minutes an empty bus arrives at the bus stop, it can carry at most m people. Naturally, the people from the first group enter the bus first. Then go the people from the second group and so on. Note that the order of groups in the queue never changes. Moreover, if some group cannot fit all of its members into the current bus, it waits for the next bus together with other groups standing after it in the queue.
Your task is to determine how many buses is needed to transport all n groups to the dacha countryside.
Input
The first line contains two integers n and m (1 β€ n, m β€ 100). The next line contains n integers: a1, a2, ..., an (1 β€ ai β€ m).
Output
Print a single integer β the number of buses that is needed to transport all n groups to the dacha countryside.
Examples
Input
4 3
2 3 2 1
Output
3
Input
3 4
1 2 1
Output
1
|
def f(a,b,c):
if not c:return 0 if a==b else 1
if c[0]>a:return 1+f(b,b,c)
return f(a-c[0],b,c[1:])
a=int(input().split()[1])
b=list(map(int,input().split()))
print(f(a,a,b))
|
{
"input": [
"3 4\n1 2 1\n",
"4 3\n2 3 2 1\n"
],
"output": [
"1\n",
"3\n"
]
}
|
3,918 | 7 |
A triangular number is the number of dots in an equilateral triangle uniformly filled with dots. For example, three dots can be arranged in a triangle; thus three is a triangular number. The n-th triangular number is the number of dots in a triangle with n dots on a side. <image>. You can learn more about these numbers from Wikipedia (http://en.wikipedia.org/wiki/Triangular_number).
Your task is to find out if a given integer is a triangular number.
Input
The first line contains the single number n (1 β€ n β€ 500) β the given integer.
Output
If the given integer is a triangular number output YES, otherwise output NO.
Examples
Input
1
Output
YES
Input
2
Output
NO
Input
3
Output
YES
|
def check(n):
for i in range(1,501):
if i*(i+1)//2==n:
return "YES"
return "NO"
n=int(input())
print(check(n))
|
{
"input": [
"2\n",
"3\n",
"1\n"
],
"output": [
"NO\n",
"YES\n",
"YES\n"
]
}
|
3,919 | 7 |
Let's define a forest as a non-directed acyclic graph (also without loops and parallel edges). One day Misha played with the forest consisting of n vertices. For each vertex v from 0 to n - 1 he wrote down two integers, degreev and sv, were the first integer is the number of vertices adjacent to vertex v, and the second integer is the XOR sum of the numbers of vertices adjacent to v (if there were no adjacent vertices, he wrote down 0).
Next day Misha couldn't remember what graph he initially had. Misha has values degreev and sv left, though. Help him find the number of edges and the edges of the initial graph. It is guaranteed that there exists a forest that corresponds to the numbers written by Misha.
Input
The first line contains integer n (1 β€ n β€ 216), the number of vertices in the graph.
The i-th of the next lines contains numbers degreei and si (0 β€ degreei β€ n - 1, 0 β€ si < 216), separated by a space.
Output
In the first line print number m, the number of edges of the graph.
Next print m lines, each containing two distinct numbers, a and b (0 β€ a β€ n - 1, 0 β€ b β€ n - 1), corresponding to edge (a, b).
Edges can be printed in any order; vertices of the edge can also be printed in any order.
Examples
Input
3
2 3
1 0
1 0
Output
2
1 0
2 0
Input
2
1 1
1 0
Output
1
0 1
Note
The XOR sum of numbers is the result of bitwise adding numbers modulo 2. This operation exists in many modern programming languages. For example, in languages C++, Java and Python it is represented as "^", and in Pascal β as "xor".
|
def main():
n, l, ones, j = int(input()), [], [], 0
for i in range(n):
degree, s = map(int, input().split())
l.append((degree, s))
j += degree
if degree == 1:
ones.append(i)
print(j // 2)
while ones:
i = ones.pop()
degree, j = l[i]
if degree == 1:
print(i, j)
degree, s = l[j]
s ^= i
degree -= 1
l[j] = degree, s
if degree == 1:
ones.append(j)
if __name__ == '__main__':
main()
|
{
"input": [
"2\n1 1\n1 0\n",
"3\n2 3\n1 0\n1 0\n"
],
"output": [
"1\n0 1\n",
"2\n1 0\n2 0\n"
]
}
|
3,920 | 10 |
The clique problem is one of the most well-known NP-complete problems. Under some simplification it can be formulated as follows. Consider an undirected graph G. It is required to find a subset of vertices C of the maximum size such that any two of them are connected by an edge in graph G. Sounds simple, doesn't it? Nobody yet knows an algorithm that finds a solution to this problem in polynomial time of the size of the graph. However, as with many other NP-complete problems, the clique problem is easier if you consider a specific type of a graph.
Consider n distinct points on a line. Let the i-th point have the coordinate xi and weight wi. Let's form graph G, whose vertices are these points and edges connect exactly the pairs of points (i, j), such that the distance between them is not less than the sum of their weights, or more formally: |xi - xj| β₯ wi + wj.
Find the size of the maximum clique in such graph.
Input
The first line contains the integer n (1 β€ n β€ 200 000) β the number of points.
Each of the next n lines contains two numbers xi, wi (0 β€ xi β€ 109, 1 β€ wi β€ 109) β the coordinate and the weight of a point. All xi are different.
Output
Print a single number β the number of vertexes in the maximum clique of the given graph.
Examples
Input
4
2 3
3 1
6 1
0 2
Output
3
Note
If you happen to know how to solve this problem without using the specific properties of the graph formulated in the problem statement, then you are able to get a prize of one million dollars!
The picture for the sample test.
<image>
|
def on(l1, l2):
return(abs(l1[0]-l2[0])>=l1[1]+l2[1])
n = int(input())
inf = []
for i in range(n):
a,b = map(int,input().split())
inf.append([a+b,a-b])
inf.sort()
res = 1
last = 0
for i in range(1,n):
if inf[i][1] >= inf[last][0]:
res+=1
last = i
print(res)
|
{
"input": [
"4\n2 3\n3 1\n6 1\n0 2\n"
],
"output": [
"3"
]
}
|
3,921 | 8 |
Let's define the permutation of length n as an array p = [p1, p2, ..., pn] consisting of n distinct integers from range from 1 to n. We say that this permutation maps value 1 into the value p1, value 2 into the value p2 and so on.
Kyota Ootori has just learned about cyclic representation of a permutation. A cycle is a sequence of numbers such that each element of this sequence is being mapped into the next element of this sequence (and the last element of the cycle is being mapped into the first element of the cycle). The cyclic representation is a representation of p as a collection of cycles forming p. For example, permutation p = [4, 1, 6, 2, 5, 3] has a cyclic representation that looks like (142)(36)(5) because 1 is replaced by 4, 4 is replaced by 2, 2 is replaced by 1, 3 and 6 are swapped, and 5 remains in place.
Permutation may have several cyclic representations, so Kyoya defines the standard cyclic representation of a permutation as follows. First, reorder the elements within each cycle so the largest element is first. Then, reorder all of the cycles so they are sorted by their first element. For our example above, the standard cyclic representation of [4, 1, 6, 2, 5, 3] is (421)(5)(63).
Now, Kyoya notices that if we drop the parenthesis in the standard cyclic representation, we get another permutation! For instance, [4, 1, 6, 2, 5, 3] will become [4, 2, 1, 5, 6, 3].
Kyoya notices that some permutations don't change after applying operation described above at all. He wrote all permutations of length n that do not change in a list in lexicographic order. Unfortunately, his friend Tamaki Suoh lost this list. Kyoya wishes to reproduce the list and he needs your help. Given the integers n and k, print the permutation that was k-th on Kyoya's list.
Input
The first line will contain two integers n, k (1 β€ n β€ 50, 1 β€ k β€ min{1018, l} where l is the length of the Kyoya's list).
Output
Print n space-separated integers, representing the permutation that is the answer for the question.
Examples
Input
4 3
Output
1 3 2 4
Input
10 1
Output
1 2 3 4 5 6 7 8 9 10
Note
The standard cycle representation is (1)(32)(4), which after removing parenthesis gives us the original permutation. The first permutation on the list would be [1, 2, 3, 4], while the second permutation would be [1, 2, 4, 3].
|
def F(n):
a,b = 1,0
for i in range(n):
a,b = b,a+b
return b
def ans(n,k):
if n == 0:
return []
elif n == 1:
return [1]
elif k > F(n):
return [2,1] + [i+2 for i in ans(n-2,k-F(n))]
else:
return [1] + [i+1 for i in ans(n-1,k)]
n,k = map(int,input().split())
print(' '.join([str(i) for i in ans(n,k)]))
|
{
"input": [
"10 1\n",
"4 3\n"
],
"output": [
"1 2 3 4 5 6 7 8 9 10 ",
"1 3 2 4 "
]
}
|
3,922 | 7 |
Meg the Rabbit decided to do something nice, specifically β to determine the shortest distance between two points on the surface of our planet. But Meg... what can you say, she wants everything simple. So, she already regards our planet as a two-dimensional circle. No, wait, it's even worse β as a square of side n. Thus, the task has been reduced to finding the shortest path between two dots on a square (the path should go through the square sides). To simplify the task let us consider the vertices of the square to lie at points whose coordinates are: (0, 0), (n, 0), (0, n) and (n, n).
Input
The single line contains 5 space-separated integers: n, x1, y1, x2, y2 (1 β€ n β€ 1000, 0 β€ x1, y1, x2, y2 β€ n) which correspondingly represent a side of the square, the coordinates of the first point and the coordinates of the second point. It is guaranteed that the points lie on the sides of the square.
Output
You must print on a single line the shortest distance between the points.
Examples
Input
2 0 0 1 0
Output
1
Input
2 0 1 2 1
Output
4
Input
100 0 0 100 100
Output
200
|
def f(x, y, n): return x + y if y == 0 or x == n else 4 * n - x - y
n, x1, y1, x2, y2 = map(int, input().split())
d = abs(f(x1, y1, n) - f(x2, y2, n))
print(min(d, 4 * n - d))
|
{
"input": [
"2 0 0 1 0\n",
"100 0 0 100 100\n",
"2 0 1 2 1\n"
],
"output": [
"1\n",
"200\n",
"4\n"
]
}
|
3,923 | 8 |
It is a balmy spring afternoon, and Farmer John's n cows are ruminating about link-cut cacti in their stalls. The cows, labeled 1 through n, are arranged so that the i-th cow occupies the i-th stall from the left. However, Elsie, after realizing that she will forever live in the shadows beyond Bessie's limelight, has formed the Mischievous Mess Makers and is plotting to disrupt this beautiful pastoral rhythm. While Farmer John takes his k minute long nap, Elsie and the Mess Makers plan to repeatedly choose two distinct stalls and swap the cows occupying those stalls, making no more than one swap each minute.
Being the meticulous pranksters that they are, the Mischievous Mess Makers would like to know the maximum messiness attainable in the k minutes that they have. We denote as pi the label of the cow in the i-th stall. The messiness of an arrangement of cows is defined as the number of pairs (i, j) such that i < j and pi > pj.
Input
The first line of the input contains two integers n and k (1 β€ n, k β€ 100 000) β the number of cows and the length of Farmer John's nap, respectively.
Output
Output a single integer, the maximum messiness that the Mischievous Mess Makers can achieve by performing no more than k swaps.
Examples
Input
5 2
Output
10
Input
1 10
Output
0
Note
In the first sample, the Mischievous Mess Makers can swap the cows in the stalls 1 and 5 during the first minute, then the cows in stalls 2 and 4 during the second minute. This reverses the arrangement of cows, giving us a total messiness of 10.
In the second sample, there is only one cow, so the maximum possible messiness is 0.
|
def main():
n, k = map(int, input().split())
k = min(k, n // 2)
print(k * (2 * (n - k) - 1))
if __name__ == '__main__':
main()
|
{
"input": [
"5 2\n",
"1 10\n"
],
"output": [
"10\n",
"0\n"
]
}
|
3,924 | 8 |
Barney is standing in a bar and starring at a pretty girl. He wants to shoot her with his heart arrow but he needs to know the distance between him and the girl to make his shot accurate.
<image>
Barney asked the bar tender Carl about this distance value, but Carl was so busy talking to the customers so he wrote the distance value (it's a real number) on a napkin. The problem is that he wrote it in scientific notation. The scientific notation of some real number x is the notation of form AeB, where A is a real number and B is an integer and x = A Γ 10B is true. In our case A is between 0 and 9 and B is non-negative.
Barney doesn't know anything about scientific notation (as well as anything scientific at all). So he asked you to tell him the distance value in usual decimal representation with minimal number of digits after the decimal point (and no decimal point if it is an integer). See the output format for better understanding.
Input
The first and only line of input contains a single string of form a.deb where a, d and b are integers and e is usual character 'e' (0 β€ a β€ 9, 0 β€ d < 10100, 0 β€ b β€ 100) β the scientific notation of the desired distance value.
a and b contain no leading zeros and d contains no trailing zeros (but may be equal to 0). Also, b can not be non-zero if a is zero.
Output
Print the only real number x (the desired distance value) in the only line in its decimal notation.
Thus if x is an integer, print it's integer value without decimal part and decimal point and without leading zeroes.
Otherwise print x in a form of p.q such that p is an integer that have no leading zeroes (but may be equal to zero), and q is an integer that have no trailing zeroes (and may not be equal to zero).
Examples
Input
8.549e2
Output
854.9
Input
8.549e3
Output
8549
Input
0.33e0
Output
0.33
|
from decimal import Decimal
def isint(n):
return n == int(n)
s = input()
ss = Decimal(s)
if isint(ss):
print(int(ss))
else:
print(ss)
|
{
"input": [
"8.549e3\n",
"0.33e0\n",
"8.549e2\n"
],
"output": [
"8549\n",
"0.33\n",
"854.9\n"
]
}
|
3,925 | 10 |
You are given a rectangular table 3 Γ n. Each cell contains an integer. You can move from one cell to another if they share a side.
Find such path from the upper left cell to the bottom right cell of the table that doesn't visit any of the cells twice, and the sum of numbers written in the cells of this path is maximum possible.
Input
The first line contains an integer n (1 β€ n β€ 105) β the number of columns in the table.
Next three lines contain n integers each β the description of the table. The j-th number in the i-th line corresponds to the cell aij ( - 109 β€ aij β€ 109) of the table.
Output
Output the maximum sum of numbers on a path from the upper left cell to the bottom right cell of the table, that doesn't visit any of the cells twice.
Examples
Input
3
1 1 1
1 -1 1
1 1 1
Output
7
Input
5
10 10 10 -1 -1
-1 10 10 10 10
-1 10 10 10 10
Output
110
Note
The path for the first example:
<image>
The path for the second example:
<image>
|
import sys
from array import array # noqa: F401
import typing as Tp # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def output(*args):
sys.stdout.buffer.write(
('\n'.join(map(str, args)) + '\n').encode('utf-8')
)
def main():
n = int(input())
a = [list(map(float, input().split())) for _ in range(3)]
dp = [[[-1e18] * 2 for _ in range(3)] for _ in range(n + 1)]
dp[0][0][0] = 0.0
for i in range(n):
for j in range(3):
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][0] + a[j][i])
if j > 0:
dp[i + 1][j - 1][0] = max(dp[i + 1][j - 1][0], dp[i][j][0] + a[j][i] + a[j - 1][i])
if j < 2:
dp[i + 1][j + 1][0] = max(dp[i + 1][j + 1][0], dp[i][j][0] + a[j][i] + a[j + 1][i])
dp[i + 1][0][1] = max(
dp[i + 1][0][1],
dp[i][0][0] + a[0][i] + a[1][i] + a[2][i],
dp[i][0][1] + a[0][i] + a[1][i] + a[2][i]
)
dp[i + 1][2][0] = max(
dp[i + 1][2][0],
dp[i][0][0] + a[0][i] + a[1][i] + a[2][i],
dp[i][0][1] + a[0][i] + a[1][i] + a[2][i]
)
dp[i + 1][2][1] = max(
dp[i + 1][2][1],
dp[i][2][0] + a[0][i] + a[1][i] + a[2][i],
dp[i][2][1] + a[0][i] + a[1][i] + a[2][i]
)
dp[i + 1][0][0] = max(
dp[i + 1][0][0],
dp[i][2][0] + a[0][i] + a[1][i] + a[2][i],
dp[i][2][1] + a[0][i] + a[1][i] + a[2][i]
)
print(round(dp[-1][2][0]))
if __name__ == '__main__':
main()
|
{
"input": [
"3\n1 1 1\n1 -1 1\n1 1 1\n",
"5\n10 10 10 -1 -1\n-1 10 10 10 10\n-1 10 10 10 10\n"
],
"output": [
"7",
"110"
]
}
|
3,926 | 11 |
It can be shown that any positive integer x can be uniquely represented as x = 1 + 2 + 4 + ... + 2k - 1 + r, where k and r are integers, k β₯ 0, 0 < r β€ 2k. Let's call that representation prairie partition of x.
For example, the prairie partitions of 12, 17, 7 and 1 are:
12 = 1 + 2 + 4 + 5,
17 = 1 + 2 + 4 + 8 + 2,
7 = 1 + 2 + 4,
1 = 1.
Alice took a sequence of positive integers (possibly with repeating elements), replaced every element with the sequence of summands in its prairie partition, arranged the resulting numbers in non-decreasing order and gave them to Borys. Now Borys wonders how many elements Alice's original sequence could contain. Find all possible options!
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of numbers given from Alice to Borys.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 1012; a1 β€ a2 β€ ... β€ an) β the numbers given from Alice to Borys.
Output
Output, in increasing order, all possible values of m such that there exists a sequence of positive integers of length m such that if you replace every element with the summands in its prairie partition and arrange the resulting numbers in non-decreasing order, you will get the sequence given in the input.
If there are no such values of m, output a single integer -1.
Examples
Input
8
1 1 2 2 3 4 5 8
Output
2
Input
6
1 1 1 2 2 2
Output
2 3
Input
5
1 2 4 4 4
Output
-1
Note
In the first example, Alice could get the input sequence from [6, 20] as the original sequence.
In the second example, Alice's original sequence could be either [4, 5] or [3, 3, 3].
|
from collections import Counter
from math import log2
def can():
seqs_cp = Counter(seqs)
for num in set(nums):
cnt = nums[num]
while cnt != 0 and num < 2 ** 63:
dif = min(cnt, seqs_cp[num])
cnt -= dif
seqs_cp[num] -= dif
num *= 2
if cnt > 0:
return False
return True
n = int(input())
seq = list(map(int, input().split()))
cnt = Counter(seq)
nums = Counter(seq)
seqs = Counter()
cur_cnt = cnt[1]
cur_pow = 1
while cur_cnt != 0:
nums[cur_pow] -= cur_cnt
cur_pow *= 2
if cur_cnt > cnt[cur_pow]:
seqs[cur_pow // 2] = cur_cnt - cnt[cur_pow]
cur_cnt = cnt[cur_pow]
for num in set(nums):
addition = nums[num]
nums[num] = 0
nums[2 ** int(log2(num))] += addition
# remove elements with zero count
nums -= Counter()
seqs -= Counter()
cur_len = sum(seqs[num] for num in set(seqs))
res = []
cur_pow = 1
while can():
res.append(cur_len)
while seqs[cur_pow] == 0 and cur_pow <= 2 ** 63:
cur_pow *= 2
if cur_pow > 2 ** 63:
break
other_pow = 1
while other_pow <= cur_pow:
nums[other_pow] += 1
other_pow *= 2
seqs[cur_pow] -= 1
cur_len -= 1
print(-1 if len(res) == 0 else ' '.join(map(str, reversed(res))))
|
{
"input": [
"5\n1 2 4 4 4\n",
"6\n1 1 1 2 2 2\n",
"8\n1 1 2 2 3 4 5 8\n"
],
"output": [
"-1\n",
"2 3\n",
"2\n"
]
}
|
3,927 | 8 |
One day Nikita found the string containing letters "a" and "b" only.
Nikita thinks that string is beautiful if it can be cut into 3 strings (possibly empty) without changing the order of the letters, where the 1-st and the 3-rd one contain only letters "a" and the 2-nd contains only letters "b".
Nikita wants to make the string beautiful by removing some (possibly none) of its characters, but without changing their order. What is the maximum length of the string he can get?
Input
The first line contains a non-empty string of length not greater than 5 000 containing only lowercase English letters "a" and "b".
Output
Print a single integer β the maximum possible size of beautiful string Nikita can get.
Examples
Input
abba
Output
4
Input
bab
Output
2
Note
It the first sample the string is already beautiful.
In the second sample he needs to delete one of "b" to make it beautiful.
|
s = input()
a = 0
ab = 0
aba = 0
def max(a, b):
if a > b:
return a
return b
for i in range(len(s)):
c = s[i]
if c == 'a':
a += 1
aba = max(ab, aba) + 1
else:
ab = max(a, ab) + 1
print(max(ab, max(a, aba)))
|
{
"input": [
"bab\n",
"abba\n"
],
"output": [
"2\n",
"4\n"
]
}
|
3,928 | 9 |
You are given a permutation p of length n. Remove one element from permutation to make the number of records the maximum possible.
We remind that in a sequence of numbers a1, a2, ..., ak the element ai is a record if for every integer j (1 β€ j < i) the following holds: aj < ai.
Input
The first line contains the only integer n (1 β€ n β€ 105) β the length of the permutation.
The second line contains n integers p1, p2, ..., pn (1 β€ pi β€ n) β the permutation. All the integers are distinct.
Output
Print the only integer β the element that should be removed to make the number of records the maximum possible. If there are multiple such elements, print the smallest one.
Examples
Input
1
1
Output
1
Input
5
5 1 2 3 4
Output
5
Note
In the first example the only element can be removed.
|
def zero():
return 0
from collections import defaultdict
n = int(input())
p = [int(i) for i in input().split()]
c=defaultdict(zero)
a,b=0,0
for i in range(n):
if(p[i]>a):
b=a
a=p[i]
c[p[i]]-=1
elif p[i]>b:
b=p[i]
c[a]+=1
res=1
for i in range(2,n+1):
if(c[i]>c[res]):
res=i
print(res)
|
{
"input": [
"1\n1\n",
"5\n5 1 2 3 4\n"
],
"output": [
"1\n",
"5\n"
]
}
|
3,929 | 7 |
Alice and Bob begin their day with a quick game. They first choose a starting number X0 β₯ 3 and try to reach one million by the process described below.
Alice goes first and then they take alternating turns. In the i-th turn, the player whose turn it is selects a prime number smaller than the current number, and announces the smallest multiple of this prime number that is not smaller than the current number.
Formally, he or she selects a prime p < Xi - 1 and then finds the minimum Xi β₯ Xi - 1 such that p divides Xi. Note that if the selected prime p already divides Xi - 1, then the number does not change.
Eve has witnessed the state of the game after two turns. Given X2, help her determine what is the smallest possible starting number X0. Note that the players don't necessarily play optimally. You should consider all possible game evolutions.
Input
The input contains a single integer X2 (4 β€ X2 β€ 106). It is guaranteed that the integer X2 is composite, that is, is not prime.
Output
Output a single integer β the minimum possible X0.
Examples
Input
14
Output
6
Input
20
Output
15
Input
8192
Output
8191
Note
In the first test, the smallest possible starting number is X0 = 6. One possible course of the game is as follows:
* Alice picks prime 5 and announces X1 = 10
* Bob picks prime 7 and announces X2 = 14.
In the second case, let X0 = 15.
* Alice picks prime 2 and announces X1 = 16
* Bob picks prime 5 and announces X2 = 20.
|
def lpf(n,m=0,i=2):
while i*i<=n:
if n%i:i+=1
else:n//=i
return m-n
x=int(input())
a=x
for i in range(lpf(x,x+1),x+1):
if lpf(i,i+1)>=3:a=min(lpf(i,i+1),a)
print(a)
|
{
"input": [
"14\n",
"8192\n",
"20\n"
],
"output": [
"6",
"8191",
"15"
]
}
|
3,930 | 9 |
Oleg writes down the history of the days he lived. For each day he decides if it was good or bad. Oleg calls a non-empty sequence of days a zebra, if it starts with a bad day, ends with a bad day, and good and bad days are alternating in it. Let us denote bad days as 0 and good days as 1. Then, for example, sequences of days 0, 010, 01010 are zebras, while sequences 1, 0110, 0101 are not.
Oleg tells you the story of days he lived in chronological order in form of string consisting of 0 and 1. Now you are interested if it is possible to divide Oleg's life history into several subsequences, each of which is a zebra, and the way it can be done. Each day must belong to exactly one of the subsequences. For each of the subsequences, days forming it must be ordered chronologically. Note that subsequence does not have to be a group of consecutive days.
Input
In the only line of input data there is a non-empty string s consisting of characters 0 and 1, which describes the history of Oleg's life. Its length (denoted as |s|) does not exceed 200 000 characters.
Output
If there is a way to divide history into zebra subsequences, in the first line of output you should print an integer k (1 β€ k β€ |s|), the resulting number of subsequences. In the i-th of following k lines first print the integer li (1 β€ li β€ |s|), which is the length of the i-th subsequence, and then li indices of days forming the subsequence. Indices must follow in ascending order. Days are numbered starting from 1. Each index from 1 to n must belong to exactly one subsequence. If there is no way to divide day history into zebra subsequences, print -1.
Subsequences may be printed in any order. If there are several solutions, you may print any of them. You do not have to minimize nor maximize the value of k.
Examples
Input
0010100
Output
3
3 1 3 4
3 2 5 6
1 7
Input
111
Output
-1
|
def read_int():
return int(input())
def read_str():
return input()
def read_list(t=int):
return list(map(t, input().split()))
def print_list(x):
print(len(x), ' '.join(map(str, x)))
# ------------------------------
def work(num_seqs):
ans = [[] for i in range(num_seqs)]
need = {
'0': deque([]),
'1': deque([])
}
need['0'].extend(range(num_seqs))
for i in range(len(s)):
if not len(need[s[i]]):
return False
si = need[s[i]].popleft()
need[chr(ord('0')+ord('1')-ord(s[i]))].append(si)
ans[si].append(i+1)
return ans
# ------------------------------
from collections import deque
s = read_str()
num_seqs = s.count('0') - s.count('1')
if num_seqs <= 0:
print(-1)
else:
ans = work(num_seqs)
if not work(num_seqs):
print(-1)
else:
print(num_seqs)
for seq in ans:
print_list(seq)
|
{
"input": [
"111\n",
"0010100\n"
],
"output": [
"-1\n",
"3\n1 1\n5 2 3 4 5 6\n1 7\n"
]
}
|
3,931 | 12 |
In BerSoft n programmers work, the programmer i is characterized by a skill r_i.
A programmer a can be a mentor of a programmer b if and only if the skill of the programmer a is strictly greater than the skill of the programmer b (r_a > r_b) and programmers a and b are not in a quarrel.
You are given the skills of each programmers and a list of k pairs of the programmers, which are in a quarrel (pairs are unordered). For each programmer i, find the number of programmers, for which the programmer i can be a mentor.
Input
The first line contains two integers n and k (2 β€ n β€ 2 β
10^5, 0 β€ k β€ min(2 β
10^5, (n β
(n - 1))/(2))) β total number of programmers and number of pairs of programmers which are in a quarrel.
The second line contains a sequence of integers r_1, r_2, ..., r_n (1 β€ r_i β€ 10^{9}), where r_i equals to the skill of the i-th programmer.
Each of the following k lines contains two distinct integers x, y (1 β€ x, y β€ n, x β y) β pair of programmers in a quarrel. The pairs are unordered, it means that if x is in a quarrel with y then y is in a quarrel with x. Guaranteed, that for each pair (x, y) there are no other pairs (x, y) and (y, x) in the input.
Output
Print n integers, the i-th number should be equal to the number of programmers, for which the i-th programmer can be a mentor. Programmers are numbered in the same order that their skills are given in the input.
Examples
Input
4 2
10 4 10 15
1 2
4 3
Output
0 0 1 2
Input
10 4
5 4 1 5 4 3 7 1 2 5
4 6
2 1
10 8
3 5
Output
5 4 0 5 3 3 9 0 2 5
Note
In the first example, the first programmer can not be mentor of any other (because only the second programmer has a skill, lower than first programmer skill, but they are in a quarrel). The second programmer can not be mentor of any other programmer, because his skill is minimal among others. The third programmer can be a mentor of the second programmer. The fourth programmer can be a mentor of the first and of the second programmers. He can not be a mentor of the third programmer, because they are in a quarrel.
|
def ke(i):
return a[i]
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=[]
for i in range(n):
b.append(i)
b.sort(key=ke)
ans=[0]*n
k=0
for i in range(1,n):
if a[b[i]]==a[b[i-1]]:
k+=1
ans[b[i]]=i-k
else:
k=0
ans[b[i]]=i
for i in range(m):
r1,r2=map(int,input().split())
if (a[r1-1]>a[r2-1]):
ans[r1-1]-=1
elif a[r1-1]<a[r2-1]:
ans[r2-1]-=1
for i in ans:
print(i, end=' ')
|
{
"input": [
"10 4\n5 4 1 5 4 3 7 1 2 5\n4 6\n2 1\n10 8\n3 5\n",
"4 2\n10 4 10 15\n1 2\n4 3\n"
],
"output": [
"5 4 0 5 3 3 9 0 2 5 ",
"0 0 1 2 "
]
}
|
3,932 | 12 |
Natasha travels around Mars in the Mars rover. But suddenly it broke down, namely β the logical scheme inside it. The scheme is an undirected tree (connected acyclic graph) with a root in the vertex 1, in which every leaf (excluding root) is an input, and all other vertices are logical elements, including the root, which is output. One bit is fed to each input. One bit is returned at the output.
There are four types of logical elements: [AND](https://en.wikipedia.org/wiki/Logical_conjunction) (2 inputs), [OR](https://en.wikipedia.org/wiki/Logical_disjunction) (2 inputs), [XOR](https://en.wikipedia.org/wiki/Exclusive_or) (2 inputs), [NOT](https://en.wikipedia.org/wiki/Negation) (1 input). Logical elements take values from their direct descendants (inputs) and return the result of the function they perform. Natasha knows the logical scheme of the Mars rover, as well as the fact that only one input is broken. In order to fix the Mars rover, she needs to change the value on this input.
For each input, determine what the output will be if Natasha changes this input.
Input
The first line contains a single integer n (2 β€ n β€ 10^6) β the number of vertices in the graph (both inputs and elements).
The i-th of the next n lines contains a description of i-th vertex: the first word "AND", "OR", "XOR", "NOT" or "IN" (means the input of the scheme) is the vertex type. If this vertex is "IN", then the value of this input follows (0 or 1), otherwise follow the indices of input vertices of this element: "AND", "OR", "XOR" have 2 inputs, whereas "NOT" has 1 input. The vertices are numbered from one.
It is guaranteed that input data contains a correct logical scheme with an output produced by the vertex 1.
Output
Print a string of characters '0' and '1' (without quotes) β answers to the problem for each input in the ascending order of their vertex indices.
Example
Input
10
AND 9 4
IN 1
IN 1
XOR 6 5
AND 3 7
IN 0
NOT 10
IN 1
IN 1
AND 2 8
Output
10110
Note
The original scheme from the example (before the input is changed):
<image>
Green indicates bits '1', yellow indicates bits '0'.
If Natasha changes the input bit 2 to 0, then the output will be 1.
If Natasha changes the input bit 3 to 0, then the output will be 0.
If Natasha changes the input bit 6 to 1, then the output will be 1.
If Natasha changes the input bit 8 to 0, then the output will be 1.
If Natasha changes the input bit 9 to 0, then the output will be 0.
|
AND = "AND"
OR = "OR"
XOR = "XOR"
NOT = "NOT"
IN = "IN"
OPS = {
AND: AND,
OR: OR,
XOR: XOR,
NOT: NOT,
}
class Node:
def __init__(self, num):
self.num = num
self.op = None
self.parent = None
self.input_1 = None
self.input_2 = None
self.orig_value = None
self.root_value_if_changed = None
@property
def children(self):
if self.op == IN:
return []
elif self.op == NOT:
return [self.input_1]
else:
return [self.input_1, self.input_2]
def can_compute(self):
if self.op == IN:
return True
if self.op == NOT:
return self.input_1.orig_value is not None
return self.input_1.orig_value is not None and self.input_2.orig_value is not None
def compute(self):
if self.op == IN:
return self.orig_value
assert self.can_compute()
if self.op == NOT:
return not self.input_1.orig_value
elif self.op == AND:
return self.input_1.orig_value and self.input_2.orig_value
elif self.op == OR:
return self.input_1.orig_value or self.input_2.orig_value
else:
return self.input_1.orig_value != self.input_2.orig_value
def set_input(self, a):
self.input_1 = a
a.parent = self
def set_inputs(self, a, b):
self.input_1 = a
self.input_2 = b
a.parent = self
b.parent = self
def compute_orig_values(root):
stack = [root]
while len(stack) > 0:
node: Node = stack[-1]
if node.can_compute():
node.orig_value = node.compute()
stack.pop()
else:
stack.extend(node.children)
def compute_if_change(root: Node):
def comp_if_changed(node: Node):
if node is root:
return not node.orig_value
orig = node.orig_value
node.orig_value = not node.orig_value
res = node.parent.compute()
node.orig_value = orig
if res == node.parent.orig_value:
return root.orig_value
else:
return node.parent.root_value_if_changed
stack = [root]
while len(stack) > 0:
node: Node = stack.pop()
node.root_value_if_changed = comp_if_changed(node)
stack.extend(node.children)
def main():
import sys
n = int(sys.stdin.readline())
nodes = {i: Node(i) for i in range(1, n + 1)}
assert len(nodes) == n
for i in range(1, n + 1):
toks = sys.stdin.readline().strip().split(" ")
node = nodes[i]
if len(toks) == 2:
if toks[0] == IN:
node.op = IN
node.orig_value = toks[1] == "1"
else:
node.op = NOT
node.set_input(nodes[int(toks[1])])
else:
node.op = OPS[toks[0]]
a, b = map(int, toks[1:])
a = nodes[a]
b = nodes[b]
node.set_inputs(a, b)
root: Node = nodes[1]
compute_orig_values(root)
compute_if_change(root)
ret = []
for i in range(1, n + 1):
node = nodes[i]
if node.op == IN:
ret.append(int(node.root_value_if_changed))
ret = "".join(str(x) for x in ret)
print(ret)
if __name__ == '__main__':
main()
|
{
"input": [
"10\nAND 9 4\nIN 1\nIN 1\nXOR 6 5\nAND 3 7\nIN 0\nNOT 10\nIN 1\nIN 1\nAND 2 8\n"
],
"output": [
"10110\n"
]
}
|
3,933 | 7 |
In Disgaea as in most role-playing games, characters have skills that determine the character's ability to use certain weapons or spells. If the character does not have the necessary skill, he cannot use it. The skill level is represented as an integer that increases when you use this skill. Different character classes are characterized by different skills.
Unfortunately, the skills that are uncommon for the given character's class are quite difficult to obtain. To avoid this limitation, there is the so-called transmigration.
Transmigration is reincarnation of the character in a new creature. His soul shifts to a new body and retains part of his experience from the previous life.
As a result of transmigration the new character gets all the skills of the old character and the skill levels are reduced according to the k coefficient (if the skill level was equal to x, then after transmigration it becomes equal to [kx], where [y] is the integral part of y). If some skill's levels are strictly less than 100, these skills are forgotten (the character does not have them any more). After that the new character also gains the skills that are specific for his class, but are new to him. The levels of those additional skills are set to 0.
Thus, one can create a character with skills specific for completely different character classes via transmigrations. For example, creating a mage archer or a thief warrior is possible.
You are suggested to solve the following problem: what skills will the character have after transmigration and what will the levels of those skills be?
Input
The first line contains three numbers n, m and k β the number of skills the current character has, the number of skills specific for the class into which the character is going to transmigrate and the reducing coefficient respectively; n and m are integers, and k is a real number with exactly two digits after decimal point (1 β€ n, m β€ 20, 0.01 β€ k β€ 0.99).
Then follow n lines, each of which describes a character's skill in the form "name exp" β the skill's name and the character's skill level: name is a string and exp is an integer in range from 0 to 9999, inclusive.
Then follow m lines each of which contains names of skills specific for the class, into which the character transmigrates.
All names consist of lowercase Latin letters and their lengths can range from 1 to 20 characters, inclusive. All character's skills have distinct names. Besides the skills specific for the class into which the player transmigrates also have distinct names.
Output
Print on the first line number z β the number of skills the character will have after the transmigration. Then print z lines, on each of which print a skill's name and level, separated by a single space. The skills should be given in the lexicographical order.
Examples
Input
5 4 0.75
axe 350
impaler 300
ionize 80
megafire 120
magicboost 220
heal
megafire
shield
magicboost
Output
6
axe 262
heal 0
impaler 225
magicboost 165
megafire 0
shield 0
|
import sys
from itertools import *
from math import *
def solve():
n, m, k = input().split()
n = int(n)
m = int(m)
k = int(k[2:])
skills = {}
for i in range(n):
name, level = input().split()
level = int(level)
newlevel = (k * level) // 100
if newlevel >= 100:
skills[name] = newlevel
for i in range(m):
name = input()
if name not in skills:
skills[name] = 0
print(len(skills))
ssskills = sorted(skills)
for name in ssskills:
print(name, skills[name])
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
|
{
"input": [
"5 4 0.75\naxe 350\nimpaler 300\nionize 80\nmegafire 120\nmagicboost 220\nheal\nmegafire\nshield\nmagicboost\n"
],
"output": [
"6\naxe 262\nheal 0\nimpaler 225\nmagicboost 165\nmegafire 0\nshield 0\n"
]
}
|
3,934 | 8 |
Chouti and his classmates are going to the university soon. To say goodbye to each other, the class has planned a big farewell party in which classmates, teachers and parents sang and danced.
Chouti remembered that n persons took part in that party. To make the party funnier, each person wore one hat among n kinds of weird hats numbered 1, 2, β¦ n. It is possible that several persons wore hats of the same kind. Some kinds of hats can remain unclaimed by anyone.
After the party, the i-th person said that there were a_i persons wearing a hat differing from his own.
It has been some days, so Chouti forgot all about others' hats, but he is curious about that. Let b_i be the number of hat type the i-th person was wearing, Chouti wants you to find any possible b_1, b_2, β¦, b_n that doesn't contradict with any person's statement. Because some persons might have a poor memory, there could be no solution at all.
Input
The first line contains a single integer n (1 β€ n β€ 10^5), the number of persons in the party.
The second line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ n-1), the statements of people.
Output
If there is no solution, print a single line "Impossible".
Otherwise, print "Possible" and then n integers b_1, b_2, β¦, b_n (1 β€ b_i β€ n).
If there are multiple answers, print any of them.
Examples
Input
3
0 0 0
Output
Possible
1 1 1
Input
5
3 3 2 2 2
Output
Possible
1 1 2 2 2
Input
4
0 1 2 3
Output
Impossible
Note
In the answer to the first example, all hats are the same, so every person will say that there were no persons wearing a hat different from kind 1.
In the answer to the second example, the first and the second person wore the hat with type 1 and all other wore a hat of type 2.
So the first two persons will say there were three persons with hats differing from their own. Similarly, three last persons will say there were two persons wearing a hat different from their own.
In the third example, it can be shown that no solution exists.
In the first and the second example, other possible configurations are possible.
|
n = int(input())
a = list(map(int, input().split()))
def solve():
b = sorted((a[i], i) for i in range(n))
ret = [None] * n
i = 0
cur = 1
while i < n:
same = n - b[i][0]
for j in range(i, i + same):
if j >= n or b[i][0] != b[j][0]:
print('Impossible')
return
ret[b[j][1]] = cur
cur += 1
i += same
print('Possible')
print(*ret)
solve()
|
{
"input": [
"3\n0 0 0\n",
"5\n3 3 2 2 2\n",
"4\n0 1 2 3\n"
],
"output": [
"Possible\n1 1 1 \n",
"Possible\n1 1 2 2 2 \n",
"Impossible\n"
]
}
|
3,935 | 8 |
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
|
def check(x,n):
if(x==n):
return 1
else :
return 0
x1=100004
lis=input()
l=list(map(int,lis.split(' ')))
n=int(l[0])
m=int(l[1])
li=input()
x=list(map(int,li.split(" ")))
#print(x)
a=[0]*(x1)
b=[0]*(x1)
for i in range(0,m):
#x=int(intput())
a[x[i]]=a[x[i]]+1
b[a[x[i]]]=b[a[x[i]]]+1
print(check(b[a[x[i]]],n),end="")
|
{
"input": [
"4 8\n4 1 3 3 2 3 3 3\n",
"3 11\n2 3 1 2 2 2 3 2 2 3 1\n"
],
"output": [
"00001000",
"00100000001"
]
}
|
3,936 | 12 |
Suppose you are given a string s of length n consisting of lowercase English letters. You need to compress it using the smallest possible number of coins.
To compress the string, you have to represent s as a concatenation of several non-empty strings: s = t_{1} t_{2} β¦ t_{k}. The i-th of these strings should be encoded with one of the two ways:
* if |t_{i}| = 1, meaning that the current string consists of a single character, you can encode it paying a coins;
* if t_{i} is a substring of t_{1} t_{2} β¦ t_{i - 1}, then you can encode it paying b coins.
A string x is a substring of a string y if x can be obtained from y by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
So your task is to calculate the minimum possible number of coins you need to spend in order to compress the given string s.
Input
The first line contains three positive integers, separated by spaces: n, a and b (1 β€ n, a, b β€ 5000) β the length of the string, the cost to compress a one-character string and the cost to compress a string that appeared before.
The second line contains a single string s, consisting of n lowercase English letters.
Output
Output a single integer β the smallest possible number of coins you need to spend to compress s.
Examples
Input
3 3 1
aba
Output
7
Input
4 1 1
abcd
Output
4
Input
4 10 1
aaaa
Output
12
Note
In the first sample case, you can set t_{1} = 'a', t_{2} = 'b', t_{3} = 'a' and pay 3 + 3 + 1 = 7 coins, since t_{3} is a substring of t_{1}t_{2}.
In the second sample, you just need to compress every character by itself.
In the third sample, you set t_{1} = t_{2} = 'a', t_{3} = 'aa' and pay 10 + 1 + 1 = 12 coins, since t_{2} is a substring of t_{1} and t_{3} is a substring of t_{1} t_{2}.
|
import sys
sys.setrecursionlimit(10 ** 8)
n, a, b = map(int,input().split())
s = input()
def calc(j):
if (j >= n): return 0
if (dp[j] != -1): return dp[j]
dp[j] = a + calc(j + 1)
lo = j
hi = n
farthest = -1
# finding best string to reach from a given j such that it eist before i using binary search
while (lo < hi):
mid = (lo + hi) // 2
if (s[j:mid + 1] in s[0:j]):
farthest = mid
lo = mid + 1
else:
hi = mid
if (farthest != -1): dp[j] = min(dp[j], b + calc(farthest + 1))
return dp[j]
dp = [-1 for i in range(n + 5)]
print(calc(0))
|
{
"input": [
"4 1 1\nabcd\n",
"4 10 1\naaaa\n",
"3 3 1\naba\n"
],
"output": [
"4",
"12",
"7"
]
}
|
3,937 | 12 |
You are given an array a consisting of 500000 integers (numbered from 1 to 500000). Initially all elements of a are zero.
You have to process two types of queries to this array:
* 1 x y β increase a_x by y;
* 2 x y β compute β_{i β R(x, y)} a_i, where R(x, y) is the set of all integers from 1 to 500000 which have remainder y modulo x.
Can you process all the queries?
Input
The first line contains one integer q (1 β€ q β€ 500000) β the number of queries.
Then q lines follow, each describing a query. The i-th line contains three integers t_i, x_i and y_i (1 β€ t_i β€ 2). If t_i = 1, then it is a query of the first type, 1 β€ x_i β€ 500000, and -1000 β€ y_i β€ 1000. If t_i = 2, then it it a query of the second type, 1 β€ x_i β€ 500000, and 0 β€ y_i < x_i.
It is guaranteed that there will be at least one query of type 2.
Output
For each query of type 2 print one integer β the answer to it.
Example
Input
5
1 3 4
2 3 0
2 4 3
1 4 -4
2 1 0
Output
4
4
0
|
import sys
readline = sys.stdin.buffer.readline
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
def solve():
q = ni()
n = 5 * 10**5
a = [0]*(n + 1)
m = 710
rem = [[0]*m for _ in range(m)]
for _ in range(q):
t, x, y = nm()
if t == 1:
a[x] += y
for p in range(1, m):
rem[p][x%p] += y
else:
if x < m:
print(rem[x][y])
else:
print(sum(a[y::x]))
if __name__ == '__main__':
solve()
# T = ni()
# for _ in range(T):
# solve()
|
{
"input": [
"5\n1 3 4\n2 3 0\n2 4 3\n1 4 -4\n2 1 0\n"
],
"output": [
"4\n4\n0\n"
]
}
|
3,938 | 8 |
You are given n k-digit integers. You have to rearrange the digits in the integers so that the difference between the largest and the smallest number was minimum. Digits should be rearranged by the same rule in all integers.
Input
The first line contains integers n and k β the number and digit capacity of numbers correspondingly (1 β€ n, k β€ 8). Next n lines contain k-digit positive integers. Leading zeroes are allowed both in the initial integers and the integers resulting from the rearranging of digits.
Output
Print a single number: the minimally possible difference between the largest and the smallest number after the digits are rearranged in all integers by the same rule.
Examples
Input
6 4
5237
2753
7523
5723
5327
2537
Output
2700
Input
3 3
010
909
012
Output
3
Input
7 5
50808
36603
37198
44911
29994
42543
50156
Output
20522
Note
In the first sample, if we rearrange the digits in numbers as (3,1,4,2), then the 2-nd and the 4-th numbers will equal 5237 and 2537 correspondingly (they will be maximum and minimum for such order of digits).
In the second sample, if we swap the second digits and the first ones, we get integers 100, 99 and 102.
|
#!/usr/bin/python3
from itertools import permutations
def ap(t, p):
return [t[q] for q in p]
n, k = map(int, input().split())
s = [input() for i in range(n)]
ans = 10 ** 100
for p in permutations(range(k)):
u = [int(''.join(ap(t, p))) for t in s]
ans = min(ans, max(u) - min(u))
print(ans)
|
{
"input": [
"6 4\n5237\n2753\n7523\n5723\n5327\n2537\n",
"7 5\n50808\n36603\n37198\n44911\n29994\n42543\n50156\n",
"3 3\n010\n909\n012\n"
],
"output": [
"2700\n",
"20522\n",
"3\n"
]
}
|
3,939 | 7 |
You are given two positive integers a and b.
In one move, you can change a in the following way:
* Choose any positive odd integer x (x > 0) and replace a with a+x;
* choose any positive even integer y (y > 0) and replace a with a-y.
You can perform as many such operations as you want. You can choose the same numbers x and y in different moves.
Your task is to find the minimum number of moves required to obtain b from a. It is guaranteed that you can always obtain b from a.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^4) β the number of test cases.
Then t test cases follow. Each test case is given as two space-separated integers a and b (1 β€ a, b β€ 10^9).
Output
For each test case, print the answer β the minimum number of moves required to obtain b from a if you can perform any number of moves described in the problem statement. It is guaranteed that you can always obtain b from a.
Example
Input
5
2 3
10 10
2 4
7 4
9 3
Output
1
0
2
2
1
Note
In the first test case, you can just add 1.
In the second test case, you don't need to do anything.
In the third test case, you can add 1 two times.
In the fourth test case, you can subtract 4 and add 1.
In the fifth test case, you can just subtract 6.
|
def addOrSub(a, b):
return 1 + ((a < b) ^ ((a + b) % 2)) if a != b else 0
if __name__ == "__main__":
t = int(input())
for i in range(t):
n, k = map(int, input().split())
print(addOrSub(n, k))
|
{
"input": [
"5\n2 3\n10 10\n2 4\n7 4\n9 3\n"
],
"output": [
"1\n0\n2\n2\n1\n"
]
}
|
3,940 | 11 |
Egor wants to achieve a rating of 1600 points on the well-known chess portal ChessForces and he needs your help!
Before you start solving the problem, Egor wants to remind you how the chess pieces move. Chess rook moves along straight lines up and down, left and right, as many squares as it wants. And when it wants, it can stop. The queen walks in all directions vertically and diagonally at any distance. You can see the examples below.
<image>
To reach the goal, Egor should research the next topic:
There is an N Γ N board. Each cell of the board has a number from 1 to N ^ 2 in it and numbers in all cells are distinct.
In the beginning, some chess figure stands in the cell with the number 1. Note that this cell is already considered as visited. After that every move is determined by the following rules:
1. Among all not visited yet cells to which the figure can get in one move, it goes to the cell that has minimal number.
2. If all accessible cells were already visited and some cells are not yet visited, then the figure is teleported to the not visited cell that has minimal number. If this step happens, the piece pays a fee of 1 vun.
3. If all cells are already visited, the process is stopped.
Egor should find an N Γ N board on which the rook pays strictly less vuns than the queen during the round with this numbering. Help him to find such N Γ N numbered board, or tell that it doesn't exist.
Input
The only line contains one integer N β the size of the board, 1β€ N β€ 500.
Output
The output should contain N lines.
In i-th line output N numbers β numbers on the i-th row of the board. All numbers from 1 to N Γ N must be used exactly once.
On your board rook must pay strictly less vuns than the queen.
If there are no solutions, print -1.
If there are several solutions, you can output any of them.
Examples
Input
1
Output
-1
Input
4
Output
4 3 6 12
7 5 9 15
14 1 11 10
13 8 16 2
Note
In case we have 1 Γ 1 board, both rook and queen do not have a chance to pay fees.
In second sample rook goes through cells 1 β 3 β 4 β 6 β 9 β 5 β 7 β 13 β 2 β 8 β 16 β 11 β 10 β 12 β 15 β (1 vun) β 14.
Queen goes through 1 β 3 β 4 β 2 β 5 β 6 β 9 β 7 β 13 β 8 β 11 β 10 β 12 β 15 β (1 vun) β 14 β (1 vun) β 16.
As a result rook pays 1 vun and queen pays 2 vuns.
|
def main():
L = [[0 for _ in range(501)]for _ in range(501)]
n = int(input())
if(n<=2):
print(-1)
return
lf = 1
rt = n
id = n
cur = 1
direct = 1
cnt = 0
if(n%2==1): direct = -1;cur=n
while(id>0):
if(n==3): break
cnt+=1
L[id][cur]=cnt
if(cur+direct >= lf and cur+direct <=rt): cur+=direct
else: id-=1;direct*=-1
if(id==3): lf = 4
L[1][1]=1+cnt
L[1][2]=7+cnt
L[1][3]=9+cnt
L[2][1]=3+cnt
L[2][2]=2+cnt
L[2][3]=5+cnt
L[3][1]=4+cnt
L[3][2]=8+cnt
L[3][3]=6+cnt
for i in range(1,n+1):
for j in range(1,n+1):
print(L[i][j],end=" ")
print()
main()
|
{
"input": [
"1\n",
"4\n"
],
"output": [
"-1\n",
"4 3 6 12 \n7 5 9 15 \n14 1 11 10 \n13 8 16 2 \n"
]
}
|
3,941 | 8 |
You are given a string s such that each its character is either 1, 2, or 3. You have to choose the shortest contiguous substring of s such that it contains each of these three characters at least once.
A contiguous substring of string s is a string that can be obtained from s by removing some (possibly zero) characters from the beginning of s and some (possibly zero) characters from the end of s.
Input
The first line contains one integer t (1 β€ t β€ 20000) β the number of test cases.
Each test case consists of one line containing the string s (1 β€ |s| β€ 200000). It is guaranteed that each character of s is either 1, 2, or 3.
The sum of lengths of all strings in all test cases does not exceed 200000.
Output
For each test case, print one integer β the length of the shortest contiguous substring of s containing all three types of characters at least once. If there is no such substring, print 0 instead.
Example
Input
7
123
12222133333332
112233
332211
12121212
333333
31121
Output
3
3
4
4
0
0
4
Note
Consider the example test:
In the first test case, the substring 123 can be used.
In the second test case, the substring 213 can be used.
In the third test case, the substring 1223 can be used.
In the fourth test case, the substring 3221 can be used.
In the fifth test case, there is no character 3 in s.
In the sixth test case, there is no character 1 in s.
In the seventh test case, the substring 3112 can be used.
|
def solve(s):
m = {3: -1e9, 1: -1e9, 2 : -1e9};
ans = 1e9;
for i in range(len(s)):
m[int(s[i])] = i;
x = min(m.values());
ans = min(ans, i-x+1);
if ans > len(s) :
print(0);
else :
print(ans);
for _ in range(int(input())) :
s = input()
solve(s);
|
{
"input": [
"7\n123\n12222133333332\n112233\n332211\n12121212\n333333\n31121\n"
],
"output": [
"3\n3\n4\n4\n0\n0\n4\n"
]
}
|
3,942 | 7 |
You are given n strings s_1, s_2, β¦, s_n consisting of lowercase Latin letters.
In one operation you can remove a character from a string s_i and insert it to an arbitrary position in a string s_j (j may be equal to i). You may perform this operation any number of times. Is it possible to make all n strings equal?
Input
The first line contains t (1 β€ t β€ 10): the number of test cases.
The first line of each test case contains a single integer n (1 β€ n β€ 1000): the number of strings.
n lines follow, the i-th line contains s_i (1 β€ \lvert s_i \rvert β€ 1000).
The sum of lengths of all strings in all test cases does not exceed 1000.
Output
If it is possible to make the strings equal, print "YES" (without quotes).
Otherwise, print "NO" (without quotes).
You can output each character in either lowercase or uppercase.
Example
Input
4
2
caa
cbb
3
cba
cba
cbb
4
ccab
cbac
bca
acbcc
4
acb
caf
c
cbafc
Output
YES
NO
YES
NO
Note
In the first test case, you can do the following:
* Remove the third character of the first string and insert it after the second character of the second string, making the two strings "ca" and "cbab" respectively.
* Remove the second character of the second string and insert it after the second character of the first string, making both strings equal to "cab".
In the second test case, it is impossible to make all n strings equal.
|
def solve():
n=int(input())
d={}
for i in range(n):
s=input().strip()
for c in s:
d[c]=d.get(c,0)+1
for i in d:
if d[i]%n:
print("NO")
return
print("YES")
t=int(input())
while t:
solve()
t-=1
|
{
"input": [
"4\n2\ncaa\ncbb\n3\ncba\ncba\ncbb\n4\nccab\ncbac\nbca\nacbcc\n4\nacb\ncaf\nc\ncbafc\n"
],
"output": [
"YES\nNO\nYES\nNO\n"
]
}
|
3,943 | 9 |
This is the easy version of the problem. The difference between the versions is that the easy version has no swap operations. You can make hacks only if all versions of the problem are solved.
Pikachu is a cute and friendly pokΓ©mon living in the wild pikachu herd.
But it has become known recently that infamous team R wanted to steal all these pokΓ©mon! PokΓ©mon trainer Andrew decided to help Pikachu to build a pokΓ©mon army to resist.
First, Andrew counted all the pokΓ©mon β there were exactly n pikachu. The strength of the i-th pokΓ©mon is equal to a_i, and all these numbers are distinct.
As an army, Andrew can choose any non-empty subsequence of pokemons. In other words, Andrew chooses some array b from k indices such that 1 β€ b_1 < b_2 < ... < b_k β€ n, and his army will consist of pokΓ©mons with forces a_{b_1}, a_{b_2}, ..., a_{b_k}.
The strength of the army is equal to the alternating sum of elements of the subsequence; that is, a_{b_1} - a_{b_2} + a_{b_3} - a_{b_4} + ....
Andrew is experimenting with pokΓ©mon order. He performs q operations. In i-th operation Andrew swaps l_i-th and r_i-th pokΓ©mon.
Note: q=0 in this version of the task.
Andrew wants to know the maximal stregth of the army he can achieve with the initial pokΓ©mon placement. He also needs to know the maximal strength after each operation.
Help Andrew and the pokΓ©mon, or team R will realize their tricky plan!
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 β€ t β€ 10^3) denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains two integers n and q (1 β€ n β€ 3 β
10^5, q = 0) denoting the number of pokΓ©mon and number of operations respectively.
The second line contains n distinct positive integers a_1, a_2, ..., a_n (1 β€ a_i β€ n) denoting the strengths of the pokΓ©mon.
i-th of the last q lines contains two positive integers l_i and r_i (1 β€ l_i β€ r_i β€ n) denoting the indices of pokΓ©mon that were swapped in the i-th operation.
It is guaranteed that the sum of n over all test cases does not exceed 3 β
10^5, and the sum of q over all test cases does not exceed 3 β
10^5.
Output
For each test case, print q+1 integers: the maximal strength of army before the swaps and after each swap.
Example
Input
3
3 0
1 3 2
2 0
1 2
7 0
1 2 5 4 3 6 7
Output
3
2
9
Note
In third test case we can build an army in such way: [1 2 5 4 3 6 7], its strength will be 5β3+7=9.
|
def mi():
return map(int, input().split())
for _ in range(int(input())):
n,k = mi()
a = list(mi())
ma,mii = a[-1],0
for i in range(n-1,-1,-1):
ma = max(ma, a[i]-mii)
mii = min(mii, a[i]-ma)
print (max(ma,mii))
|
{
"input": [
"3\n3 0\n1 3 2\n2 0\n1 2\n7 0\n1 2 5 4 3 6 7\n"
],
"output": [
"3\n2\n9\n"
]
}
|
3,944 | 7 |
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
|
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
a = [list(map(int, input())) for i in range(n)]
def add(p):
a[p[0]][p[1]] ^= 1
a[p[2]][p[3]] ^= 1
a[p[4]][p[5]] ^= 1
ans.append(' '.join(map(lambda x: str(x + 1), p)))
ans = []
for i in range(n - 1, 1, -1):
for j in range(m):
if a[i][j]: add((i, j, i - 1, j, i - 1, j + (1 if j < m - 1 else -1)))
for j in range(m - 1, 1, -1):
for i in (0, 1):
if a[i][j]: add((i, j, 0, j - 1, 1, j - 1))
for i in (0, 1):
for j in (0, 1):
if (a[0][0] + a[0][1] + a[1][0] + a[1][1] + a[i][j]) % 2:
add((i ^ 1, j, i, j ^ 1, i ^ 1, j ^ 1))
print(len(ans))
print('\n'.join(ans))
|
{
"input": [
"5\n2 2\n10\n11\n3 3\n011\n101\n110\n4 4\n1111\n0110\n0110\n1111\n5 5\n01011\n11001\n00010\n11011\n10000\n2 3\n011\n101\n"
],
"output": [
"1\n1 1 2 1 2 2\n6\n1 2 2 1 2 2\n1 3 2 2 2 3\n3 1 2 2 3 2\n2 2 3 2 3 3\n2 2 2 3 3 3\n2 2 2 3 3 2\n8\n1 1 1 2 2 1\n1 3 1 4 2 3\n2 1 2 2 3 1\n3 1 4 1 4 2\n3 2 3 3 4 3\n3 4 4 3 4 4\n3 3 4 3 4 4\n3 3 3 4 4 4\n10\n1 2 2 1 2 2\n1 4 2 3 2 4\n1 5 2 4 2 5\n2 3 3 3 3 4\n3 3 4 3 4 4\n4 1 5 1 5 2\n4 2 5 2 5 3\n4 3 5 3 5 4\n4 4 5 4 5 5\n4 4 4 5 5 5\n2\n2 1 1 2 2 2\n1 3 2 2 2 3\n"
]
}
|
3,945 | 7 |
Argus was charged with guarding Io, which is not an ordinary cow. Io is quite an explorer, and she wanders off rather frequently, making Argus' life stressful. So the cowherd decided to construct an enclosed pasture for Io.
There are n trees growing along the river, where Argus tends Io. For this problem, the river can be viewed as the OX axis of the Cartesian coordinate system, and the n trees as points with the y-coordinate equal 0. There is also another tree growing in the point (0, 1).
Argus will tie a rope around three of the trees, creating a triangular pasture. Its exact shape doesn't matter to Io, but its area is crucial to her. There may be many ways for Argus to arrange the fence, but only the ones which result in different areas of the pasture are interesting for Io. Calculate the number of different areas that her pasture may have. Note that the pasture must have nonzero area.
Input
The input consists of multiple test cases. The first line contains an integer t (1 β€ t β€ 100) β the number of test cases. Then t test cases follow, each one is described in two lines.
In the first line of each test case there is a single integer n (1 β€ n β€ 50) denoting the number of trees growing along the river. Next line contains n distinct integers x_1 < x_2 < β¦ < x_{n - 1} < x_n (1 β€ x_i β€ 50), the x-coordinates of trees growing along the river.
Output
In a single line output an integer, the number of different nonzero areas that triangles with trees as vertices may have.
Example
Input
8
4
1 2 4 5
3
1 3 5
3
2 6 8
2
1 2
1
50
5
3 4 5 6 8
3
1 25 26
6
1 2 4 8 16 32
Output
4
2
3
1
0
5
3
15
Note
In the first test case, we have 6 non-degenerate triangles with the following areas: 0.5, 0.5, 1, 1.5, 1.5 and 2. The pasture can have 4 different areas, and thus 4 is the answer.
In the second test case, we have 3 non-degenerate triangles with the following areas: 1, 1 and 2. The pasture can have 2 different areas, so 2 is the answer.
The following two drawings present the situation in the second test case. The blue triangles in the first drawing have area 1. The red triangle in the second drawing has area 2.
<image>
|
def solve():
n=int(input())
a=list(map(int,input().split()))
k=set()
for i in range(n-1):
for j in range(i+1,n):
k.add(a[j]-a[i])
print(len(k))
for _ in range(int(input())):
solve()
|
{
"input": [
"8\n4\n1 2 4 5\n3\n1 3 5\n3\n2 6 8\n2\n1 2\n1\n50\n5\n3 4 5 6 8\n3\n1 25 26\n6\n1 2 4 8 16 32\n"
],
"output": [
"\n4\n2\n3\n1\n0\n5\n3\n15\n"
]
}
|
3,946 | 8 |
You are given a number n (divisible by 3) and an array a[1 ... n]. In one move, you can increase any of the array elements by one. Formally, you choose the index i (1 β€ i β€ n) and replace a_i with a_i + 1. You can choose the same index i multiple times for different moves.
Let's denote by c_0, c_1 and c_2 the number of numbers from the array a that have remainders 0, 1 and 2 when divided by the number 3, respectively. Let's say that the array a has balanced remainders if c_0, c_1 and c_2 are equal.
For example, if n = 6 and a = [0, 2, 5, 5, 4, 8], then the following sequence of moves is possible:
* initially c_0 = 1, c_1 = 1 and c_2 = 4, these values are not equal to each other. Let's increase a_3, now the array a = [0, 2, 6, 5, 4, 8];
* c_0 = 2, c_1 = 1 and c_2 = 3, these values are not equal. Let's increase a_6, now the array a = [0, 2, 6, 5, 4, 9];
* c_0 = 3, c_1 = 1 and c_2 = 2, these values are not equal. Let's increase a_1, now the array a = [1, 2, 6, 5, 4, 9];
* c_0 = 2, c_1 = 2 and c_2 = 2, these values are equal to each other, which means that the array a has balanced remainders.
Find the minimum number of moves needed to make the array a have balanced remainders.
Input
The first line contains one integer t (1 β€ t β€ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (3 β€ n β€ 3 β
10^4) β the length of the array a. It is guaranteed that the number n is divisible by 3.
The next line contains n integers a_1, a_2, β¦, a_n (0 β€ a_i β€ 100).
It is guaranteed that the sum of n over all test cases does not exceed 150 000.
Output
For each test case, output one integer β the minimum number of moves that must be made for the a array to make it have balanced remainders.
Example
Input
4
6
0 2 5 5 4 8
6
2 0 2 1 0 0
9
7 1 3 4 2 10 3 9 6
6
0 1 2 3 4 5
Output
3
1
3
0
Note
The first test case is explained in the statements.
In the second test case, you need to make one move for i=2.
The third test case you need to make three moves:
* the first move: i=9;
* the second move: i=9;
* the third move: i=2.
In the fourth test case, the values c_0, c_1 and c_2 initially equal to each other, so the array a already has balanced remainders.
|
def solve():
n = int(input())
arr = [int(i) for i in input().split()]
c = [0, 0, 0]
for i in arr:
c[i % 3] += 1
it = 0
while c[0] != c[1] or c[0] != c[2] or c[1] != c[2]:
max_c = max(c)
max_i = c.index(max_c)
c[(max_i + 1) % 3] += 1
c[max_i] -= 1
it += 1
print(str(it))
for _ in range(int(input())):
solve()
|
{
"input": [
"4\n6\n0 2 5 5 4 8\n6\n2 0 2 1 0 0\n9\n7 1 3 4 2 10 3 9 6\n6\n0 1 2 3 4 5\n"
],
"output": [
"\n3\n1\n3\n0\n"
]
}
|
3,947 | 11 |
A permutation is a sequence of n integers from 1 to n, in which all the numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was given four integers n, l, r (1 β€ l β€ r β€ n) and s (1 β€ s β€ (n (n+1))/(2)) and asked to find a permutation p of numbers from 1 to n that satisfies the following condition:
* s = p_l + p_{l+1} + β¦ + p_r.
For example, for n=5, l=3, r=5, and s=8, the following permutations are suitable (not all options are listed):
* p = [3, 4, 5, 2, 1];
* p = [5, 2, 4, 3, 1];
* p = [5, 2, 1, 3, 4].
But, for example, there is no permutation suitable for the condition above for n=4, l=1, r=1, and s=5.
Help Polycarp, for the given n, l, r, and s, find a permutation of numbers from 1 to n that fits the condition above. If there are several suitable permutations, print any of them.
Input
The first line contains a single integer t (1 β€ t β€ 500). Then t test cases follow.
Each test case consist of one line with four integers n (1 β€ n β€ 500), l (1 β€ l β€ n), r (l β€ r β€ n), s (1 β€ s β€ (n (n+1))/(2)).
It is guaranteed that the sum of n for all input data sets does not exceed 500.
Output
For each test case, output on a separate line:
* n integers β a permutation of length n that fits the condition above if such a permutation exists;
* -1, otherwise.
If there are several suitable permutations, print any of them.
Example
Input
5
5 2 3 5
5 3 4 1
3 1 2 4
2 2 2 2
2 1 1 3
Output
1 2 3 4 5
-1
1 3 2
1 2
-1
|
def solve(n,l,r,s) :
sol = list(range(1,r-l+2))
sol.reverse()
somme = sum(sol)
i = 0
while somme < s :
if i >= len(sol) :
print(-1)
return
#print('i',i, sol, n, l, r, s)
if sol[i] < n and (i == 0 or sol[i] < sol[i-1] - 1) :
sol[i] += 1
somme+=1
else :
i+=1
if somme < s or somme > s :
print(-1)
return
reste = [x for x in range(1,n+1) if x not in sol]
result = reste[:l-1] + sol + reste[l-1:]
print(*result)
t = int(input())
for i in range(t) :
n, l, r, s = list(map(int, input().split()))
solve(n,l,r,s)
|
{
"input": [
"5\n5 2 3 5\n5 3 4 1\n3 1 2 4\n2 2 2 2\n2 1 1 3\n"
],
"output": [
"\n1 2 3 4 5 \n-1\n1 3 2 \n1 2 \n-1\n"
]
}
|
3,948 | 7 |
In some country live wizards. They love to ride trolleybuses.
A city in this country has a trolleybus depot with n trolleybuses. Every day the trolleybuses leave the depot, one by one and go to the final station. The final station is at a distance of d meters from the depot. We know for the i-th trolleybus that it leaves at the moment of time ti seconds, can go at a speed of no greater than vi meters per second, and accelerate with an acceleration no greater than a meters per second squared. A trolleybus can decelerate as quickly as you want (magic!). It can change its acceleration as fast as you want, as well. Note that the maximum acceleration is the same for all trolleys.
Despite the magic the trolleys are still powered by an electric circuit and cannot overtake each other (the wires are to blame, of course). If a trolleybus catches up with another one, they go together one right after the other until they arrive at the final station. Also, the drivers are driving so as to arrive at the final station as quickly as possible.
You, as head of the trolleybuses' fans' club, are to determine for each trolley the minimum time by which it can reach the final station. At the time of arrival at the destination station the trolleybus does not necessarily have zero speed. When a trolley is leaving the depot, its speed is considered equal to zero. From the point of view of physics, the trolleybuses can be considered as material points, and also we should ignore the impact on the speed of a trolley bus by everything, except for the acceleration and deceleration provided by the engine.
Input
The first input line contains three space-separated integers n, a, d (1 β€ n β€ 105, 1 β€ a, d β€ 106) β the number of trolleybuses, their maximum acceleration and the distance from the depot to the final station, correspondingly.
Next n lines contain pairs of integers ti vi (0 β€ t1 < t2... < tn - 1 < tn β€ 106, 1 β€ vi β€ 106) β the time when the i-th trolleybus leaves the depot and its maximum speed, correspondingly. The numbers in the lines are separated by spaces.
Output
For each trolleybus print a single line the time it arrives to the final station. Print the times for the trolleybuses in the order in which the trolleybuses are given in the input. The answer will be accepted if the absolute or relative error doesn't exceed 10 - 4.
Examples
Input
3 10 10000
0 10
5 11
1000 1
Output
1000.5000000000
1000.5000000000
11000.0500000000
Input
1 2 26
28 29
Output
33.0990195136
Note
In the first sample the second trolleybus will catch up with the first one, that will happen at distance 510.5 meters from the depot. The trolleybuses will go the remaining 9489.5 meters together at speed 10 meters per second. As a result, both trolleybuses will arrive to the final station by the moment of time 1000.5 seconds. The third trolleybus will not catch up with them. It will arrive to the final station by the moment of time 11000.05 seconds.
|
'''input
1 2 26
28 29
'''
import math
def get_time(t, v):
total = t
t1 = math.sqrt((2 * d)/ a)
if a* t1 < v:
total += t1
else:
t2 = v/a
total += t2
r_d = d - 0.5 *(a * t2 * t2)
total += r_d/v
return total
from sys import stdin, stdout
# main starts
n,a , d = list(map(int, stdin.readline().split()))
time = []
for i in range(n):
t, v = list(map(int, stdin.readline().split()))
time.append(get_time(t, v))
ans = []
ans.append(time[0])
prev = time[0]
for i in range(1, n):
if time[i] <= prev:
ans.append(prev)
else:
prev = time[i]
ans.append(time[i])
for i in ans:
print(i)
|
{
"input": [
"1 2 26\n28 29\n",
"3 10 10000\n0 10\n5 11\n1000 1\n"
],
"output": [
"33.0990195136\n",
"1000.5000000000\n1000.5000000000\n11000.0500000000\n"
]
}
|
3,949 | 9 |
Scientists say a lot about the problems of global warming and cooling of the Earth. Indeed, such natural phenomena strongly influence all life on our planet.
Our hero Vasya is quite concerned about the problems. He decided to try a little experiment and observe how outside daily temperature changes. He hung out a thermometer on the balcony every morning and recorded the temperature. He had been measuring the temperature for the last n days. Thus, he got a sequence of numbers t1, t2, ..., tn, where the i-th number is the temperature on the i-th day.
Vasya analyzed the temperature statistics in other cities, and came to the conclusion that the city has no environmental problems, if first the temperature outside is negative for some non-zero number of days, and then the temperature is positive for some non-zero number of days. More formally, there must be a positive integer k (1 β€ k β€ n - 1) such that t1 < 0, t2 < 0, ..., tk < 0 and tk + 1 > 0, tk + 2 > 0, ..., tn > 0. In particular, the temperature should never be zero. If this condition is not met, Vasya decides that his city has environmental problems, and gets upset.
You do not want to upset Vasya. Therefore, you want to select multiple values of temperature and modify them to satisfy Vasya's condition. You need to know what the least number of temperature values needs to be changed for that.
Input
The first line contains a single integer n (2 β€ n β€ 105) β the number of days for which Vasya has been measuring the temperature.
The second line contains a sequence of n integers t1, t2, ..., tn (|ti| β€ 109) β the sequence of temperature values. Numbers ti are separated by single spaces.
Output
Print a single integer β the answer to the given task.
Examples
Input
4
-1 1 -2 1
Output
1
Input
5
0 -1 1 2 -5
Output
2
Note
Note to the first sample: there are two ways to change exactly one number so that the sequence met Vasya's condition. You can either replace the first number 1 by any negative number or replace the number -2 by any positive number.
|
# aadiupadhyay
import sys
from collections import *
import os.path
mod = 1000000007
INF = float('inf')
def st(): return list(sys.stdin.readline().strip())
def li(): return list(map(int, sys.stdin.readline().split()))
def mp(): return map(int, sys.stdin.readline().split())
def inp(): return int(sys.stdin.readline())
def pr(n): return sys.stdout.write(str(n)+"\n")
def prl(n): return sys.stdout.write(str(n)+" ")
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def solve():
n = inp()
l = li()
pref_pos = [0 for i in range(n)]
suf_neg = [0 for i in range(n)]
a, b = INF, -INF
for i in range(n):
if l[i] >= 0:
if i == 0:
pref_pos[i] = 1
else:
pref_pos[i] = 1+pref_pos[i-1]
else:
if i != 0:
pref_pos[i] += pref_pos[i-1]
if l[n-i-1] <= 0:
if i == 0:
suf_neg[n-i-1] = 1
else:
suf_neg[n-1-i] = 1+suf_neg[n-i]
else:
if i != 0:
suf_neg[n-i-1] += suf_neg[n-i]
a = min(a, l[i])
b = max(b, l[i])
if (a > 0 and b > 0) or (a < 0 and b < 0):
pr(1)
return
ans = INF
# print(pref_pos)
# print(suf_neg)
for i in range(n-1):
ans = min(ans, pref_pos[i]+suf_neg[i+1])
pr(ans)
solve()
|
{
"input": [
"4\n-1 1 -2 1\n",
"5\n0 -1 1 2 -5\n"
],
"output": [
"1\n",
"2\n"
]
}
|
3,950 | 8 |
Phone number in Berland is a sequence of n digits. Often, to make it easier to memorize the number, it is divided into groups of two or three digits. For example, the phone number 1198733 is easier to remember as 11-987-33. Your task is to find for a given phone number any of its divisions into groups of two or three digits.
Input
The first line contains integer n (2 β€ n β€ 100) β amount of digits in the phone number. The second line contains n digits β the phone number to divide into groups.
Output
Output any of divisions of the given phone number into groups of two or three digits. Separate groups by single character -. If the answer is not unique, output any.
Examples
Input
6
549871
Output
54-98-71
Input
7
1198733
Output
11-987-33
|
def fun(s):
if len(s) <= 3:
return s
return s[:2]+'-'+fun(s[2:])
n=input()
print(fun(input()))
|
{
"input": [
"6\n549871\n",
"7\n1198733\n"
],
"output": [
"54-98-71\n",
"11-98-733\n"
]
}
|
3,951 | 8 |
Farmer John has just given the cows a program to play with! The program contains two integer variables, x and y, and performs the following operations on a sequence a1, a2, ..., an of positive integers:
1. Initially, x = 1 and y = 0. If, after any step, x β€ 0 or x > n, the program immediately terminates.
2. The program increases both x and y by a value equal to ax simultaneously.
3. The program now increases y by ax while decreasing x by ax.
4. The program executes steps 2 and 3 (first step 2, then step 3) repeatedly until it terminates (it may never terminate). So, the sequence of executed steps may start with: step 2, step 3, step 2, step 3, step 2 and so on.
The cows are not very good at arithmetic though, and they want to see how the program works. Please help them!
You are given the sequence a2, a3, ..., an. Suppose for each i (1 β€ i β€ n - 1) we run the program on the sequence i, a2, a3, ..., an. For each such run output the final value of y if the program terminates or -1 if it does not terminate.
Input
The first line contains a single integer, n (2 β€ n β€ 2Β·105). The next line contains n - 1 space separated integers, a2, a3, ..., an (1 β€ ai β€ 109).
Output
Output n - 1 lines. On the i-th line, print the requested value when the program is run on the sequence i, a2, a3, ...an.
Please do not use the %lld specifier to read or write 64-bit integers in Π‘++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
4
2 4 1
Output
3
6
8
Input
3
1 2
Output
-1
-1
Note
In the first sample
1. For i = 1, x becomes <image> and y becomes 1 + 2 = 3.
2. For i = 2, x becomes <image> and y becomes 2 + 4 = 6.
3. For i = 3, x becomes <image> and y becomes 3 + 1 + 4 = 8.
|
n = int(input())
t = [0, 0]
t += list(map(int, input().split()))
n += 1
a = [0] * n
b = [0] * n
n -= 1
a[1] = b[1] = -1
#print(t, a, b)
def calc(s, a, b, l):
global t
l.reverse()
j = 0
n = len(l)
while True:
s += t[l[j]]
a[l[j]] = s
j += 1
if j == n:
return
s += t[l[j]]
b[l[j]] = s
j += 1
if j == n:
return
def calc2(i, k):
global a, b
l = []
if k:
a[i] = -1
l.append(i)
i += t[i]
while True:
if i > n:
return calc(0, a, b, l)
if b[i] > 0:
return calc(b[i], a, b, l)
if b[i] == -1:
return
b[i] = -1
l.append(i)
i -= t[i]
if i < 1:
return calc(0, b, a, l)
if a[i] > 0:
return calc(a[i], b, a, l)
if a[i] == -1:
return
a[i] -= 1
l.append(i)
i += t[i]
for i in range(2, n + 1):
if a[i] == 0:
calc2(i, True)
if b[i] == 0:
calc2(i, False)
for i in range(1, n):
if b[i + 1] > 0:
t[i] = i + b[i + 1]
else:
t[i] = -1
#print(t, a, b)
print('\n'.join(map(str, t[1:n])))
|
{
"input": [
"4\n2 4 1\n",
"3\n1 2\n"
],
"output": [
"3\n6\n8\n",
"-1\n-1\n"
]
}
|
3,952 | 7 |
Polycarpus has got n candies and m friends (n β₯ m). He wants to make a New Year present with candies to each friend. Polycarpus is planning to present all candies and he wants to do this in the fairest (that is, most equal) manner. He wants to choose such ai, where ai is the number of candies in the i-th friend's present, that the maximum ai differs from the least ai as little as possible.
For example, if n is divisible by m, then he is going to present the same number of candies to all his friends, that is, the maximum ai won't differ from the minimum one.
Input
The single line of the input contains a pair of space-separated positive integers n, m (1 β€ n, m β€ 100;n β₯ m) β the number of candies and the number of Polycarpus's friends.
Output
Print the required sequence a1, a2, ..., am, where ai is the number of candies in the i-th friend's present. All numbers ai must be positive integers, total up to n, the maximum one should differ from the minimum one by the smallest possible value.
Examples
Input
12 3
Output
4 4 4
Input
15 4
Output
3 4 4 4
Input
18 7
Output
2 2 2 3 3 3 3
Note
Print ai in any order, separate the numbers by spaces.
|
import sys
def main():
n, m = map(int, sys.stdin.read().strip().split())
return [n//m]*(m - n%m) + [n//m + 1]*(n%m)
print(*main())
|
{
"input": [
"18 7\n",
"15 4\n",
"12 3\n"
],
"output": [
"2 2 2 3 3 3 3 \n",
"3 4 4 4 \n",
"4 4 4\n"
]
}
|
3,953 | 9 |
Yet another Armageddon is coming! This time the culprit is the Julya tribe calendar.
The beavers in this tribe knew math very well. Smart Beaver, an archaeologist, got a sacred plate with a magic integer on it. The translation from Old Beaverish is as follows:
"May the Great Beaver bless you! May your chacres open and may your third eye never turn blind from beholding the Truth! Take the magic number, subtract a digit from it (the digit must occur in the number) and get a new magic number. Repeat this operation until a magic number equals zero. The Earth will stand on Three Beavers for the time, equal to the number of subtractions you perform!"
Distinct subtraction sequences can obviously get you different number of operations. But the Smart Beaver is ready to face the worst and is asking you to count the minimum number of operations he needs to reduce the magic number to zero.
Input
The single line contains the magic integer n, 0 β€ n.
* to get 20 points, you need to solve the problem with constraints: n β€ 106 (subproblem C1);
* to get 40 points, you need to solve the problem with constraints: n β€ 1012 (subproblems C1+C2);
* to get 100 points, you need to solve the problem with constraints: n β€ 1018 (subproblems C1+C2+C3).
Output
Print a single integer β the minimum number of subtractions that turns the magic number to a zero.
Examples
Input
24
Output
5
Note
In the first test sample the minimum number of operations can be reached by the following sequence of subtractions:
24 β 20 β 18 β 10 β 9 β 0
|
c = '0123456789'
F = {c[a] + c[b]: (c[10 - a + b], 1) if a > b else (c[10 - a], 2) for a in range(1, 10) for b in range(10)}
for b in range(1, 10): F['0' + c[b]] = ('0', 1)
F['00'] = ('0', 0)
def f(x):
global F
if x in F: return F[x]
a, b, y, s = int(x[0]), int(x[1]), x[2: ], 0
for i in range(b, a, -1):
y, d = f(c[i] + y)
s += d
for i in range(min(a, b) + 1):
y, d = f(x[0] + y)
s += d
F[x] = ('9' + y, s)
return F[x]
print(f('0' + input())[1])
|
{
"input": [
"24\n"
],
"output": [
"5\n"
]
}
|
3,954 | 7 |
Two players are playing a game. First each of them writes an integer from 1 to 6, and then a dice is thrown. The player whose written number got closer to the number on the dice wins. If both payers have the same difference, it's a draw.
The first player wrote number a, the second player wrote number b. How many ways to throw a dice are there, at which the first player wins, or there is a draw, or the second player wins?
Input
The single line contains two integers a and b (1 β€ a, b β€ 6) β the numbers written on the paper by the first and second player, correspondingly.
Output
Print three integers: the number of ways to throw the dice at which the first player wins, the game ends with a draw or the second player wins, correspondingly.
Examples
Input
2 5
Output
3 0 3
Input
2 4
Output
2 1 3
Note
The dice is a standard cube-shaped six-sided object with each side containing a number from 1 to 6, and where all numbers on all sides are distinct.
You can assume that number a is closer to number x than number b, if |a - x| < |b - x|.
|
def I(): return map(int, input().split())
a, b = I()
z = x = c = 0
for i in range(1, 7):
if abs(a-i) < abs(b-i):
z += 1
elif abs(a-i) > abs(b-i):
c += 1
else:
x += 1
print(z, x, c)
|
{
"input": [
"2 5\n",
"2 4\n"
],
"output": [
"3 0 3\n",
"2 1 3\n"
]
}
|
3,955 | 8 |
Jzzhu is the president of country A. There are n cities numbered from 1 to n in his country. City 1 is the capital of A. Also there are m roads connecting the cities. One can go from city ui to vi (and vise versa) using the i-th road, the length of this road is xi. Finally, there are k train routes in the country. One can use the i-th train route to go from capital of the country to city si (and vise versa), the length of this route is yi.
Jzzhu doesn't want to waste the money of the country, so he is going to close some of the train routes. Please tell Jzzhu the maximum number of the train routes which can be closed under the following condition: the length of the shortest path from every city to the capital mustn't change.
Input
The first line contains three integers n, m, k (2 β€ n β€ 105; 1 β€ m β€ 3Β·105; 1 β€ k β€ 105).
Each of the next m lines contains three integers ui, vi, xi (1 β€ ui, vi β€ n; ui β vi; 1 β€ xi β€ 109).
Each of the next k lines contains two integers si and yi (2 β€ si β€ n; 1 β€ yi β€ 109).
It is guaranteed that there is at least one way from every city to the capital. Note, that there can be multiple roads between two cities. Also, there can be multiple routes going to the same city from the capital.
Output
Output a single integer representing the maximum number of the train routes which can be closed.
Examples
Input
5 5 3
1 2 1
2 3 2
1 3 3
3 4 4
1 5 5
3 5
4 5
5 5
Output
2
Input
2 2 3
1 2 2
2 1 3
2 1
2 2
2 3
Output
2
|
import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill():
pass
return super(FastIO, self).read()
def readline(self):
while self.newlines == 0:
s = self._fill()
self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self, a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = "\n"
import heapq
def solve():
"""
1. First we calculate shortest path using dijkstra. We
1.1) While comparison of distances, in case of equal shortest paths, -> Maybe we can keep (dist, num_trains_encountered, next_node) in heapq.
choose the one with more train network.
2. All train paths not on shortest path can be eliminated.
"""
n, m, k = map(int, input().split())
adj_list = {x: [] for x in range(n + 1)}
dist = [float("inf")] * (n + 1)
dist[1] = 0
hq = [(0, 1)]
for _ in range(m):
u, v, x = map(int, input().split())
adj_list[u].append((v, x, False))
adj_list[v].append((u, x, False))
for _ in range(k):
v, y = map(int, input().split())
adj_list[1].append((v, y, True))
adj_list[v].append((1, y, True))
visited = [False] * (n + 1)
prev = {}
train_used = [0] * (n + 1)
# Dist, Train found, Next Node.
while hq:
d, node = heapq.heappop(hq)
if visited[node]:
continue
visited[node] = True
for edge in adj_list[node]:
nxt, w, isTrain = edge
if not visited[nxt]:
if d + w < dist[nxt]:
dist[nxt] = d + w
if isTrain:
train_used[nxt] = 1
if d + w == dist[nxt] and train_used[nxt] == 1 and not isTrain:
train_used[nxt] = 0
heapq.heappush(hq, (d + w, nxt))
cout<<k - sum(train_used)<<"\n"
def main():
solve()
if __name__ == "__main__":
main()
|
{
"input": [
"2 2 3\n1 2 2\n2 1 3\n2 1\n2 2\n2 3\n",
"5 5 3\n1 2 1\n2 3 2\n1 3 3\n3 4 4\n1 5 5\n3 5\n4 5\n5 5\n"
],
"output": [
"2\n",
"2\n"
]
}
|
3,956 | 10 |
Vasya decided to learn to play chess. Classic chess doesn't seem interesting to him, so he plays his own sort of chess.
The queen is the piece that captures all squares on its vertical, horizontal and diagonal lines. If the cell is located on the same vertical, horizontal or diagonal line with queen, and the cell contains a piece of the enemy color, the queen is able to move to this square. After that the enemy's piece is removed from the board. The queen cannot move to a cell containing an enemy piece if there is some other piece between it and the queen.
There is an n Γ n chessboard. We'll denote a cell on the intersection of the r-th row and c-th column as (r, c). The square (1, 1) contains the white queen and the square (1, n) contains the black queen. All other squares contain green pawns that don't belong to anyone.
The players move in turns. The player that moves first plays for the white queen, his opponent plays for the black queen.
On each move the player has to capture some piece with his queen (that is, move to a square that contains either a green pawn or the enemy queen). The player loses if either he cannot capture any piece during his move or the opponent took his queen during the previous move.
Help Vasya determine who wins if both players play with an optimal strategy on the board n Γ n.
Input
The input contains a single number n (2 β€ n β€ 109) β the size of the board.
Output
On the first line print the answer to problem β string "white" or string "black", depending on who wins if the both players play optimally.
If the answer is "white", then you should also print two integers r and c representing the cell (r, c), where the first player should make his first move to win. If there are multiple such cells, print the one with the minimum r. If there are still multiple squares, print the one with the minimum c.
Examples
Input
2
Output
white
1 2
Input
3
Output
black
Note
In the first sample test the white queen can capture the black queen at the first move, so the white player wins.
In the second test from the statement if the white queen captures the green pawn located on the central vertical line, then it will be captured by the black queen during the next move. So the only move for the white player is to capture the green pawn located at (2, 1).
Similarly, the black queen doesn't have any other options but to capture the green pawn located at (2, 3), otherwise if it goes to the middle vertical line, it will be captured by the white queen.
During the next move the same thing happens β neither the white, nor the black queen has other options rather than to capture green pawns situated above them. Thus, the white queen ends up on square (3, 1), and the black queen ends up on square (3, 3).
In this situation the white queen has to capture any of the green pawns located on the middle vertical line, after that it will be captured by the black queen. Thus, the player who plays for the black queen wins.
|
def main():
n = int(input()) & 1
print(('white', 'black')[n])
if not n:
print(1, 2)
main()
|
{
"input": [
"3\n",
"2\n"
],
"output": [
"black\n",
"white\n1 2\n"
]
}
|
3,957 | 9 |
Anya has bought a new smartphone that uses Berdroid operating system. The smartphone menu has exactly n applications, each application has its own icon. The icons are located on different screens, one screen contains k icons. The icons from the first to the k-th one are located on the first screen, from the (k + 1)-th to the 2k-th ones are on the second screen and so on (the last screen may be partially empty).
Initially the smartphone menu is showing the screen number 1. To launch the application with the icon located on the screen t, Anya needs to make the following gestures: first she scrolls to the required screen number t, by making t - 1 gestures (if the icon is on the screen t), and then make another gesture β press the icon of the required application exactly once to launch it.
After the application is launched, the menu returns to the first screen. That is, to launch the next application you need to scroll through the menu again starting from the screen number 1.
All applications are numbered from 1 to n. We know a certain order in which the icons of the applications are located in the menu at the beginning, but it changes as long as you use the operating system. Berdroid is intelligent system, so it changes the order of the icons by moving the more frequently used icons to the beginning of the list. Formally, right after an application is launched, Berdroid swaps the application icon and the icon of a preceding application (that is, the icon of an application on the position that is smaller by one in the order of menu). The preceding icon may possibly be located on the adjacent screen. The only exception is when the icon of the launched application already occupies the first place, in this case the icon arrangement doesn't change.
Anya has planned the order in which she will launch applications. How many gestures should Anya make to launch the applications in the planned order?
Note that one application may be launched multiple times.
Input
The first line of the input contains three numbers n, m, k (1 β€ n, m, k β€ 105) β the number of applications that Anya has on her smartphone, the number of applications that will be launched and the number of icons that are located on the same screen.
The next line contains n integers, permutation a1, a2, ..., an β the initial order of icons from left to right in the menu (from the first to the last one), ai β is the id of the application, whose icon goes i-th in the menu. Each integer from 1 to n occurs exactly once among ai.
The third line contains m integers b1, b2, ..., bm(1 β€ bi β€ n) β the ids of the launched applications in the planned order. One application may be launched multiple times.
Output
Print a single number β the number of gestures that Anya needs to make to launch all the applications in the desired order.
Examples
Input
8 3 3
1 2 3 4 5 6 7 8
7 8 1
Output
7
Input
5 4 2
3 1 5 2 4
4 4 4 4
Output
8
Note
In the first test the initial configuration looks like (123)(456)(78), that is, the first screen contains icons of applications 1, 2, 3, the second screen contains icons 4, 5, 6, the third screen contains icons 7, 8.
After application 7 is launched, we get the new arrangement of the icons β (123)(457)(68). To launch it Anya makes 3 gestures.
After application 8 is launched, we get configuration (123)(457)(86). To launch it Anya makes 3 gestures.
After application 1 is launched, the arrangement of icons in the menu doesn't change. To launch it Anya makes 1 gesture.
In total, Anya makes 7 gestures.
|
from math import ceil
def move(l,i):
if i != 0:
l[i-1],l[i] = l[i],l[i-1]
return l
n,m,k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
d = {}
for i in range(n):
d[a[i]] = i
cnt = 0
for i in b:
cnt += ceil((d[i]+1)/k)
if d[i] != 0:
d[i] -= 1
d[a[d[i]]] += 1
move(a,d[i]+1)
print(cnt)
|
{
"input": [
"5 4 2\n3 1 5 2 4\n4 4 4 4\n",
"8 3 3\n1 2 3 4 5 6 7 8\n7 8 1\n"
],
"output": [
"8\n",
"7\n"
]
}
|
3,958 | 9 |
Programmers working on a large project have just received a task to write exactly m lines of code. There are n programmers working on a project, the i-th of them makes exactly ai bugs in every line of code that he writes.
Let's call a sequence of non-negative integers v1, v2, ..., vn a plan, if v1 + v2 + ... + vn = m. The programmers follow the plan like that: in the beginning the first programmer writes the first v1 lines of the given task, then the second programmer writes v2 more lines of the given task, and so on. In the end, the last programmer writes the remaining lines of the code. Let's call a plan good, if all the written lines of the task contain at most b bugs in total.
Your task is to determine how many distinct good plans are there. As the number of plans can be large, print the remainder of this number modulo given positive integer mod.
Input
The first line contains four integers n, m, b, mod (1 β€ n, m β€ 500, 0 β€ b β€ 500; 1 β€ mod β€ 109 + 7) β the number of programmers, the number of lines of code in the task, the maximum total number of bugs respectively and the modulo you should use when printing the answer.
The next line contains n space-separated integers a1, a2, ..., an (0 β€ ai β€ 500) β the number of bugs per line for each programmer.
Output
Print a single integer β the answer to the problem modulo mod.
Examples
Input
3 3 3 100
1 1 1
Output
10
Input
3 6 5 1000000007
1 2 3
Output
0
Input
3 5 6 11
1 2 1
Output
0
|
def main():
n, m, b, mod = map(int, input().split())
row_zero = [1] + [0] * b
b += 1
dp = [[0] * b for _ in range(m)]
for a in list(map(int, input().split())):
cur = row_zero
for nxt in dp:
for i, u in zip(range(a, b), cur):
nxt[i] = (nxt[i] + u) % mod
cur = nxt
print(sum(dp[-1]) % mod)
if __name__ == '__main__':
main()
|
{
"input": [
"3 6 5 1000000007\n1 2 3\n",
"3 3 3 100\n1 1 1\n",
"3 5 6 11\n1 2 1\n"
],
"output": [
"0\n",
"10\n",
"0\n"
]
}
|
3,959 | 9 |
Vector Willman and Array Bolt are the two most famous athletes of Byteforces. They are going to compete in a race with a distance of L meters today.
<image>
Willman and Bolt have exactly the same speed, so when they compete the result is always a tie. That is a problem for the organizers because they want a winner.
While watching previous races the organizers have noticed that Willman can perform only steps of length equal to w meters, and Bolt can perform only steps of length equal to b meters. Organizers decided to slightly change the rules of the race. Now, at the end of the racetrack there will be an abyss, and the winner will be declared the athlete, who manages to run farther from the starting point of the the racetrack (which is not the subject to change by any of the athletes).
Note that none of the athletes can run infinitely far, as they both will at some moment of time face the point, such that only one step further will cause them to fall in the abyss. In other words, the athlete will not fall into the abyss if the total length of all his steps will be less or equal to the chosen distance L.
Since the organizers are very fair, the are going to set the length of the racetrack as an integer chosen randomly and uniformly in range from 1 to t (both are included). What is the probability that Willman and Bolt tie again today?
Input
The first line of the input contains three integers t, w and b (1 β€ t, w, b β€ 5Β·1018) β the maximum possible length of the racetrack, the length of Willman's steps and the length of Bolt's steps respectively.
Output
Print the answer to the problem as an irreducible fraction <image>. Follow the format of the samples output.
The fraction <image> (p and q are integers, and both p β₯ 0 and q > 0 holds) is called irreducible, if there is no such integer d > 1, that both p and q are divisible by d.
Examples
Input
10 3 2
Output
3/10
Input
7 1 2
Output
3/7
Note
In the first sample Willman and Bolt will tie in case 1, 6 or 7 are chosen as the length of the racetrack.
|
def g(a,b):
if(0==b):return a
return g(b,a%b)
i=input
t,w,b=map(int,i().split())
l=(w*b)//g(w,b)
m=min(w,b)
r=t//l*m + min(m-1,t%l)
e=g(t,r)
print('%d/%d'%(r//e,t//e))
|
{
"input": [
"10 3 2\n",
"7 1 2\n"
],
"output": [
"3/10\n",
"3/7\n"
]
}
|
3,960 | 7 |
Programmer Rostislav got seriously interested in the Link/Cut Tree data structure, which is based on Splay trees. Specifically, he is now studying the expose procedure.
Unfortunately, Rostislav is unable to understand the definition of this procedure, so he decided to ask programmer Serezha to help him. Serezha agreed to help if Rostislav solves a simple task (and if he doesn't, then why would he need Splay trees anyway?)
Given integers l, r and k, you need to print all powers of number k within range from l to r inclusive. However, Rostislav doesn't want to spent time doing this, as he got interested in playing a network game called Agar with Gleb. Help him!
Input
The first line of the input contains three space-separated integers l, r and k (1 β€ l β€ r β€ 1018, 2 β€ k β€ 109).
Output
Print all powers of number k, that lie within range from l to r in the increasing order. If there are no such numbers, print "-1" (without the quotes).
Examples
Input
1 10 2
Output
1 2 4 8
Input
2 4 5
Output
-1
Note
Note to the first sample: numbers 20 = 1, 21 = 2, 22 = 4, 23 = 8 lie within the specified range. The number 24 = 16 is greater then 10, thus it shouldn't be printed.
|
def main():
l, r, k = map(int, input().split())
ans = []
x = 1
while x <= r:
if x >= l:
ans.append(x)
x *= k
if ans:
print(' '.join(map(str, ans)))
else:
print(-1)
if __name__ == '__main__':
main()
|
{
"input": [
"1 10 2\n",
"2 4 5\n"
],
"output": [
"1\n2\n4\n8\n",
"-1\n"
]
}
|
3,961 | 9 |
You are given a non-empty string s consisting of lowercase English letters. You have to pick exactly one non-empty substring of s and shift all its letters 'z' <image> 'y' <image> 'x' <image> 'b' <image> 'a' <image> 'z'. In other words, each character is replaced with the previous character of English alphabet and 'a' is replaced with 'z'.
What is the lexicographically minimum string that can be obtained from s by performing this shift exactly once?
Input
The only line of the input contains the string s (1 β€ |s| β€ 100 000) consisting of lowercase English letters.
Output
Print the lexicographically minimum string that can be obtained from s by shifting letters of exactly one non-empty substring.
Examples
Input
codeforces
Output
bncdenqbdr
Input
abacaba
Output
aaacaba
Note
String s is lexicographically smaller than some other string t of the same length if there exists some 1 β€ i β€ |s|, such that s1 = t1, s2 = t2, ..., si - 1 = ti - 1, and si < ti.
|
s = list(input())
started = False
def flip(c):
return chr((ord(c) - 1 - ord('a')) % 26 + ord('a'))
for i in range(len(s)):
if s[i] == 'a' and started:
break
if s[i] != 'a':
s[i] = flip(s[i])
started = True
if not started:
s[-1] = flip(s[-1])
print(''.join(s))
|
{
"input": [
"codeforces\n",
"abacaba\n"
],
"output": [
"bncdenqbdr\n",
"aaacaba\n"
]
}
|
3,962 | 8 |
Fox Ciel saw a large field while she was on a bus. The field was a n Γ m rectangle divided into 1 Γ 1 cells. Some cells were wasteland, and other each cell contained crop plants: either carrots or kiwis or grapes.
After seeing the field carefully, Ciel found that the crop plants of each cell were planted in following procedure:
* Assume that the rows are numbered 1 to n from top to bottom and the columns are numbered 1 to m from left to right, and a cell in row i and column j is represented as (i, j).
* First, each field is either cultivated or waste. Crop plants will be planted in the cultivated cells in the order of (1, 1) β ... β (1, m) β (2, 1) β ... β (2, m) β ... β (n, 1) β ... β (n, m). Waste cells will be ignored.
* Crop plants (either carrots or kiwis or grapes) will be planted in each cell one after another cyclically. Carrots will be planted in the first cell, then kiwis in the second one, grapes in the third one, carrots in the forth one, kiwis in the fifth one, and so on.
The following figure will show you the example of this procedure. Here, a white square represents a cultivated cell, and a black square represents a waste cell.
<image>
Now she is wondering how to determine the crop plants in some certain cells.
Input
In the first line there are four positive integers n, m, k, t (1 β€ n β€ 4Β·104, 1 β€ m β€ 4Β·104, 1 β€ k β€ 103, 1 β€ t β€ 103), each of which represents the height of the field, the width of the field, the number of waste cells and the number of queries that ask the kind of crop plants in a certain cell.
Following each k lines contains two integers a, b (1 β€ a β€ n, 1 β€ b β€ m), which denotes a cell (a, b) is waste. It is guaranteed that the same cell will not appear twice in this section.
Following each t lines contains two integers i, j (1 β€ i β€ n, 1 β€ j β€ m), which is a query that asks you the kind of crop plants of a cell (i, j).
Output
For each query, if the cell is waste, print Waste. Otherwise, print the name of crop plants in the cell: either Carrots or Kiwis or Grapes.
Examples
Input
4 5 5 6
4 3
1 3
3 3
2 5
3 2
1 3
1 4
2 3
2 4
1 1
1 1
Output
Waste
Grapes
Carrots
Kiwis
Carrots
Carrots
Note
The sample corresponds to the figure in the statement.
|
def read():
return map(int, input().split())
plants = ['Carrots', 'Kiwis', 'Grapes', 'Waste']
n, m, k, t = read()
waste_pos = set()
for _ in range(k):
x, y = read()
pos = (x-1) * m + (y-1)
waste_pos.add(pos)
for _ in range(t):
x, y = read()
res = (x-1) * m + (y-1)
sub = 0
if res in waste_pos:
ans = 3
else:
sub = sum(elm < res for elm in waste_pos)
ans = (res - sub) % 3
print(plants[ans])
|
{
"input": [
"4 5 5 6\n4 3\n1 3\n3 3\n2 5\n3 2\n1 3\n1 4\n2 3\n2 4\n1 1\n1 1\n"
],
"output": [
"Waste\nGrapes\nCarrots\nKiwis\nCarrots\nCarrots\n"
]
}
|
3,963 | 8 |
Attention: we lost all the test cases for this problem, so instead of solving the problem, we need you to generate test cases. We're going to give you the answer, and you need to print a test case that produces the given answer. The original problem is in the following paragraph.
People don't use cash as often as they used to. Having a credit card solves some of the hassles of cash, such as having to receive change when you can't form the exact amount of money needed to purchase an item. Typically cashiers will give you as few coins as possible in change, but they don't have to. For example, if your change is 30 cents, a cashier could give you a 5 cent piece and a 25 cent piece, or they could give you three 10 cent pieces, or ten 1 cent pieces, two 5 cent pieces, and one 10 cent piece. Altogether there are 18 different ways to make 30 cents using only 1 cent pieces, 5 cent pieces, 10 cent pieces, and 25 cent pieces. Two ways are considered different if they contain a different number of at least one type of coin. Given the denominations of the coins and an amount of change to be made, how many different ways are there to make change?
As we mentioned before, we lost all the test cases for this problem, so we're actually going to give you the number of ways, and want you to produce a test case for which the number of ways is the given number. There could be many ways to achieve this (we guarantee there's always at least one), so you can print any, as long as it meets the constraints described below.
Input
Input will consist of a single integer A (1 β€ A β€ 105), the desired number of ways.
Output
In the first line print integers N and M (1 β€ N β€ 106, 1 β€ M β€ 10), the amount of change to be made, and the number of denominations, respectively.
Then print M integers D1, D2, ..., DM (1 β€ Di β€ 106), the denominations of the coins. All denominations must be distinct: for any i β j we must have Di β Dj.
If there are multiple tests, print any of them. You can print denominations in atbitrary order.
Examples
Input
18
Output
30 4
1 5 10 25
Input
3
Output
20 2
5 2
Input
314
Output
183 4
6 5 2 139
|
def main():
n = int(input())
result = 1
if n > 1:
result = 2*n - 2
print("{} 2\n1 2".format(result))
if __name__ == '__main__':
main()
|
{
"input": [
"3\n",
"314\n",
"18\n"
],
"output": [
"4 2\n1 2\n",
"626 2\n1 2",
"34 2\n1 2"
]
}
|
3,964 | 10 |
Bash likes playing with arrays. He has an array a1, a2, ... an of n integers. He likes to guess the greatest common divisor (gcd) of different segments of the array. Of course, sometimes the guess is not correct. However, Bash will be satisfied if his guess is almost correct.
Suppose he guesses that the gcd of the elements in the range [l, r] of a is x. He considers the guess to be almost correct if he can change at most one element in the segment such that the gcd of the segment is x after making the change. Note that when he guesses, he doesn't actually change the array β he just wonders if the gcd of the segment can be made x. Apart from this, he also sometimes makes changes to the array itself.
Since he can't figure it out himself, Bash wants you to tell him which of his guesses are almost correct. Formally, you have to process q queries of one of the following forms:
* 1 l r x β Bash guesses that the gcd of the range [l, r] is x. Report if this guess is almost correct.
* 2 i y β Bash sets ai to y.
Note: The array is 1-indexed.
Input
The first line contains an integer n (1 β€ n β€ 5Β·105) β the size of the array.
The second line contains n integers a1, a2, ..., an (1 β€ ai β€ 109) β the elements of the array.
The third line contains an integer q (1 β€ q β€ 4Β·105) β the number of queries.
The next q lines describe the queries and may have one of the following forms:
* 1 l r x (1 β€ l β€ r β€ n, 1 β€ x β€ 109).
* 2 i y (1 β€ i β€ n, 1 β€ y β€ 109).
Guaranteed, that there is at least one query of first type.
Output
For each query of first type, output "YES" (without quotes) if Bash's guess is almost correct and "NO" (without quotes) otherwise.
Examples
Input
3
2 6 3
4
1 1 2 2
1 1 3 3
2 1 9
1 1 3 2
Output
YES
YES
NO
Input
5
1 2 3 4 5
6
1 1 4 2
2 3 6
1 1 4 2
1 1 5 2
2 5 10
1 1 5 2
Output
NO
YES
NO
YES
Note
In the first sample, the array initially is {2, 6, 3}.
For query 1, the first two numbers already have their gcd as 2.
For query 2, we can achieve a gcd of 3 by changing the first element of the array to 3. Note that the changes made during queries of type 1 are temporary and do not get reflected in the array.
After query 3, the array is now {9, 6, 3}.
For query 4, no matter which element you change, you cannot get the gcd of the range to be 2.
|
#!/usr/bin/env python3
import os
import sys
from atexit import register
from io import StringIO
from math import gcd
sys.stdin = StringIO(os.read(0, os.fstat(0).st_size).decode())
sys.stdout = StringIO()
register(lambda: os.write(1, sys.stdout.getvalue().encode()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
def main():
n = int(input())
arr = [int(num) for num in input().split()]
a = [0] * (524288 << 1 | 1)
for i in range(n):
p = i + 524289
a[p] = arr[i]
while p != 1:
p >>= 1
a[p] = gcd(a[p << 1], a[p << 1 | 1])
q = int(input())
for _ in range(q):
query = [int(num) for num in input().split()]
if query[0] == 1:
p = 524288 + query[1]
while p != 1 and (a[p] % query[3] == 0):
if p & (p + 1) == 0:
p = n + 524289
break
p = (p + 1) >> 1
while p < 524288:
p <<= 1
p += int(a[p] % query[3] == 0)
if p - 524288 >= query[2]:
print('YES')
else:
p += 1
while p != 1 and (a[p] % query[3] == 0):
if p & (p + 1) == 0:
p = n + 524289
break
p = (p + 1) >> 1
while p < 524288:
p <<= 1
p += int(a[p] % query[3] == 0)
print('YES' if p - 524288 > query[2] else 'NO')
else:
p = query[1] + 524288
a[p] = query[2]
while p != 1:
p >>= 1
a[p] = gcd(a[p << 1], a[p << 1 | 1])
if __name__ == '__main__':
main()
|
{
"input": [
"3\n2 6 3\n4\n1 1 2 2\n1 1 3 3\n2 1 9\n1 1 3 2\n",
"5\n1 2 3 4 5\n6\n1 1 4 2\n2 3 6\n1 1 4 2\n1 1 5 2\n2 5 10\n1 1 5 2\n"
],
"output": [
"YES\nYES\nNO\n",
"NO\nYES\nNO\nYES\n"
]
}
|
3,965 | 8 |
The weather is fine today and hence it's high time to climb the nearby pine and enjoy the landscape.
The pine's trunk includes several branches, located one above another and numbered from 2 to y. Some of them (more precise, from 2 to p) are occupied by tiny vile grasshoppers which you're at war with. These grasshoppers are known for their awesome jumping skills: the grasshopper at branch x can jump to branches <image>.
Keeping this in mind, you wisely decided to choose such a branch that none of the grasshoppers could interrupt you. At the same time you wanna settle as high as possible since the view from up there is simply breathtaking.
In other words, your goal is to find the highest branch that cannot be reached by any of the grasshoppers or report that it's impossible.
Input
The only line contains two integers p and y (2 β€ p β€ y β€ 109).
Output
Output the number of the highest suitable branch. If there are none, print -1 instead.
Examples
Input
3 6
Output
5
Input
3 4
Output
-1
Note
In the first sample case grasshopper from branch 2 reaches branches 2, 4 and 6 while branch 3 is initially settled by another grasshopper. Therefore the answer is 5.
It immediately follows that there are no valid branches in second sample case.
|
p, y = map(int, input().split())
def div(n):
for i in range(2, int(n ** (1 / 2)) + 1):
if n % i == 0:
return i
return n
while y > p:
if div(y) > p:
print(y)
break
y -= 1
if y <= p:
print(-1)
|
{
"input": [
"3 4\n",
"3 6\n"
],
"output": [
"-1\n",
"5\n"
]
}
|
3,966 | 10 |
You are given an array of positive integers. While there are at least two equal elements, we will perform the following operation. We choose the smallest value x that occurs in the array 2 or more times. Take the first two occurrences of x in this array (the two leftmost occurrences). Remove the left of these two occurrences, and the right one is replaced by the sum of this two values (that is, 2 β
x).
Determine how the array will look after described operations are performed.
For example, consider the given array looks like [3, 4, 1, 2, 2, 1, 1]. It will be changed in the following way: [3, 4, 1, 2, 2, 1, 1]~β~[3, 4, 2, 2, 2, 1]~β~[3, 4, 4, 2, 1]~β~[3, 8, 2, 1].
If the given array is look like [1, 1, 3, 1, 1] it will be changed in the following way: [1, 1, 3, 1, 1]~β~[2, 3, 1, 1]~β~[2, 3, 2]~β~[3, 4].
Input
The first line contains a single integer n (2 β€ n β€ 150 000) β the number of elements in the array.
The second line contains a sequence from n elements a_1, a_2, ..., a_n (1 β€ a_i β€ 10^{9}) β the elements of the array.
Output
In the first line print an integer k β the number of elements in the array after all the performed operations. In the second line print k integers β the elements of the array after all the performed operations.
Examples
Input
7
3 4 1 2 2 1 1
Output
4
3 8 2 1
Input
5
1 1 3 1 1
Output
2
3 4
Input
5
10 40 20 50 30
Output
5
10 40 20 50 30
Note
The first two examples were considered in the statement.
In the third example all integers in the given array are distinct, so it will not change.
|
def inpmap():
return map(int, input().split())
n = int(input())
arr = list(inpmap())
dc = {}
for i in range(n):
x = arr[i]
while x in dc:
del dc[x]
x *= 2
dc[x] = i
print(len(dc))
print(*dc)
|
{
"input": [
"7\n3 4 1 2 2 1 1\n",
"5\n10 40 20 50 30\n",
"5\n1 1 3 1 1\n"
],
"output": [
"4\n3 8 2 1 ",
"5\n10 40 20 50 30 ",
"2\n3 4 "
]
}
|
3,967 | 11 |
You are given an integer sequence a_1, a_2, ..., a_n.
Find the number of pairs of indices (l, r) (1 β€ l β€ r β€ n) such that the value of median of a_l, a_{l+1}, ..., a_r is exactly the given number m.
The median of a sequence is the value of an element which is in the middle of the sequence after sorting it in non-decreasing order. If the length of the sequence is even, the left of two middle elements is used.
For example, if a=[4, 2, 7, 5] then its median is 4 since after sorting the sequence, it will look like [2, 4, 5, 7] and the left of two middle elements is equal to 4. The median of [7, 1, 2, 9, 6] equals 6 since after sorting, the value 6 will be in the middle of the sequence.
Write a program to find the number of pairs of indices (l, r) (1 β€ l β€ r β€ n) such that the value of median of a_l, a_{l+1}, ..., a_r is exactly the given number m.
Input
The first line contains integers n and m (1 β€ n,m β€ 2β
10^5) β the length of the given sequence and the required value of the median.
The second line contains an integer sequence a_1, a_2, ..., a_n (1 β€ a_i β€ 2β
10^5).
Output
Print the required number.
Examples
Input
5 4
1 4 5 60 4
Output
8
Input
3 1
1 1 1
Output
6
Input
15 2
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3
Output
97
Note
In the first example, the suitable pairs of indices are: (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 5), (4, 5) and (5, 5).
|
def ask(x):
s={}
s[0]=1
sum,cnt,res=0,0,0
for i in range(n):
if(a[i]<x):
sum-=1
cnt-=s.get(sum,0)
else:
cnt+=s.get(sum,0)
sum+=1
s[sum]=s.get(sum,0)+1
res+=cnt
return res
n,m=map(int,input().split())
a=list(map(int,input().split()))
print(ask(m)-ask(m+1))
|
{
"input": [
"15 2\n1 2 3 1 2 3 1 2 3 1 2 3 1 2 3\n",
"5 4\n1 4 5 60 4\n",
"3 1\n1 1 1\n"
],
"output": [
"97\n",
"8\n",
"6\n"
]
}
|
3,968 | 10 |
You are given an array a, consisting of n positive integers.
Let's call a concatenation of numbers x and y the number that is obtained by writing down numbers x and y one right after another without changing the order. For example, a concatenation of numbers 12 and 3456 is a number 123456.
Count the number of ordered pairs of positions (i, j) (i β j) in array a such that the concatenation of a_i and a_j is divisible by k.
Input
The first line contains two integers n and k (1 β€ n β€ 2 β
10^5, 2 β€ k β€ 10^9).
The second line contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
Output
Print a single integer β the number of ordered pairs of positions (i, j) (i β j) in array a such that the concatenation of a_i and a_j is divisible by k.
Examples
Input
6 11
45 1 10 12 11 7
Output
7
Input
4 2
2 78 4 10
Output
12
Input
5 2
3 7 19 3 3
Output
0
Note
In the first example pairs (1, 2), (1, 3), (2, 3), (3, 1), (3, 4), (4, 2), (4, 3) suffice. They produce numbers 451, 4510, 110, 1045, 1012, 121, 1210, respectively, each of them is divisible by 11.
In the second example all n(n - 1) pairs suffice.
In the third example no pair is sufficient.
|
rd = lambda: list(map(int, input().split()))
(n, k), a = rd(), rd()
def proceed(a):
global n, k
b = [{} for _ in range(11)]
ans = 0
for i in range(n - 1, 0, -1):
cur = a[i] % k
ln = len(str(a[i]))
if cur not in b[ln]:
b[ln][cur] = 0
b[ln][cur] += 1
for j in range(11):
cur = (k - a[i - 1] * 10 ** j % k) % k
ans += b[j][cur] if cur in b[j] else 0
return ans
print(proceed(a) + proceed(a[::-1]))
|
{
"input": [
"5 2\n3 7 19 3 3\n",
"6 11\n45 1 10 12 11 7\n",
"4 2\n2 78 4 10\n"
],
"output": [
"0",
"7",
"12"
]
}
|
3,969 | 9 |
...Once upon a time a man came to the sea. The sea was stormy and dark. The man started to call for the little mermaid to appear but alas, he only woke up Cthulhu...
Whereas on the other end of the world Pentagon is actively collecting information trying to predict the monster's behavior and preparing the secret super weapon. Due to high seismic activity and poor weather conditions the satellites haven't yet been able to make clear shots of the monster. The analysis of the first shot resulted in an undirected graph with n vertices and m edges. Now the world's best minds are about to determine whether this graph can be regarded as Cthulhu or not.
To add simplicity, let's suppose that Cthulhu looks from the space like some spherical body with tentacles attached to it. Formally, we shall regard as Cthulhu such an undirected graph that can be represented as a set of three or more rooted trees, whose roots are connected by a simple cycle.
It is guaranteed that the graph contains no multiple edges and self-loops.
<image>
Input
The first line contains two integers β the number of vertices n and the number of edges m of the graph (1 β€ n β€ 100, 0 β€ m β€ <image>).
Each of the following m lines contains a pair of integers x and y, that show that an edge exists between vertices x and y (1 β€ x, y β€ n, x β y). For each pair of vertices there will be at most one edge between them, no edge connects a vertex to itself.
Output
Print "NO", if the graph is not Cthulhu and "FHTAGN!" if it is.
Examples
Input
6 6
6 3
6 4
5 1
2 5
1 4
5 4
Output
FHTAGN!
Input
6 5
5 6
4 6
3 1
5 1
1 2
Output
NO
Note
Let us denote as a simple cycle a set of v vertices that can be numbered so that the edges will only exist between vertices number 1 and 2, 2 and 3, ..., v - 1 and v, v and 1.
A tree is a connected undirected graph consisting of n vertices and n - 1 edges (n > 0).
A rooted tree is a tree where one vertex is selected to be the root.
|
n,m=map(int,input().split())
a=[[] for _ in range(n+1)]
vis=[]
for _ in range(m):
x,y=map(int,input().split())
a[x].append(y)
a[y].append(x)
def dfs(x):
vis.append(x)
for z in a[x]:
if not(z in vis):
dfs(z)
dfs(1)
if n<3 or n!=m or len(vis)!=n:
print("NO")
else:
print("FHTAGN!")
|
{
"input": [
"6 6\n6 3\n6 4\n5 1\n2 5\n1 4\n5 4\n",
"6 5\n5 6\n4 6\n3 1\n5 1\n1 2\n"
],
"output": [
"FHTAGN!\n",
"NO\n"
]
}
|
3,970 | 12 |
Vasya has got an array consisting of n integers, and two integers k and len in addition. All numbers in the array are either between 1 and k (inclusive), or equal to -1. The array is good if there is no segment of len consecutive equal numbers.
Vasya will replace each -1 with some number from 1 to k (inclusive) in such a way that the resulting array is good. Tell him the number of ways to do this replacement. Since the answer may be large, print it modulo 998244353.
Input
The first line contains three integers n, k and len (1 β€ n β€ 10^5, 1 β€ k β€ 100, 1 β€ len β€ n).
The second line contains n numbers β the array. Each number is either -1 or between 1 and k (inclusive).
Output
Print one integer β the number of ways to replace each -1 with some number from 1 to k (inclusive) so the array is good. The answer may be large, so print it modulo 998244353.
Examples
Input
5 2 3
1 -1 1 -1 2
Output
2
Input
6 3 2
1 1 -1 -1 -1 -1
Output
0
Input
10 42 7
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
Output
645711643
Note
Possible answers in the first test:
1. [1, 2, 1, 1, 2];
2. [1, 2, 1, 2, 2].
There is no way to make the array good in the second test, since first two elements are equal.
There are too many answers in the third test, so we won't describe any of them.
|
def vasya_and_array():
n,k,leng = [int(x) for x in input().split()]
if(leng==1):
return 0
a = [int(x) for x in input().split()]
mod = 998244353
a.insert(0,0)
dp = [[0 for x in range((k+1))] for y in range(n+1)]
sumdp = [0 for _ in range(n+1)]
sumdp[0]=1
count = [0 for _ in range(k+1)]
for i in range(1,n+1):
for j in range(1,k+1):
if(a[i]==-1 or a[i]==j):
dp[i][j] = sumdp[i-1]
count[j]+=1
if(count[j] >= leng):
dp[i][j]-=(sumdp[i-leng] - dp[i-leng][j])
dp[i][j]%=mod
sumdp[i]+=dp[i][j]
sumdp[i]%=mod
else:
count[j]=0
return (sumdp[n])
print(vasya_and_array())
|
{
"input": [
"6 3 2\n1 1 -1 -1 -1 -1\n",
"5 2 3\n1 -1 1 -1 2\n",
"10 42 7\n-1 -1 -1 -1 -1 -1 -1 -1 -1 -1\n"
],
"output": [
"0\n",
"2\n",
"645711643\n"
]
}
|
3,971 | 7 |
Recently a Golden Circle of Beetlovers was found in Byteland. It is a circle route going through n β
k cities. The cities are numerated from 1 to n β
k, the distance between the neighboring cities is exactly 1 km.
Sergey does not like beetles, he loves burgers. Fortunately for him, there are n fast food restaurants on the circle, they are located in the 1-st, the (k + 1)-st, the (2k + 1)-st, and so on, the ((n-1)k + 1)-st cities, i.e. the distance between the neighboring cities with fast food restaurants is k km.
Sergey began his journey at some city s and traveled along the circle, making stops at cities each l km (l > 0), until he stopped in s once again. Sergey then forgot numbers s and l, but he remembers that the distance from the city s to the nearest fast food restaurant was a km, and the distance from the city he stopped at after traveling the first l km from s to the nearest fast food restaurant was b km. Sergey always traveled in the same direction along the circle, but when he calculated distances to the restaurants, he considered both directions.
Now Sergey is interested in two integers. The first integer x is the minimum number of stops (excluding the first) Sergey could have done before returning to s. The second integer y is the maximum number of stops (excluding the first) Sergey could have done before returning to s.
Input
The first line contains two integers n and k (1 β€ n, k β€ 100 000) β the number of fast food restaurants on the circle and the distance between the neighboring restaurants, respectively.
The second line contains two integers a and b (0 β€ a, b β€ k/2) β the distances to the nearest fast food restaurants from the initial city and from the city Sergey made the first stop at, respectively.
Output
Print the two integers x and y.
Examples
Input
2 3
1 1
Output
1 6
Input
3 2
0 0
Output
1 3
Input
1 10
5 3
Output
5 5
Note
In the first example the restaurants are located in the cities 1 and 4, the initial city s could be 2, 3, 5, or 6. The next city Sergey stopped at could also be at cities 2, 3, 5, 6. Let's loop through all possible combinations of these cities. If both s and the city of the first stop are at the city 2 (for example, l = 6), then Sergey is at s after the first stop already, so x = 1. In other pairs Sergey needs 1, 2, 3, or 6 stops to return to s, so y = 6.
In the second example Sergey was at cities with fast food restaurant both initially and after the first stop, so l is 2, 4, or 6. Thus x = 1, y = 3.
In the third example there is only one restaurant, so the possible locations of s and the first stop are: (6, 8) and (6, 4). For the first option l = 2, for the second l = 8. In both cases Sergey needs x=y=5 stops to go to s.
|
from math import *
def main():
c, s = map(int, input().split())
a, b = map(int, input().split())
r = set()
for i in range(100000):
r.add(c * s // gcd(a + b + s * i, c * s))
r.add(c * s // gcd(a - b + s * i, c * s))
print(min(r), max(r))
main()
|
{
"input": [
"3 2\n0 0\n",
"2 3\n1 1\n",
"1 10\n5 3\n"
],
"output": [
"1 3\n",
"1 6\n",
"5 5\n"
]
}
|
3,972 | 9 |
Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, β¦, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, β¦, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i β a_j or b_i β b_j.
Input
The first line contains two integers n and k (1 β€ n,k β€ 10^5) β the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, β¦, x_k (1 β€ x_i β€ n) β Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| β€ 1 except for (42, 42) are valid scenarios.
|
def main():
n, k = map(int, input().split())
x = [int(i) for i in input().split()]
ans = 3 * n - 2
a, b = set(), set()
for val in x:
if val - 1 in a:
b.add((val, val - 1))
if val + 1 in a:
b.add((val, val + 1))
a.add(val)
ans -= len(a) + len(b)
print(max(ans, 0))
main()
|
{
"input": [
"4 8\n1 2 3 4 4 3 2 1\n",
"100000 1\n42\n",
"5 3\n5 1 4\n"
],
"output": [
"0\n",
"299997\n",
"9\n"
]
}
|
3,973 | 8 |
There are n products in the shop. The price of the i-th product is a_i. The owner of the shop wants to equalize the prices of all products. However, he wants to change prices smoothly.
In fact, the owner of the shop can change the price of some product i in such a way that the difference between the old price of this product a_i and the new price b_i is at most k. In other words, the condition |a_i - b_i| β€ k should be satisfied (|x| is the absolute value of x).
He can change the price for each product not more than once. Note that he can leave the old prices for some products. The new price b_i of each product i should be positive (i.e. b_i > 0 should be satisfied for all i from 1 to n).
Your task is to find out the maximum possible equal price B of all productts with the restriction that for all products the condiion |a_i - B| β€ k should be satisfied (where a_i is the old price of the product and B is the same new price of all products) or report that it is impossible to find such price B.
Note that the chosen price B should be integer.
You should answer q independent queries.
Input
The first line of the input contains one integer q (1 β€ q β€ 100) β the number of queries. Each query is presented by two lines.
The first line of the query contains two integers n and k (1 β€ n β€ 100, 1 β€ k β€ 10^8) β the number of products and the value k. The second line of the query contains n integers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^8), where a_i is the price of the i-th product.
Output
Print q integers, where the i-th integer is the answer B on the i-th query.
If it is impossible to equalize prices of all given products with restriction that for all products the condition |a_i - B| β€ k should be satisfied (where a_i is the old price of the product and B is the new equal price of all products), print -1. Otherwise print the maximum possible equal price of all products.
Example
Input
4
5 1
1 1 2 3 1
4 2
6 4 8 5
2 2
1 6
3 5
5 2 5
Output
2
6
-1
7
Note
In the first example query you can choose the price B=2. It is easy to see that the difference between each old price and each new price B=2 is no more than 1.
In the second example query you can choose the price B=6 and then all the differences between old and new price B=6 will be no more than 2.
In the third example query you cannot choose any suitable price B. For any value B at least one condition out of two will be violated: |1-B| β€ 2, |6-B| β€ 2.
In the fourth example query all values B between 1 and 7 are valid. But the maximum is 7, so it's the answer.
|
def readInts():
return [int(x) for x in input().split(' ')]
Q = int(input())
for q in range(Q):
[N, K] = readInts()
A = readInts()
B = min(A) + K
if max(A) - K > B:
B = -1
print(B)
|
{
"input": [
"4\n5 1\n1 1 2 3 1\n4 2\n6 4 8 5\n2 2\n1 6\n3 5\n5 2 5\n"
],
"output": [
"2\n6\n-1\n7\n"
]
}
|
3,974 | 9 |
Amugae is in a very large round corridor. The corridor consists of two areas. The inner area is equally divided by n sectors, and the outer area is equally divided by m sectors. A wall exists between each pair of sectors of same area (inner or outer), but there is no wall between the inner area and the outer area. A wall always exists at the 12 o'clock position.
<image>
The inner area's sectors are denoted as (1,1), (1,2), ..., (1,n) in clockwise direction. The outer area's sectors are denoted as (2,1), (2,2), ..., (2,m) in the same manner. For a clear understanding, see the example image above.
Amugae wants to know if he can move from one sector to another sector. He has q questions.
For each question, check if he can move between two given sectors.
Input
The first line contains three integers n, m and q (1 β€ n, m β€ 10^{18}, 1 β€ q β€ 10^4) β the number of sectors in the inner area, the number of sectors in the outer area and the number of questions.
Each of the next q lines contains four integers s_x, s_y, e_x, e_y (1 β€ s_x, e_x β€ 2; if s_x = 1, then 1 β€ s_y β€ n, otherwise 1 β€ s_y β€ m; constraints on e_y are similar). Amague wants to know if it is possible to move from sector (s_x, s_y) to sector (e_x, e_y).
Output
For each question, print "YES" if Amugae can move from (s_x, s_y) to (e_x, e_y), and "NO" otherwise.
You can print each letter in any case (upper or lower).
Example
Input
4 6 3
1 1 2 3
2 6 1 2
2 6 2 4
Output
YES
NO
YES
Note
Example is shown on the picture in the statement.
|
from math import gcd
n, m, q = map(int, input().split())
d = gcd(n, m)
def f(x, y):
return (y - 1) * d // (n if x == 1 else m)
for _ in range(q):
sx, sy, ex, ey = map(int, input().split())
print("YES" if f(sx, sy) == f(ex, ey) else "NO")
|
{
"input": [
"4 6 3\n1 1 2 3\n2 6 1 2\n2 6 2 4\n"
],
"output": [
"YES\nNO\nYES\n"
]
}
|
3,975 | 8 |
Ujan has a lot of useless stuff in his drawers, a considerable part of which are his math notebooks: it is time to sort them out. This time he found an old dusty graph theory notebook with a description of a graph.
It is an undirected weighted graph on n vertices. It is a complete graph: each pair of vertices is connected by an edge. The weight of each edge is either 0 or 1; exactly m edges have weight 1, and all others have weight 0.
Since Ujan doesn't really want to organize his notes, he decided to find the weight of the minimum spanning tree of the graph. (The weight of a spanning tree is the sum of all its edges.) Can you find the answer for Ujan so he stops procrastinating?
Input
The first line of the input contains two integers n and m (1 β€ n β€ 10^5, 0 β€ m β€ min((n(n-1))/(2),10^5)), the number of vertices and the number of edges of weight 1 in the graph.
The i-th of the next m lines contains two integers a_i and b_i (1 β€ a_i, b_i β€ n, a_i β b_i), the endpoints of the i-th edge of weight 1.
It is guaranteed that no edge appears twice in the input.
Output
Output a single integer, the weight of the minimum spanning tree of the graph.
Examples
Input
6 11
1 3
1 4
1 5
1 6
2 3
2 4
2 5
2 6
3 4
3 5
3 6
Output
2
Input
3 0
Output
0
Note
The graph from the first sample is shown below. Dashed edges have weight 0, other edges have weight 1. One of the minimum spanning trees is highlighted in orange and has total weight 2.
<image>
In the second sample, all edges have weight 0 so any spanning tree has total weight 0.
|
from sys import stdin
def rl():
return [int(w) for w in stdin.readline().split()]
n,m = rl()
he = [set() for _ in range(n+1)]
for _ in range(m):
a,b = rl()
he[a].add(b)
he[b].add(a)
unvisited = set(range(1,n+1))
ccs = 0
while unvisited:
fringe = {unvisited.pop()}
while fringe:
v = fringe.pop()
nxt = [u for u in unvisited if u not in he[v]]
unvisited.difference_update(nxt)
fringe.update(nxt)
ccs += 1
print(ccs-1)
|
{
"input": [
"6 11\n1 3\n1 4\n1 5\n1 6\n2 3\n2 4\n2 5\n2 6\n3 4\n3 5\n3 6\n",
"3 0\n"
],
"output": [
"2\n",
"0\n"
]
}
|
3,976 | 8 |
This is the harder version of the problem. In this version, 1 β€ n, m β€ 2β
10^5. You can hack this problem if you locked it. But you can hack the previous problem only if you locked both problems.
You are given a sequence of integers a=[a_1,a_2,...,a_n] of length n. Its subsequence is obtained by removing zero or more elements from the sequence a (they do not necessarily go consecutively). For example, for the sequence a=[11,20,11,33,11,20,11]:
* [11,20,11,33,11,20,11], [11,20,11,33,11,20], [11,11,11,11], [20], [33,20] are subsequences (these are just some of the long list);
* [40], [33,33], [33,20,20], [20,20,11,11] are not subsequences.
Suppose that an additional non-negative integer k (1 β€ k β€ n) is given, then the subsequence is called optimal if:
* it has a length of k and the sum of its elements is the maximum possible among all subsequences of length k;
* and among all subsequences of length k that satisfy the previous item, it is lexicographically minimal.
Recall that the sequence b=[b_1, b_2, ..., b_k] is lexicographically smaller than the sequence c=[c_1, c_2, ..., c_k] if the first element (from the left) in which they differ less in the sequence b than in c. Formally: there exists t (1 β€ t β€ k) such that b_1=c_1, b_2=c_2, ..., b_{t-1}=c_{t-1} and at the same time b_t<c_t. For example:
* [10, 20, 20] lexicographically less than [10, 21, 1],
* [7, 99, 99] is lexicographically less than [10, 21, 1],
* [10, 21, 0] is lexicographically less than [10, 21, 1].
You are given a sequence of a=[a_1,a_2,...,a_n] and m requests, each consisting of two numbers k_j and pos_j (1 β€ k β€ n, 1 β€ pos_j β€ k_j). For each query, print the value that is in the index pos_j of the optimal subsequence of the given sequence a for k=k_j.
For example, if n=4, a=[10,20,30,20], k_j=2, then the optimal subsequence is [20,30] β it is the minimum lexicographically among all subsequences of length 2 with the maximum total sum of items. Thus, the answer to the request k_j=2, pos_j=1 is the number 20, and the answer to the request k_j=2, pos_j=2 is the number 30.
Input
The first line contains an integer n (1 β€ n β€ 2β
10^5) β the length of the sequence a.
The second line contains elements of the sequence a: integer numbers a_1, a_2, ..., a_n (1 β€ a_i β€ 10^9).
The third line contains an integer m (1 β€ m β€ 2β
10^5) β the number of requests.
The following m lines contain pairs of integers k_j and pos_j (1 β€ k β€ n, 1 β€ pos_j β€ k_j) β the requests.
Output
Print m integers r_1, r_2, ..., r_m (1 β€ r_j β€ 10^9) one per line: answers to the requests in the order they appear in the input. The value of r_j should be equal to the value contained in the position pos_j of the optimal subsequence for k=k_j.
Examples
Input
3
10 20 10
6
1 1
2 1
2 2
3 1
3 2
3 3
Output
20
10
20
10
20
10
Input
7
1 2 1 3 1 2 1
9
2 1
2 2
3 1
3 2
3 3
1 1
7 1
7 7
7 4
Output
2
3
2
3
2
3
1
1
3
Note
In the first example, for a=[10,20,10] the optimal subsequences are:
* for k=1: [20],
* for k=2: [10,20],
* for k=3: [10,20,10].
|
import sys
input=sys.stdin.readline
from operator import itemgetter
def updatebit(BITTree , n , i ,v):
#print('n',n)
while i <= n:
#print('i',i)
BITTree[i] += v
i += i & (-i)
#print(BITTree)
def bisect_left( val):
sum_ = 0
pos = 0
bit_length = (n+1).bit_length()
for i in range(bit_length, -1, -1):
k = pos + (1 << i)
#print('a',sum_,val,k,pos)
if k < n + 1 and sum_ + l[k] < val:
sum_ += l[k]
pos += 1 << i
#print('b',sum_,self.bit[k],val,k,pos)
return pos
n=int(input())
l=[0]*(n+1)
a=[int(i) for i in input().split() if i!='\n']
empty=[]
for i in range(len(a)):
empty.append([a[i],i+1])
empty.sort(key=lambda x:x[1])
empty.sort(key=lambda x:x[0], reverse=True)
m = int(input())
info = [list(map(int, input().split())) + [i] for i in range(m) if i!='\n']
info = sorted(info, key = itemgetter(0))
#print(empty)
bit,ans,cnt=[0]*(n+1),[0]*(m),0
for i in range(m):
k, pos, ind = info[i]
while cnt < k:
updatebit(l,n,empty[cnt][1], 1)
cnt += 1
ans[ind] = a[bisect_left(pos)]
for i in ans:
sys.stdout.write(str(i)+'\n')
|
{
"input": [
"7\n1 2 1 3 1 2 1\n9\n2 1\n2 2\n3 1\n3 2\n3 3\n1 1\n7 1\n7 7\n7 4\n",
"3\n10 20 10\n6\n1 1\n2 1\n2 2\n3 1\n3 2\n3 3\n"
],
"output": [
"2\n3\n2\n3\n2\n3\n1\n1\n3\n",
"20\n10\n20\n10\n20\n10\n"
]
}
|
3,977 | 10 |
There are n Christmas trees on an infinite number line. The i-th tree grows at the position x_i. All x_i are guaranteed to be distinct.
Each integer point can be either occupied by the Christmas tree, by the human or not occupied at all. Non-integer points cannot be occupied by anything.
There are m people who want to celebrate Christmas. Let y_1, y_2, ..., y_m be the positions of people (note that all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct and all y_j should be integer). You want to find such an arrangement of people that the value β_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| is the minimum possible (in other words, the sum of distances to the nearest Christmas tree for all people should be minimized).
In other words, let d_j be the distance from the j-th human to the nearest Christmas tree (d_j = min_{i=1}^{n} |y_j - x_i|). Then you need to choose such positions y_1, y_2, ..., y_m that β_{j=1}^{m} d_j is the minimum possible.
Input
The first line of the input contains two integers n and m (1 β€ n, m β€ 2 β
10^5) β the number of Christmas trees and the number of people.
The second line of the input contains n integers x_1, x_2, ..., x_n (-10^9 β€ x_i β€ 10^9), where x_i is the position of the i-th Christmas tree. It is guaranteed that all x_i are distinct.
Output
In the first line print one integer res β the minimum possible value of β_{j=1}^{m}min_{i=1}^{n}|x_i - y_j| (in other words, the sum of distances to the nearest Christmas tree for all people).
In the second line print m integers y_1, y_2, ..., y_m (-2 β
10^9 β€ y_j β€ 2 β
10^9), where y_j is the position of the j-th human. All y_j should be distinct and all values x_1, x_2, ..., x_n, y_1, y_2, ..., y_m should be distinct.
If there are multiple answers, print any of them.
Examples
Input
2 6
1 5
Output
8
-1 2 6 4 0 3
Input
3 5
0 3 1
Output
7
5 -2 4 -1 2
|
from collections import defaultdict, deque
def put():
return map(int, input().split())
n,m = put()
l = list(put())
vis = defaultdict()
q = deque()
for i in l:
vis[i]=1
for j in [i-1, i+1]:
q.append((j,1))
ans,l = 0, []
while q and m>0:
i, d = q.popleft()
if i in vis:
continue
vis[i]=1
m-=1
l.append(i)
ans+=d
for j in [i-1, i+1]:
q.append((j,d+1))
print(ans)
print(*l)
|
{
"input": [
"3 5\n0 3 1\n",
"2 6\n1 5\n"
],
"output": [
"7\n-1 2 4 -2 5 ",
"8\n0 2 4 6 -1 3 "
]
}
|
3,978 | 7 |
You are given two integers n and k. Your task is to find if n can be represented as a sum of k distinct positive odd (not divisible by 2) integers or not.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 β€ t β€ 10^5) β the number of test cases.
The next t lines describe test cases. The only line of the test case contains two integers n and k (1 β€ n, k β€ 10^7).
Output
For each test case, print the answer β "YES" (without quotes) if n can be represented as a sum of k distinct positive odd (not divisible by 2) integers and "NO" otherwise.
Example
Input
6
3 1
4 2
10 3
10 2
16 4
16 5
Output
YES
YES
NO
YES
YES
NO
Note
In the first test case, you can represent 3 as 3.
In the second test case, the only way to represent 4 is 1+3.
In the third test case, you cannot represent 10 as the sum of three distinct positive odd integers.
In the fourth test case, you can represent 10 as 3+7, for example.
In the fifth test case, you can represent 16 as 1+3+5+7.
In the sixth test case, you cannot represent 16 as the sum of five distinct positive odd integers.
|
def main():
for _ in range(int(input())):
n,k=list(map(int,input().split()))
print("YES" if(n%2==k%2 and n>=k*k) else "NO")
main()
|
{
"input": [
"6\n3 1\n4 2\n10 3\n10 2\n16 4\n16 5\n"
],
"output": [
"YES\nYES\nNO\nYES\nYES\nNO\n"
]
}
|
3,979 | 7 |
Leo has developed a new programming language C+=. In C+=, integer variables can only be changed with a "+=" operation that adds the right-hand side value to the left-hand side variable. For example, performing "a += b" when a = 2, b = 3 changes the value of a to 5 (the value of b does not change).
In a prototype program Leo has two integer variables a and b, initialized with some positive values. He can perform any number of operations "a += b" or "b += a". Leo wants to test handling large integers, so he wants to make the value of either a or b strictly greater than a given value n. What is the smallest number of operations he has to perform?
Input
The first line contains a single integer T (1 β€ T β€ 100) β the number of test cases.
Each of the following T lines describes a single test case, and contains three integers a, b, n (1 β€ a, b β€ n β€ 10^9) β initial values of a and b, and the value one of the variables has to exceed, respectively.
Output
For each test case print a single integer β the smallest number of operations needed. Separate answers with line breaks.
Example
Input
2
1 2 3
5 4 100
Output
2
7
Note
In the first case we cannot make a variable exceed 3 in one operation. One way of achieving this in two operations is to perform "b += a" twice.
|
def f(a,b,n,o):
if a > n or b > n:
return o
return f(max(a,b), a + b, n, o + 1)
for __ in range(int(input())):
a, b, n = [ int(_) for _ in input().split() ]
print(f(a,b,n,0))
|
{
"input": [
"2\n1 2 3\n5 4 100\n"
],
"output": [
"2\n7\n"
]
}
|
3,980 | 9 |
Let's call left cyclic shift of some string t_1 t_2 t_3 ... t_{n - 1} t_n as string t_2 t_3 ... t_{n - 1} t_n t_1.
Analogically, let's call right cyclic shift of string t as string t_n t_1 t_2 t_3 ... t_{n - 1}.
Let's say string t is good if its left cyclic shift is equal to its right cyclic shift.
You are given string s which consists of digits 0β9.
What is the minimum number of characters you need to erase from s to make it good?
Input
The first line contains single integer t (1 β€ t β€ 1000) β the number of test cases.
Next t lines contains test cases β one per line. The first and only line of each test case contains string s (2 β€ |s| β€ 2 β
10^5). Each character s_i is digit 0β9.
It's guaranteed that the total length of strings doesn't exceed 2 β
10^5.
Output
For each test case, print the minimum number of characters you need to erase from s to make it good.
Example
Input
3
95831
100120013
252525252525
Output
3
5
0
Note
In the first test case, you can erase any 3 characters, for example, the 1-st, the 3-rd, and the 4-th. You'll get string 51 and it is good.
In the second test case, we can erase all characters except 0: the remaining string is 0000 and it's good.
In the third test case, the given string s is already good.
|
def sol(s,x,y):
c=0
for i in s:
if int(i)==x:
c+=1
x,y=y,x
if x!=y and c&1:
c-=1
return c
for i in range(int(input())):
ans=0
s=input()
n=len(s)
for x in range(10):
for y in range(10):
ans=max(ans,sol(s,x,y))
print(n-ans)
|
{
"input": [
"3\n95831\n100120013\n252525252525\n"
],
"output": [
"3\n5\n0\n"
]
}
|
3,981 | 12 |
You are given two strings s and t consisting of lowercase Latin letters. The length of t is 2 (i.e. this string consists only of two characters).
In one move, you can choose any character of s and replace it with any lowercase Latin letter. More formally, you choose some i and replace s_i (the character at the position i) with some character from 'a' to 'z'.
You want to do no more than k replacements in such a way that maximizes the number of occurrences of t in s as a subsequence.
Recall that a subsequence is a sequence that can be derived from the given sequence by deleting zero or more elements without changing the order of the remaining elements.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200; 0 β€ k β€ n) β the length of s and the maximum number of moves you can make. The second line of the input contains the string s consisting of n lowercase Latin letters. The third line of the input contains the string t consisting of two lowercase Latin letters.
Output
Print one integer β the maximum possible number of occurrences of t in s as a subsequence if you replace no more than k characters in s optimally.
Examples
Input
4 2
bbaa
ab
Output
3
Input
7 3
asddsaf
sd
Output
10
Input
15 6
qwertyhgfdsazxc
qa
Output
16
Input
7 2
abacaba
aa
Output
15
Note
In the first example, you can obtain the string "abab" replacing s_1 with 'a' and s_4 with 'b'. Then the answer is 3.
In the second example, you can obtain the string "ssddsdd" and get the answer 10.
In the fourth example, you can obtain the string "aaacaaa" and get the answer 15.
|
def g(i,z,k):
if i>=n:return 0
if q[i][z][k]>-1:return q[i][z][k]
o=g(i+1,z,k);c=s[i]!=t[0]
if k>=c:o=max(o,g(i+1,z+1,k-c))
c=s[i]!=t[1]
if k>=c:o=max(o,g(i+1,z+(t[0]==t[1]),k-c)+z)
q[i][z][k]=o;return o
I=input
n,k=map(int,I().split());s=I();t=I();q=[[[-1]*(n+1)for _ in[0]*n]for _ in[0]*n]
print(g(0,0,k))
|
{
"input": [
"7 2\nabacaba\naa\n",
"15 6\nqwertyhgfdsazxc\nqa\n",
"7 3\nasddsaf\nsd\n",
"4 2\nbbaa\nab\n"
],
"output": [
"15\n",
"16\n",
"10\n",
"3\n"
]
}
|
3,982 | 10 |
You have a string s consisting of n characters. Each character is either 0 or 1.
You can perform operations on the string. Each operation consists of two steps:
1. select an integer i from 1 to the length of the string s, then delete the character s_i (the string length gets reduced by 1, the indices of characters to the right of the deleted one also get reduced by 1);
2. if the string s is not empty, delete the maximum length prefix consisting of the same characters (the indices of the remaining characters and the string length get reduced by the length of the deleted prefix).
Note that both steps are mandatory in each operation, and their order cannot be changed.
For example, if you have a string s = 111010, the first operation can be one of the following:
1. select i = 1: we'll get 111010 β 11010 β 010;
2. select i = 2: we'll get 111010 β 11010 β 010;
3. select i = 3: we'll get 111010 β 11010 β 010;
4. select i = 4: we'll get 111010 β 11110 β 0;
5. select i = 5: we'll get 111010 β 11100 β 00;
6. select i = 6: we'll get 111010 β 11101 β 01.
You finish performing operations when the string s becomes empty. What is the maximum number of operations you can perform?
Input
The first line contains a single integer t (1 β€ t β€ 1000) β the number of test cases.
The first line of each test case contains a single integer n (1 β€ n β€ 2 β
10^5) β the length of the string s.
The second line contains string s of n characters. Each character is either 0 or 1.
It's guaranteed that the total sum of n over test cases doesn't exceed 2 β
10^5.
Output
For each test case, print a single integer β the maximum number of operations you can perform.
Example
Input
5
6
111010
1
0
1
1
2
11
6
101010
Output
3
1
1
1
3
Note
In the first test case, you can, for example, select i = 2 and get string 010 after the first operation. After that, you can select i = 3 and get string 1. Finally, you can only select i = 1 and get empty string.
|
import math
def mi(): return map(int,input().strip().split(" "))
for _ in range(int(input())):
n=int(input())
s=input()
ans=0
cnt=1
for i in range(1,n):
if s[i]==s[i-1]:
ans+=1
ans=min(ans,cnt)
else:
cnt+=1
#print(cnt)
ans+=(cnt-ans+1)//2
print(ans)
|
{
"input": [
"5\n6\n111010\n1\n0\n1\n1\n2\n11\n6\n101010\n"
],
"output": [
"3\n1\n1\n1\n3\n"
]
}
|
3,983 | 12 |
Gildong is now developing a puzzle game. The puzzle consists of n platforms numbered from 1 to n. The player plays the game as a character that can stand on each platform and the goal of the game is to move the character from the 1-st platform to the n-th platform.
The i-th platform is labeled with an integer a_i (0 β€ a_i β€ n-i). When the character is standing on the i-th platform, the player can move the character to any of the j-th platforms where i+1 β€ j β€ i+a_i. If the character is on the i-th platform where a_i=0 and i β n, the player loses the game.
Since Gildong thinks the current game is not hard enough, he wants to make it even harder. He wants to change some (possibly zero) labels to 0 so that there remains exactly one way to win. He wants to modify the game as little as possible, so he's asking you to find the minimum number of platforms that should have their labels changed. Two ways are different if and only if there exists a platform the character gets to in one way but not in the other way.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 β€ t β€ 500).
Each test case contains two lines. The first line of each test case consists of an integer n (2 β€ n β€ 3000) β the number of platforms of the game.
The second line of each test case contains n integers. The i-th integer is a_i (0 β€ a_i β€ n-i) β the integer of the i-th platform.
It is guaranteed that:
* For each test case, there is at least one way to win initially.
* The sum of n in all test cases doesn't exceed 3000.
Output
For each test case, print one integer β the minimum number of different labels that should be changed to 0 so that there remains exactly one way to win.
Example
Input
3
4
1 1 1 0
5
4 3 2 1 0
9
4 1 4 2 1 0 2 1 0
Output
0
3
2
Note
In the first case, the player can only move to the next platform until they get to the 4-th platform. Since there is already only one way to win, the answer is zero.
In the second case, Gildong can change a_2, a_3, and a_4 to 0 so that the game becomes 4 0 0 0 0. Now the only way the player can win is to move directly from the 1-st platform to the 5-th platform.
In the third case, Gildong can change a_2 and a_8 to 0, then the only way to win is to move in the following way: 1 β 3 β 7 β 9.
|
MAX_N = 3000;inf = MAX_N
def solve():
global inf;n = int(input());a = [0] + list(map(int, input().split()));dp = [[0] * (n + 1) for i in range(n + 1)]
for i in range(2, n + 1):
cnt = 0
for j in range(i, n + 1):dp[i][j] = inf
for j in range(i - 1, 0, -1):
if j + a[j] >= i:dp[i][j + a[j]] = min(dp[i][j + a[j]], dp[j][i - 1 ] + cnt);cnt += 1
for j in range(i + 1, n + 1):dp[i][j] = min(dp[i][j], dp[i][j - 1])
return dp[n][n]
for _ in range(int(input())):print(solve())
|
{
"input": [
"3\n4\n1 1 1 0\n5\n4 3 2 1 0\n9\n4 1 4 2 1 0 2 1 0\n"
],
"output": [
"\n0\n3\n2\n"
]
}
|
3,984 | 8 |
There is a binary string a of length n. In one operation, you can select any prefix of a with an equal number of 0 and 1 symbols. Then all symbols in the prefix are inverted: each 0 becomes 1 and each 1 becomes 0.
For example, suppose a=0111010000.
* In the first operation, we can select the prefix of length 8 since it has four 0's and four 1's: [01110100]00β [10001011]00.
* In the second operation, we can select the prefix of length 2 since it has one 0 and one 1: [10]00101100β [01]00101100.
* It is illegal to select the prefix of length 4 for the third operation, because it has three 0's and one 1.
Can you transform the string a into the string b using some finite number of operations (possibly, none)?
Input
The first line contains a single integer t (1β€ tβ€ 10^4) β the number of test cases.
The first line of each test case contains a single integer n (1β€ nβ€ 3β
10^5) β the length of the strings a and b.
The following two lines contain strings a and b of length n, consisting of symbols 0 and 1.
The sum of n across all test cases does not exceed 3β
10^5.
Output
For each test case, output "YES" if it is possible to transform a into b, or "NO" if it is impossible. You can print each letter in any case (upper or lower).
Example
Input
5
10
0111010000
0100101100
4
0000
0000
3
001
000
12
010101010101
100110011010
6
000111
110100
Output
YES
YES
NO
YES
NO
Note
The first test case is shown in the statement.
In the second test case, we transform a into b by using zero operations.
In the third test case, there is no legal operation, so it is impossible to transform a into b.
In the fourth test case, here is one such transformation:
* Select the length 2 prefix to get 100101010101.
* Select the length 12 prefix to get 011010101010.
* Select the length 8 prefix to get 100101011010.
* Select the length 4 prefix to get 011001011010.
* Select the length 6 prefix to get 100110011010.
In the fifth test case, the only legal operation is to transform a into 111000. From there, the only legal operation is to return to the string we started with, so we cannot transform a into b.
|
def equivalent(prefix1, prefix2):
num1 = int(prefix1, 2)
num2 = int(prefix2, 2)
return num1 == num2 or ((2**len(prefix1) - 1) ^ num1) == num2
tests = int(input())
for k in range(tests):
length = int(input())
num1 = input()
num2 = input()
last = 0
ones = 0
zeroes = 0
for k in range(length):
if num1[k] == '1':
ones += 1
else:
zeroes += 1
if ones == zeroes:
if not equivalent(num1[last:k + 1], num2[last:k + 1]):
break
last = k + 1
if (num1[last:] == num2[last:]):
print("YES")
else:
print("NO")
|
{
"input": [
"5\n10\n0111010000\n0100101100\n4\n0000\n0000\n3\n001\n000\n12\n010101010101\n100110011010\n6\n000111\n110100\n"
],
"output": [
"\nYES\nYES\nNO\nYES\nNO\n"
]
}
|
3,985 | 7 |
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
The first line contains an integer t (1β€ tβ€ 250) β the number of test cases. The description of the test cases follows.
The first line of each test case contains a single integer n (2β€ nβ€ 10^5) β the number of vertices in Parsa's tree.
The i-th of the following n lines contains two integers l_i and r_i (1 β€ l_i β€ r_i β€ 10^9).
Each of the next n-1 lines contains two integers u and v (1 β€ u , v β€ n, uβ v) meaning that there is an edge between the vertices u and v in Parsa's tree.
It is guaranteed that the given graph is a tree.
It is guaranteed that the sum of n over all test cases doesn't exceed 2 β
10^5.
Output
For each test case print the maximum possible beauty for Parsa's tree.
Example
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
Note
The trees in the example:
<image>
In the first test case, one possible assignment is a = \{1, 8\} which results in |1 - 8| = 7.
In the second test case, one of the possible assignments is a = \{1, 5, 9\} which results in a beauty of |1 - 5| + |5 - 9| = 8
|
import sys
input = sys.stdin.buffer.readline
def main():
t = int(input()); INF = float("inf")
for _ in range(t):
n = int(input())
L = []; R = []
for i in range(n):
l,r = map(int,input().split())
L.append(l); R.append(r)
G = [[] for _ in range(n)]
for i in range(n-1):
a,b = map(int,input().split())
a-=1;b-=1 #0-index
G[a].append(b)
G[b].append(a)
root = 0
#depth = [-1]*n
#depth[0] = 0
par = [-1]*n
#depth_list = defaultdict(list)
#depth_list[0].append(root)
stack = []
stack.append(~0)
stack.append(0)
dp = [[0, 0] for _ in range(n)]
#cnt = 0
while stack:
#cnt += 1
v = stack.pop()
if v >= 0:
for u in G[v]:
if u == par[v]: continue
par[u] = v
stack.append(~u)
stack.append(u)
else:
u = ~v #child
v = par[u] #parent
if v == -1: continue
zero = max(dp[u][0] + abs(L[v] - L[u]), dp[u][1] + abs(L[v] - R[u]))
one = max(dp[u][0] + abs(R[v] - L[u]), dp[u][1] + abs(R[v] - R[u]))
dp[v][0] += zero
dp[v][1] += one
ans = max(dp[0])
#print("CNT",cnt)
#print(dp)
print(ans)
if __name__ == "__main__":
main()
|
{
"input": [
"3\n2\n1 6\n3 8\n1 2\n3\n1 3\n4 6\n7 9\n1 2\n2 3\n6\n3 14\n12 20\n12 19\n2 12\n10 17\n3 17\n3 2\n6 5\n1 5\n2 6\n4 6\n"
],
"output": [
"\n7\n8\n62\n"
]
}
|
3,986 | 8 |
There are n piles of stones of sizes a1, a2, ..., an lying on the table in front of you.
During one move you can take one pile and add it to the other. As you add pile i to pile j, the size of pile j increases by the current size of pile i, and pile i stops existing. The cost of the adding operation equals the size of the added pile.
Your task is to determine the minimum cost at which you can gather all stones in one pile.
To add some challenge, the stone piles built up conspiracy and decided that each pile will let you add to it not more than k times (after that it can only be added to another pile).
Moreover, the piles decided to puzzle you completely and told you q variants (not necessarily distinct) of what k might equal.
Your task is to find the minimum cost for each of q variants.
Input
The first line contains integer n (1 β€ n β€ 105) β the number of stone piles. The second line contains n space-separated integers: a1, a2, ..., an (1 β€ ai β€ 109) β the initial sizes of the stone piles.
The third line contains integer q (1 β€ q β€ 105) β the number of queries. The last line contains q space-separated integers k1, k2, ..., kq (1 β€ ki β€ 105) β the values of number k for distinct queries. Note that numbers ki can repeat.
Output
Print q whitespace-separated integers β the answers to the queries in the order, in which the queries are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
2 3 4 1 1
2
2 3
Output
9 8
Note
In the first sample one way to get the optimal answer goes like this: we add in turns the 4-th and the 5-th piles to the 2-nd one; then we add the 1-st pile to the 3-rd one; we add the 2-nd pile to the 3-rd one. The first two operations cost 1 each; the third one costs 2, the fourth one costs 5 (the size of the 2-nd pile after the first two operations is not 3, it already is 5).
In the second sample you can add the 2-nd pile to the 3-rd one (the operations costs 3); then the 1-st one to the 3-th one (the cost is 2); then the 5-th one to the 4-th one (the costs is 1); and at last, the 4-th one to the 3-rd one (the cost is 2).
|
class CodeforcesTask226BSolution:
def __init__(self):
self.result = ''
self.n = 0
self.piles = []
self.q = 0
self.variants = []
def read_input(self):
self.n = int(input())
self.piles = [int(x) for x in input().split(" ")]
self.q = int(input())
self.variants = [int(x) for x in input().split(" ")]
def process_task(self):
self.piles.sort(reverse=True)
sums = [0] * self.n
sums[0] = self.piles[0]
for x in range(self.n - 1):
sums[x + 1] = self.piles[x + 1] + sums[x]
anwsers = {}
results = []
for query in self.variants:
if query in anwsers.keys():
results.append(anwsers[query])
else:
anwser = 0
factor = 1
k = 1
width = query
x = 1
while x + width < self.n:
anwser += (sums[x + width - 1] - sums[x - 1]) * factor
factor += 1
x += width
k += 1
width = query ** k
anwser += (sums[-1] - sums[x - 1]) * factor
results.append(anwser)
anwsers[query] = anwser
self.result = " ".join([str(x) for x in results])
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask226BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
|
{
"input": [
"5\n2 3 4 1 1\n2\n2 3\n"
],
"output": [
" 9 8\n"
]
}
|
3,987 | 7 |
Lenny is playing a game on a 3 Γ 3 grid of lights. In the beginning of the game all lights are switched on. Pressing any of the lights will toggle it and all side-adjacent lights. The goal of the game is to switch all the lights off. We consider the toggling as follows: if the light was switched on then it will be switched off, if it was switched off then it will be switched on.
Lenny has spent some time playing with the grid and by now he has pressed each light a certain number of times. Given the number of times each light is pressed, you have to print the current state of each light.
Input
The input consists of three rows. Each row contains three integers each between 0 to 100 inclusive. The j-th number in the i-th row is the number of times the j-th light of the i-th row of the grid is pressed.
Output
Print three lines, each containing three characters. The j-th character of the i-th line is "1" if and only if the corresponding light is switched on, otherwise it's "0".
Examples
Input
1 0 0
0 0 0
0 0 1
Output
001
010
100
Input
1 0 1
8 8 8
2 0 3
Output
010
011
100
|
def lit(v,x,y):
s = v[x][y]
if(x<2):s+=v[x+1][y];
if(y<2):s+=v[x][y+1];
if(x>0):s+=v[x-1][y];
if(y>0):s+=v[x][y-1];
return (s+1)%2
v=[]
for i in range(3):
v.append([i%2 for i in list(map(int,input().strip().split()))])
for i in range(3):
for j in range(3):
print(lit(v,i,j),end="")
print()
|
{
"input": [
"1 0 0\n0 0 0\n0 0 1\n",
"1 0 1\n8 8 8\n2 0 3\n"
],
"output": [
"001\n010\n100\n",
"010\n011\n100\n"
]
}
|
3,988 | 9 |
You are fishing with polar bears Alice and Bob. While waiting for the fish to bite, the polar bears get bored. They come up with a game. First Alice and Bob each writes a 01-string (strings that only contain character "0" and "1") a and b. Then you try to turn a into b using two types of operations:
* Write parity(a) to the end of a. For example, <image>.
* Remove the first character of a. For example, <image>. You cannot perform this operation if a is empty.
You can use as many operations as you want. The problem is, is it possible to turn a into b?
The parity of a 01-string is 1 if there is an odd number of "1"s in the string, and 0 otherwise.
Input
The first line contains the string a and the second line contains the string b (1 β€ |a|, |b| β€ 1000). Both strings contain only the characters "0" and "1". Here |x| denotes the length of the string x.
Output
Print "YES" (without quotes) if it is possible to turn a into b, and "NO" (without quotes) otherwise.
Examples
Input
01011
0110
Output
YES
Input
0011
1110
Output
NO
Note
In the first sample, the steps are as follows: 01011 β 1011 β 011 β 0110
|
def main():
a, b = (input().count('1') for _ in "ab")
print(("NO", "YES")[a + (a & 1) >= b])
if __name__ == '__main__':
main()
|
{
"input": [
"0011\n1110\n",
"01011\n0110\n"
],
"output": [
"NO\n",
"YES\n"
]
}
|
3,989 | 7 |
Fox Ciel has a robot on a 2D plane. Initially it is located in (0, 0). Fox Ciel code a command to it. The command was represented by string s. Each character of s is one move operation. There are four move operations at all:
* 'U': go up, (x, y) β (x, y+1);
* 'D': go down, (x, y) β (x, y-1);
* 'L': go left, (x, y) β (x-1, y);
* 'R': go right, (x, y) β (x+1, y).
The robot will do the operations in s from left to right, and repeat it infinite times. Help Fox Ciel to determine if after some steps the robot will located in (a, b).
Input
The first line contains two integers a and b, ( - 109 β€ a, b β€ 109). The second line contains a string s (1 β€ |s| β€ 100, s only contains characters 'U', 'D', 'L', 'R') β the command.
Output
Print "Yes" if the robot will be located at (a, b), and "No" otherwise.
Examples
Input
2 2
RU
Output
Yes
Input
1 2
RU
Output
No
Input
-1 1000000000
LRRLU
Output
Yes
Input
0 0
D
Output
Yes
Note
In the first and second test case, command string is "RU", so the robot will go right, then go up, then right, and then up and so on.
The locations of its moves are (0, 0) β (1, 0) β (1, 1) β (2, 1) β (2, 2) β ...
So it can reach (2, 2) but not (1, 2).
|
def main():
a, b = map(int, input().split())
s, t = input(), -100
x = sum({"L": -1, "R": 1}.get(c, 0) for c in s)
y = sum({"D": -1, "U": 1}.get(c, 0) for c in s)
if x and y:
t += min(a // x, b // y)
elif x:
t += a // x
elif y:
t += b // y
if t > 0:
a -= t * x
b -= t * y
for c in s * 101:
if a == 0 == b:
print("Yes")
return
a -= {"L": -1, "R": 1}.get(c, 0)
b -= {"D": -1, "U": 1}.get(c, 0)
print("No")
if __name__ == '__main__':
main()
|
{
"input": [
"0 0\nD\n",
"-1 1000000000\nLRRLU\n",
"2 2\nRU\n",
"1 2\nRU\n"
],
"output": [
"Yes\n",
"Yes\n",
"Yes\n",
"No\n"
]
}
|
3,990 | 9 |
The city Valera lives in is going to hold elections to the city Parliament.
The city has n districts and n - 1 bidirectional roads. We know that from any district there is a path along the roads to any other district. Let's enumerate all districts in some way by integers from 1 to n, inclusive. Furthermore, for each road the residents decided if it is the problem road or not. A problem road is a road that needs to be repaired.
There are n candidates running the elections. Let's enumerate all candidates in some way by integers from 1 to n, inclusive. If the candidate number i will be elected in the city Parliament, he will perform exactly one promise β to repair all problem roads on the way from the i-th district to the district 1, where the city Parliament is located.
Help Valera and determine the subset of candidates such that if all candidates from the subset will be elected to the city Parliament, all problem roads in the city will be repaired. If there are several such subsets, you should choose the subset consisting of the minimum number of candidates.
Input
The first line contains a single integer n (2 β€ n β€ 105) β the number of districts in the city.
Then n - 1 lines follow. Each line contains the description of a city road as three positive integers xi, yi, ti (1 β€ xi, yi β€ n, 1 β€ ti β€ 2) β the districts connected by the i-th bidirectional road and the road type. If ti equals to one, then the i-th road isn't the problem road; if ti equals to two, then the i-th road is the problem road.
It's guaranteed that the graph structure of the city is a tree.
Output
In the first line print a single non-negative number k β the minimum size of the required subset of candidates. Then on the second line print k space-separated integers a1, a2, ... ak β the numbers of the candidates that form the required subset. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
5
1 2 2
2 3 2
3 4 2
4 5 2
Output
1
5
Input
5
1 2 1
2 3 2
2 4 1
4 5 1
Output
1
3
Input
5
1 2 2
1 3 2
1 4 2
1 5 2
Output
4
5 4 3 2
|
import sys
input=sys.stdin.readline
def dfs():
st=[(1,1)]
while st:
x,p=st.pop()
vis[x]=1
for v,k in g[x]:
if not vis[v]:
if k==2:
ans[v]=1
ans[p]=0
st.append((v,v))
else:st.append((v,p))
n=int(input())
g=[[] for i in range(n+1)]
for i in range(n-1):
x,y,k=map(int,input().split())
g[x].append((y,k))
g[y].append((x,k))
ans,vis=[0]*(n+1),[0]*(n+1)
dfs()
print(ans.count(1))
for i in range(n+1):
if ans[i]==1:print(i,end=' ')
print()
|
{
"input": [
"5\n1 2 2\n2 3 2\n3 4 2\n4 5 2\n",
"5\n1 2 1\n2 3 2\n2 4 1\n4 5 1\n",
"5\n1 2 2\n1 3 2\n1 4 2\n1 5 2\n"
],
"output": [
"1\n5\n",
"1\n3\n",
"4\n2 3 4 5 "
]
}
|
3,991 | 9 |
This problem consists of three subproblems: for solving subproblem C1 you will receive 4 points, for solving subproblem C2 you will receive 4 points, and for solving subproblem C3 you will receive 8 points.
Manao decided to pursue a fighter's career. He decided to begin with an ongoing tournament. Before Manao joined, there were n contestants in the tournament, numbered from 1 to n. Each of them had already obtained some amount of tournament points, namely the i-th fighter had pi points.
Manao is going to engage in a single fight against each contestant. Each of Manao's fights ends in either a win or a loss. A win grants Manao one point, and a loss grants Manao's opponent one point. For each i, Manao estimated the amount of effort ei he needs to invest to win against the i-th contestant. Losing a fight costs no effort.
After Manao finishes all of his fights, the ranklist will be determined, with 1 being the best rank and n + 1 being the worst. The contestants will be ranked in descending order of their tournament points. The contestants with the same number of points as Manao will be ranked better than him if they won the match against him and worse otherwise. The exact mechanism of breaking ties for other fighters is not relevant here.
Manao's objective is to have rank k or better. Determine the minimum total amount of effort he needs to invest in order to fulfill this goal, if it is possible.
Input
The first line contains a pair of integers n and k (1 β€ k β€ n + 1). The i-th of the following n lines contains two integers separated by a single space β pi and ei (0 β€ pi, ei β€ 200000).
The problem consists of three subproblems. The subproblems have different constraints on the input. You will get some score for the correct submission of the subproblem. The description of the subproblems follows.
* In subproblem C1 (4 points), the constraint 1 β€ n β€ 15 will hold.
* In subproblem C2 (4 points), the constraint 1 β€ n β€ 100 will hold.
* In subproblem C3 (8 points), the constraint 1 β€ n β€ 200000 will hold.
Output
Print a single number in a single line β the minimum amount of effort Manao needs to use to rank in the top k. If no amount of effort can earn Manao such a rank, output number -1.
Examples
Input
3 2
1 1
1 4
2 2
Output
3
Input
2 1
3 2
4 0
Output
-1
Input
5 2
2 10
2 10
1 1
3 1
3 1
Output
12
Note
Consider the first test case. At the time when Manao joins the tournament, there are three fighters. The first of them has 1 tournament point and the victory against him requires 1 unit of effort. The second contestant also has 1 tournament point, but Manao needs 4 units of effort to defeat him. The third contestant has 2 points and victory against him costs Manao 2 units of effort. Manao's goal is top be in top 2. The optimal decision is to win against fighters 1 and 3, after which Manao, fighter 2, and fighter 3 will all have 2 points. Manao will rank better than fighter 3 and worse than fighter 2, thus finishing in second place.
Consider the second test case. Even if Manao wins against both opponents, he will still rank third.
|
m = 301000
ns = [0] * m
es = [0] * m
c = [0] * m
b = [0] * m
t = [0] * m
P = 0
def add(b, k):
k = t[k]
while k:
e = es[k]
if b[-1] > e: b[-1] = e
b[e] += 1
k = ns[k]
def delete(b):
for i in range(b[m - 1], m + 1):
if b[i]:
b[i] -= 1
b[-1] = i
return i
def calc(k):
global b
q = 0
b = [0] * m
b[-1] = m
take = rank - dn
if take < 0: take = 0
add(b, k)
add(b, k - 1)
for i in range(1, take + 1): q += delete(b)
for i in range(k - 1): add(b, i)
for i in range(k + 1, P + 1): add(b, i)
for i in range(1, k - take + 1): q += delete(b)
return q
n, k = map(int, input().split())
rank = n - k + 1
if rank == 0:
print('0')
exit(0)
for i in range(1, n + 1):
p, e = map(int, input().split())
if p > P: P = p
c[p] += 1
es[i], ns[i] = e, t[p]
t[p] = i
dn = 0
for i in range(1, n + 1):
if i > 1: dn += c[i - 2]
if c[i] + c[i - 1] + dn >= rank and rank <= i + dn:
u = calc(i)
if i < n:
dn += c[i - 1]
v = calc(i + 1)
if u > v: u = v
if i < n - 1:
dn += c[i]
v = calc(i + 2)
if u > v: u = v
print(u)
exit(0)
print('-1')
|
{
"input": [
"3 2\n1 1\n1 4\n2 2\n",
"2 1\n3 2\n4 0\n",
"5 2\n2 10\n2 10\n1 1\n3 1\n3 1\n"
],
"output": [
"3",
"-1",
"12"
]
}
|
3,992 | 9 |
'Jeopardy!' is an intellectual game where players answer questions and earn points. Company Q conducts a simplified 'Jeopardy!' tournament among the best IT companies. By a lucky coincidence, the old rivals made it to the finals: company R1 and company R2.
The finals will have n questions, m of them are auction questions and n - m of them are regular questions. Each question has a price. The price of the i-th question is ai points. During the game the players chose the questions. At that, if the question is an auction, then the player who chose it can change the price if the number of his current points is strictly larger than the price of the question. The new price of the question cannot be less than the original price and cannot be greater than the current number of points of the player who chose the question. The correct answer brings the player the points equal to the price of the question. The wrong answer to the question reduces the number of the player's points by the value of the question price.
The game will go as follows. First, the R2 company selects a question, then the questions are chosen by the one who answered the previous question correctly. If no one answered the question, then the person who chose last chooses again.
All R2 employees support their team. They want to calculate what maximum possible number of points the R2 team can get if luck is on their side during the whole game (they will always be the first to correctly answer questions). Perhaps you are not going to be surprised, but this problem was again entrusted for you to solve.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 100; m β€ min(n, 30)) β the total number of questions and the number of auction questions, correspondingly. The second line contains n space-separated integers a1, a2, ..., an (1 β€ ai β€ 107) β the prices of the questions. The third line contains m distinct integers bi (1 β€ bi β€ n) β the numbers of auction questions. Assume that the questions are numbered from 1 to n.
Output
In the single line, print the answer to the problem β the maximum points the R2 company can get if it plays optimally well. It is guaranteed that the answer fits into the integer 64-bit signed type.
Examples
Input
4 1
1 3 7 5
3
Output
18
Input
3 2
10 3 8
2 3
Output
40
Input
2 2
100 200
1 2
Output
400
|
import sys
from itertools import *
from math import *
MAX = 10000000
def solve():
n, m = map(int, input().split())
quest = list(map(int, input().split()))
auctindex = set(map(int, input().split()))
aucts = list()
firstsum = 0
for i, q in enumerate(quest):
if (i + 1) not in auctindex:
firstsum+= q
else:
aucts.append(q)
aucts.sort(reverse = True)
for val in aucts:
firstsum += max(firstsum, val)
print(firstsum)
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
|
{
"input": [
"4 1\n1 3 7 5\n3\n",
"2 2\n100 200\n1 2\n",
"3 2\n10 3 8\n2 3\n"
],
"output": [
" 18",
" 400",
" 40"
]
}
|
3,993 | 11 |
Today s kilometer long auto race takes place in Berland. The track is represented by a straight line as long as s kilometers. There are n cars taking part in the race, all of them start simultaneously at the very beginning of the track. For every car is known its behavior β the system of segments on each of which the speed of the car is constant. The j-th segment of the i-th car is pair (vi, j, ti, j), where vi, j is the car's speed on the whole segment in kilometers per hour and ti, j is for how many hours the car had been driving at that speed. The segments are given in the order in which they are "being driven on" by the cars.
Your task is to find out how many times during the race some car managed to have a lead over another car. A lead is considered a situation when one car appears in front of another car. It is known, that all the leads happen instantly, i. e. there are no such time segment of positive length, during which some two cars drive "together". At one moment of time on one and the same point several leads may appear. In this case all of them should be taken individually. Meetings of cars at the start and finish are not considered to be counted as leads.
Input
The first line contains two integers n and s (2 β€ n β€ 100, 1 β€ s β€ 106) β the number of cars and the length of the track in kilometers. Then follow n lines β the description of the system of segments for each car. Every description starts with integer k (1 β€ k β€ 100) β the number of segments in the system. Then k space-separated pairs of integers are written. Each pair is the speed and time of the segment. These integers are positive and don't exceed 1000. It is guaranteed, that the sum of lengths of all segments (in kilometers) for each car equals to s; and all the leads happen instantly.
Output
Print the single number β the number of times some car managed to take the lead over another car during the race.
Examples
Input
2 33
2 5 1 2 14
1 3 11
Output
1
Input
2 33
2 1 3 10 3
1 11 3
Output
0
Input
5 33
2 1 3 3 10
1 11 3
2 5 3 3 6
2 3 1 10 3
2 6 3 3 5
Output
2
|
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n, s = map(int, input().split())
data = [dict() for _ in range(n)]
for i in range(n):
k, *a = map(int, input().split())
cur = 0
for j in range(0, 2 * k, 2):
data[i][cur] = a[j]
cur += a[j + 1]
data[i][cur] = 0
ans = 0
for i in range(n):
for j in range(i + 1, n):
state1 = 0
dist_i, dist_j = 0, 0
speed_i, speed_j = 0, 0
time = sorted(set(data[i].keys()) | set(data[j].keys()))
for t1, t2 in zip(time, time[1:]):
if t1 in data[i]:
speed_i = data[i][t1]
if t1 in data[j]:
speed_j = data[j][t1]
dist_i += (t2 - t1) * speed_i
dist_j += (t2 - t1) * speed_j
state2 = 0 if dist_i == dist_j else 1 if dist_i > dist_j else 2
if state2 != 0:
if state1 | state2 == 3:
ans += 1
state1 = state2
if dist_i == s or dist_j == s:
break
print(ans)
|
{
"input": [
"5 33\n2 1 3 3 10\n1 11 3\n2 5 3 3 6\n2 3 1 10 3\n2 6 3 3 5\n",
"2 33\n2 5 1 2 14\n1 3 11\n",
"2 33\n2 1 3 10 3\n1 11 3\n"
],
"output": [
" 2\n",
" 1\n",
" 0\n"
]
}
|
3,994 | 8 |
Appleman has n cards. Each card has an uppercase letter written on it. Toastman must choose k cards from Appleman's cards. Then Appleman should give Toastman some coins depending on the chosen cards. Formally, for each Toastman's card i you should calculate how much Toastman's cards have the letter equal to letter on ith, then sum up all these quantities, such a number of coins Appleman should give to Toastman.
Given the description of Appleman's cards. What is the maximum number of coins Toastman can get?
Input
The first line contains two integers n and k (1 β€ k β€ n β€ 105). The next line contains n uppercase letters without spaces β the i-th letter describes the i-th card of the Appleman.
Output
Print a single integer β the answer to the problem.
Examples
Input
15 10
DZFDFZDFDDDDDDF
Output
82
Input
6 4
YJSNPI
Output
4
Note
In the first test example Toastman can choose nine cards with letter D and one additional card with any letter. For each card with D he will get 9 coins and for the additional card he will get 1 coin.
|
from collections import Counter
def f(arr,k):
x=Counter(arr)
ans=0
for i,j in sorted(x.items(),key=lambda s:s[1],reverse=True):
if j<=k:
k-=j
ans+=j**2
else:
ans+=k**2
k=0
break
return ans
a,b=map(int,input().strip().split())
lst=input()
print(f(lst,b))
|
{
"input": [
"6 4\nYJSNPI\n",
"15 10\nDZFDFZDFDDDDDDF\n"
],
"output": [
"4\n",
"82\n"
]
}
|
3,995 | 7 |
For a positive integer n let's define a function f:
f(n) = - 1 + 2 - 3 + .. + ( - 1)nn
Your task is to calculate f(n) for a given integer n.
Input
The single line contains the positive integer n (1 β€ n β€ 1015).
Output
Print f(n) in a single line.
Examples
Input
4
Output
2
Input
5
Output
-3
Note
f(4) = - 1 + 2 - 3 + 4 = 2
f(5) = - 1 + 2 - 3 + 4 - 5 = - 3
|
def F(n):
return (n//2) - (n%2)*n
n = int(input())
print(F(n))
|
{
"input": [
"4\n",
"5\n"
],
"output": [
"2\n",
"-3\n"
]
}
|
3,996 | 8 |
The on-board computer on Polycarp's car measured that the car speed at the beginning of some section of the path equals v1 meters per second, and in the end it is v2 meters per second. We know that this section of the route took exactly t seconds to pass.
Assuming that at each of the seconds the speed is constant, and between seconds the speed can change at most by d meters per second in absolute value (i.e., the difference in the speed of any two adjacent seconds does not exceed d in absolute value), find the maximum possible length of the path section in meters.
Input
The first line contains two integers v1 and v2 (1 β€ v1, v2 β€ 100) β the speeds in meters per second at the beginning of the segment and at the end of the segment, respectively.
The second line contains two integers t (2 β€ t β€ 100) β the time when the car moves along the segment in seconds, d (0 β€ d β€ 10) β the maximum value of the speed change between adjacent seconds.
It is guaranteed that there is a way to complete the segment so that:
* the speed in the first second equals v1,
* the speed in the last second equals v2,
* the absolute value of difference of speeds between any two adjacent seconds doesn't exceed d.
Output
Print the maximum possible length of the path segment in meters.
Examples
Input
5 6
4 2
Output
26
Input
10 10
10 0
Output
100
Note
In the first sample the sequence of speeds of Polycarpus' car can look as follows: 5, 7, 8, 6. Thus, the total path is 5 + 7 + 8 + 6 = 26 meters.
In the second sample, as d = 0, the car covers the whole segment at constant speed v = 10. In t = 10 seconds it covers the distance of 100 meters.
|
def main():
v1, v2 = (int(i) for i in input().split())
t, d = (int(i) for i in input().split())
res = 0
for i in range(t):
res += min(v1 + d*i, v2 + d*(t - i - 1))
print(res)
if __name__ == '__main__':
main()
|
{
"input": [
"10 10\n10 0\n",
"5 6\n4 2\n"
],
"output": [
"100\n",
"26\n"
]
}
|
3,997 | 8 |
Today on a lecture about strings Gerald learned a new definition of string equivalency. Two strings a and b of equal length are called equivalent in one of the two cases:
1. They are equal.
2. If we split string a into two halves of the same size a1 and a2, and string b into two halves of the same size b1 and b2, then one of the following is correct:
1. a1 is equivalent to b1, and a2 is equivalent to b2
2. a1 is equivalent to b2, and a2 is equivalent to b1
As a home task, the teacher gave two strings to his students and asked to determine if they are equivalent.
Gerald has already completed this home task. Now it's your turn!
Input
The first two lines of the input contain two strings given by the teacher. Each of them has the length from 1 to 200 000 and consists of lowercase English letters. The strings have the same length.
Output
Print "YES" (without the quotes), if these two strings are equivalent, and "NO" (without the quotes) otherwise.
Examples
Input
aaba
abaa
Output
YES
Input
aabb
abab
Output
NO
Note
In the first sample you should split the first string into strings "aa" and "ba", the second one β into strings "ab" and "aa". "aa" is equivalent to "aa"; "ab" is equivalent to "ba" as "ab" = "a" + "b", "ba" = "b" + "a".
In the second sample the first string can be splitted into strings "aa" and "bb", that are equivalent only to themselves. That's why string "aabb" is equivalent only to itself and to string "bbaa".
|
def g(s):l=len(s);return sorted([g(s[:l//2]),g(s[l//2:])])if l%2==0 else s
print('YES'if g(input())==g(input())else'NO')
|
{
"input": [
"aabb\nabab\n",
"aaba\nabaa\n"
],
"output": [
"NO\n",
"YES\n"
]
}
|
3,998 | 11 |
Mikhail the Freelancer dreams of two things: to become a cool programmer and to buy a flat in Moscow. To become a cool programmer, he needs at least p experience points, and a desired flat in Moscow costs q dollars. Mikhail is determined to follow his dreams and registered at a freelance site.
He has suggestions to work on n distinct projects. Mikhail has already evaluated that the participation in the i-th project will increase his experience by ai per day and bring bi dollars per day. As freelance work implies flexible working hours, Mikhail is free to stop working on one project at any time and start working on another project. Doing so, he receives the respective share of experience and money. Mikhail is only trying to become a cool programmer, so he is able to work only on one project at any moment of time.
Find the real value, equal to the minimum number of days Mikhail needs to make his dream come true.
For example, suppose Mikhail is suggested to work on three projects and a1 = 6, b1 = 2, a2 = 1, b2 = 3, a3 = 2, b3 = 6. Also, p = 20 and q = 20. In order to achieve his aims Mikhail has to work for 2.5 days on both first and third projects. Indeed, a1Β·2.5 + a2Β·0 + a3Β·2.5 = 6Β·2.5 + 1Β·0 + 2Β·2.5 = 20 and b1Β·2.5 + b2Β·0 + b3Β·2.5 = 2Β·2.5 + 3Β·0 + 6Β·2.5 = 20.
Input
The first line of the input contains three integers n, p and q (1 β€ n β€ 100 000, 1 β€ p, q β€ 1 000 000) β the number of projects and the required number of experience and money.
Each of the next n lines contains two integers ai and bi (1 β€ ai, bi β€ 1 000 000) β the daily increase in experience and daily income for working on the i-th project.
Output
Print a real value β the minimum number of days Mikhail needs to get the required amount of experience and money. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 20 20
6 2
1 3
2 6
Output
5.000000000000000
Input
4 1 1
2 3
3 2
2 3
3 2
Output
0.400000000000000
Note
First sample corresponds to the example in the problem statement.
|
from fractions import Fraction
def higher(x1, y1, x2, y2):
if x1 == 0:
if x2 == 0:
return
def min_days(p, q, pr):
ma = max(a for a, b in pr)
mb = max(b for a, b in pr)
pr.sort(key=lambda t: (t[0], -t[1]))
ch = [(0, mb)]
for a, b in pr:
if a == ch[-1][0]:
continue
while (
len(ch) >= 2
and ((b-ch[-2][1])*(ch[-1][0]-ch[-2][0])
>= (a-ch[-2][0])*(ch[-1][1]-ch[-2][1]))
):
ch.pop()
ch.append((a, b))
ch.append((ma, 0))
a1, b1 = None, None
for a2, b2 in ch:
if a1 is not None:
d = (a2-a1)*q + (b1-b2)*p
s = Fraction(b1*p-a1*q, d)
if 0 <= s <= 1:
return Fraction(d, a2*b1 - a1*b2)
a1, b1 = a2, b2
if __name__ == '__main__':
n, p, q = map(int, input().split())
pr = []
for _ in range(n):
a, b = map(int, input().split())
pr.append((a, b))
print("{:.7f}".format(float(min_days(p, q, pr))))
|
{
"input": [
"4 1 1\n2 3\n3 2\n2 3\n3 2\n",
"3 20 20\n6 2\n1 3\n2 6\n"
],
"output": [
"0.39999999999999980016\n",
"4.99999999999999200639\n"
]
}
|
3,999 | 10 |
Consider a linear function f(x) = Ax + B. Let's define g(0)(x) = x and g(n)(x) = f(g(n - 1)(x)) for n > 0. For the given integer values A, B, n and x find the value of g(n)(x) modulo 109 + 7.
Input
The only line contains four integers A, B, n and x (1 β€ A, B, x β€ 109, 1 β€ n β€ 1018) β the parameters from the problem statement.
Note that the given value n can be too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Output
Print the only integer s β the value g(n)(x) modulo 109 + 7.
Examples
Input
3 4 1 1
Output
7
Input
3 4 2 1
Output
25
Input
3 4 3 1
Output
79
|
def mod(a, m) :
return pow(a, m - 2, m)
a,b,n,x=list(map(int,input().split()))
m=10**9+7
if a==1:
print((x+b*n)%m)
else:
print(int((pow(a,n,m)*x+(b*(pow(a,n,m)-1)*mod(a-1,m)))%m))
|
{
"input": [
"3 4 1 1\n",
"3 4 2 1\n",
"3 4 3 1\n"
],
"output": [
"7\n",
"25\n",
"79\n"
]
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.