name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
429_C. Guess the Tree | Iahub and Iahubina went to a picnic in a forest full of trees. Less than 5 minutes passed before Iahub remembered of trees from programming. Moreover, he invented a new problem and Iahubina has to solve it, otherwise Iahub won't give her the food.
Iahub asks Iahubina: can you build a rooted tree, such that
* each internal node (a node with at least one son) has at least two sons;
* node i has ci nodes in its subtree?
Iahubina has to guess the tree. Being a smart girl, she realized that it's possible no tree can follow Iahub's restrictions. In this way, Iahub will eat all the food. You need to help Iahubina: determine if there's at least one tree following Iahub's restrictions. The required tree must contain n nodes.
Input
The first line of the input contains integer n (1 ≤ n ≤ 24). Next line contains n positive integers: the i-th number represents ci (1 ≤ ci ≤ n).
Output
Output on the first line "YES" (without quotes) if there exist at least one tree following Iahub's restrictions, otherwise output "NO" (without quotes).
Examples
Input
4
1 1 1 4
Output
YES
Input
5
1 1 5 2 1
Output
NO | ```python
def DFS(x):
for i in range(x):
if(Seen[i][x]):
continue
if(Rem[i]>=C[x]):
if(Rem[i]==C[x] and len(Children[i])==0):
continue
Rem[i]-=C[x]
Parent[x]=i
Children[i].append(x)
return True
for i in range(x):
if(Seen[i][x]):
continue
Y=[]
for j in range(len(Children[i])):
child=Children[i][j]
Parent[child]=-1
Rem[i]+=C[child]
Seen[i][child]=True
Seen[child][i]=True
if(DFS(child)):
Seen[i][child]=False
Seen[child][i]=False
continue
Seen[i][child]=False
Seen[child][i]=False
Parent[child]=i
Rem[i]-=C[child]
Y.append(child)
Children[i]=list(Y)
if(Rem[i]>=C[x]):
if(Rem[i]==C[x] and len(Children[i])==0):
continue
Rem[i]-=C[x]
Children[i].append(x)
Parent[x]=i
return True
return False
n=int(input())
C=list(map(int,input().split()))
Rem=[-1]*n
Parent=[-1]*n
Children=[]
Seen=[]
for i in range(n):
Seen.append([False]*n)
C.sort(reverse=True)
if(C[0]!=n or C.count(2)>0):
print("NO")
else:
for i in range(n):
Rem[i]=C[i]-1
Children.append([])
Parent[0]=0
Ans="YES"
for i in range(1,n):
if(DFS(i)==False):
Ans="NO"
break
for i in range(n):
if(Rem[i]!=0 and C[i]!=1):
Ans="NO"
break
print(Ans)
``` |
451_A. Game With Sticks | After winning gold and silver in IOI 2014, Akshat and Malvika want to have some fun. Now they are playing a game on a grid made of n horizontal and m vertical sticks.
An intersection point is any point on the grid which is formed by the intersection of one horizontal stick and one vertical stick.
In the grid shown below, n = 3 and m = 3. There are n + m = 6 sticks in total (horizontal sticks are shown in red and vertical sticks are shown in green). There are n·m = 9 intersection points, numbered from 1 to 9.
<image>
The rules of the game are very simple. The players move in turns. Akshat won gold, so he makes the first move. During his/her move, a player must choose any remaining intersection point and remove from the grid all sticks which pass through this point. A player will lose the game if he/she cannot make a move (i.e. there are no intersection points remaining on the grid at his/her move).
Assume that both players play optimally. Who will win the game?
Input
The first line of input contains two space-separated integers, n and m (1 ≤ n, m ≤ 100).
Output
Print a single line containing "Akshat" or "Malvika" (without the quotes), depending on the winner of the game.
Examples
Input
2 2
Output
Malvika
Input
2 3
Output
Malvika
Input
3 3
Output
Akshat
Note
Explanation of the first sample:
The grid has four intersection points, numbered from 1 to 4.
<image>
If Akshat chooses intersection point 1, then he will remove two sticks (1 - 2 and 1 - 3). The resulting grid will look like this.
<image>
Now there is only one remaining intersection point (i.e. 4). Malvika must choose it and remove both remaining sticks. After her move the grid will be empty.
In the empty grid, Akshat cannot make any move, hence he will lose.
Since all 4 intersection points of the grid are equivalent, Akshat will lose no matter which one he picks. | ```python
n,m = map(int, input().strip().split())
print("Akshat" if min(n,m)%2!=0 else "Malvika")
``` |
520_E. Pluses everywhere | Vasya is sitting on an extremely boring math class. To have fun, he took a piece of paper and wrote out n numbers on a single line. After that, Vasya began to write out different ways to put pluses ("+") in the line between certain digits in the line so that the result was a correct arithmetic expression; formally, no two pluses in such a partition can stand together (between any two adjacent pluses there must be at least one digit), and no plus can stand at the beginning or the end of a line. For example, in the string 100500, ways 100500 (add no pluses), 1+00+500 or 10050+0 are correct, and ways 100++500, +1+0+0+5+0+0 or 100500+ are incorrect.
The lesson was long, and Vasya has written all the correct ways to place exactly k pluses in a string of digits. At this point, he got caught having fun by a teacher and he was given the task to calculate the sum of all the resulting arithmetic expressions by the end of the lesson (when calculating the value of an expression the leading zeros should be ignored). As the answer can be large, Vasya is allowed to get only its remainder modulo 109 + 7. Help him!
Input
The first line contains two integers, n and k (0 ≤ k < n ≤ 105).
The second line contains a string consisting of n digits.
Output
Print the answer to the problem modulo 109 + 7.
Examples
Input
3 1
108
Output
27
Input
3 2
108
Output
9
Note
In the first sample the result equals (1 + 08) + (10 + 8) = 27.
In the second sample the result equals 1 + 0 + 8 = 9. | ```python
n, k = map(int, input().split())
t = list(map(int, input()))
p, d = 1, 10**9 + 7
s = 0
f = [1] * n
for i in range(2, n):
f[i] = (i * f[i - 1]) % d
c = lambda a, b: 0 if a > b else (f[b] * pow(f[a] * f[b -a], d - 2, d)) % d
if k:
u = [0] * (n + 1)
p = [1] * (n + 1)
for i in range(n):
u[i] = (p[i] * c(k - 1, n - 2 - i) + u[i - 1]) % d
p[i + 1] = (10 * p[i]) % d
for i in range(n):
v = u[n - 2 - i] + p[n - 1 - i] * c(k,i)
s = (s + t[i] * v) % d
else:
for i in t:
s = (s * 10 + i) % d
print(s)
#GG
``` |
548_B. Mike and Fun | Mike and some bears are playing a game just for fun. Mike is the judge. All bears except Mike are standing in an n × m grid, there's exactly one bear in each cell. We denote the bear standing in column number j of row number i by (i, j). Mike's hands are on his ears (since he's the judge) and each bear standing in the grid has hands either on his mouth or his eyes.
<image>
They play for q rounds. In each round, Mike chooses a bear (i, j) and tells him to change his state i. e. if his hands are on his mouth, then he'll put his hands on his eyes or he'll put his hands on his mouth otherwise. After that, Mike wants to know the score of the bears.
Score of the bears is the maximum over all rows of number of consecutive bears with hands on their eyes in that row.
Since bears are lazy, Mike asked you for help. For each round, tell him the score of these bears after changing the state of a bear selected in that round.
Input
The first line of input contains three integers n, m and q (1 ≤ n, m ≤ 500 and 1 ≤ q ≤ 5000).
The next n lines contain the grid description. There are m integers separated by spaces in each line. Each of these numbers is either 0 (for mouth) or 1 (for eyes).
The next q lines contain the information about the rounds. Each of them contains two integers i and j (1 ≤ i ≤ n and 1 ≤ j ≤ m), the row number and the column number of the bear changing his state.
Output
After each round, print the current score of the bears.
Examples
Input
5 4 5
0 1 1 0
1 0 0 1
0 1 1 0
1 0 0 1
0 0 0 0
1 1
1 4
1 1
4 2
4 3
Output
3
4
3
3
4 | ```python
def score(R) :
val = 0
ret = 0
for i in R :
if i :
val += 1
ret = max(ret, val)
else :
val = 0
return ret
n, m, q = map(int, input().split())
A = [list(map(int, input().split())) for i in range(n)]
B = [score(A[i]) for i in range(n)]
for _ in range(q) :
x, y = map(int, input().split())
x, y = x-1, y-1
A[x][y] = not A[x][y]
B[x] = score(A[x])
print(max(B))
``` |
574_D. Bear and Blocks | Limak is a little bear who loves to play. Today he is playing by destroying block towers. He built n towers in a row. The i-th tower is made of hi identical blocks. For clarification see picture for the first sample.
Limak will repeat the following operation till everything is destroyed.
Block is called internal if it has all four neighbors, i.e. it has each side (top, left, down and right) adjacent to other block or to the floor. Otherwise, block is boundary. In one operation Limak destroys all boundary blocks. His paws are very fast and he destroys all those blocks at the same time.
Limak is ready to start. You task is to count how many operations will it take him to destroy all towers.
Input
The first line contains single integer n (1 ≤ n ≤ 105).
The second line contains n space-separated integers h1, h2, ..., hn (1 ≤ hi ≤ 109) — sizes of towers.
Output
Print the number of operations needed to destroy all towers.
Examples
Input
6
2 1 4 6 2 2
Output
3
Input
7
3 3 3 1 3 3 3
Output
2
Note
The picture below shows all three operations for the first sample test. Each time boundary blocks are marked with red color.
<image> After first operation there are four blocks left and only one remains after second operation. This last block is destroyed in third operation. | ```python
x=int(input())
mas = list(map(int,input().split(" ")))
mas2=[0]*(x)
mas2[0]=1
for i in range(1,x):
mas2[i]=min(mas[i],mas2[i-1]+1)
mas2[-1]=1
for i in range(2,x+1):
mas2[-i]=min(mas[-i],mas2[-i+1]+1, mas2[-i])
print(max(mas2))
``` |
596_B. Wilbur and Array | Wilbur the pig is tinkering with arrays again. He has the array a1, a2, ..., an initially consisting of n zeros. At one step, he can choose any index i and either add 1 to all elements ai, ai + 1, ... , an or subtract 1 from all elements ai, ai + 1, ..., an. His goal is to end up with the array b1, b2, ..., bn.
Of course, Wilbur wants to achieve this goal in the minimum number of steps and asks you to compute this value.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array ai. Initially ai = 0 for every position i, so this array is not given in the input.
The second line of the input contains n integers b1, b2, ..., bn ( - 109 ≤ bi ≤ 109).
Output
Print the minimum number of steps that Wilbur needs to make in order to achieve ai = bi for all i.
Examples
Input
5
1 2 3 4 5
Output
5
Input
4
1 2 2 1
Output
3
Note
In the first sample, Wilbur may successively choose indices 1, 2, 3, 4, and 5, and add 1 to corresponding suffixes.
In the second sample, Wilbur first chooses indices 1 and 2 and adds 1 to corresponding suffixes, then he chooses index 4 and subtract 1. | ```python
# print("Input n")
n = int(input())
# print("Input the integers")
a = [int(x) for x in input().split()]
answer = abs(a[0])
for i in range(1, n):
answer += abs(a[i-1] - a[i])
print(answer)
``` |
617_D. Polyline | There are three points marked on the coordinate plane. The goal is to make a simple polyline, without self-intersections and self-touches, such that it passes through all these points. Also, the polyline must consist of only segments parallel to the coordinate axes. You are to find the minimum number of segments this polyline may consist of.
Input
Each of the three lines of the input contains two integers. The i-th line contains integers xi and yi ( - 109 ≤ xi, yi ≤ 109) — the coordinates of the i-th point. It is guaranteed that all points are distinct.
Output
Print a single number — the minimum possible number of segments of the polyline.
Examples
Input
1 -1
1 1
1 2
Output
1
Input
-1 -1
-1 3
4 3
Output
2
Input
1 1
2 3
3 2
Output
3
Note
The variant of the polyline in the first sample: <image> The variant of the polyline in the second sample: <image> The variant of the polyline in the third sample: <image> | ```python
"""n=int(input())
x=list(map(int, input().split()))
c=0
pro=1
for i in range(n):
if x[i]==1:
c+=1
if c==1:
old=i
elif c>1:
new=i
pro*=(new-old)
old=new
print(pro)
"""
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
x,y,z=1,1,0
if a[0]==b[0] or a[0]==c[0] or b[0]==c[0]:
x=2
if a[0]==b[0] and a[0]==c[0] and b[0]==c[0]:
x=3
else:
if a[0]==b[0]:
if c[1] in range(min(a[1],b[1]),max(a[1],b[1])):
z+=1
elif a[0]==c[0]:
if b[1] in range(min(a[1],c[1]),max(a[1],c[1])):
z+=1
elif b[0]==c[0]:
if a[1] in range(min(b[1],c[1]),max(b[1],c[1])):
z+=1
if a[1]==b[1] or a[1]==c[1] or b[1]==c[1]:
y=2
if a[1]==b[1] and a[1]==c[1] and b[1]==c[1]:
y=3
else:
if a[1]==b[1]:
if c[0] in range(min(a[0],b[0]),max(a[0],b[0])):
z+=1
elif a[1]==c[1]:
if b[0] in range(min(a[0],c[0]),max(a[0],c[0])):
z+=1
elif b[1]==c[1]:
if a[0] in range(min(b[0],c[0]),max(b[0],c[0])):
z+=1
if x*y==1:
print(3)
elif x*y==3:
print(1)
elif x*y==4:
print(2)
else:
if z==1:
print(3)
else:
print(2)
``` |
638_A. Home Numbers | The main street of Berland is a straight line with n houses built along it (n is an even number). The houses are located at both sides of the street. The houses with odd numbers are at one side of the street and are numbered from 1 to n - 1 in the order from the beginning of the street to the end (in the picture: from left to right). The houses with even numbers are at the other side of the street and are numbered from 2 to n in the order from the end of the street to its beginning (in the picture: from right to left). The corresponding houses with even and odd numbers are strictly opposite each other, that is, house 1 is opposite house n, house 3 is opposite house n - 2, house 5 is opposite house n - 4 and so on.
<image>
Vasya needs to get to house number a as quickly as possible. He starts driving from the beginning of the street and drives his car to house a. To get from the beginning of the street to houses number 1 and n, he spends exactly 1 second. He also spends exactly one second to drive the distance between two neighbouring houses. Vasya can park at any side of the road, so the distance between the beginning of the street at the houses that stand opposite one another should be considered the same.
Your task is: find the minimum time Vasya needs to reach house a.
Input
The first line of the input contains two integers, n and a (1 ≤ a ≤ n ≤ 100 000) — the number of houses on the street and the number of the house that Vasya needs to reach, correspondingly. It is guaranteed that number n is even.
Output
Print a single integer — the minimum time Vasya needs to get from the beginning of the street to house a.
Examples
Input
4 2
Output
2
Input
8 5
Output
3
Note
In the first sample there are only four houses on the street, two houses at each side. House 2 will be the last at Vasya's right.
The second sample corresponds to picture with n = 8. House 5 is the one before last at Vasya's left. | ```python
[n, x] = list(map(int, input().split(' ')))
answer = int (x % 2 == 0 and (n / 2 - x / 2 + 1) or( (x + 1) / 2))
print(answer)
``` |
712_A. Memory and Crow | There are n integers b1, b2, ..., bn written in a row. For all i from 1 to n, values ai are defined by the crows performing the following procedure:
* The crow sets ai initially 0.
* The crow then adds bi to ai, subtracts bi + 1, adds the bi + 2 number, and so on until the n'th number. Thus, ai = bi - bi + 1 + bi + 2 - bi + 3....
Memory gives you the values a1, a2, ..., an, and he now wants you to find the initial numbers b1, b2, ..., bn written in the row? Can you do it?
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100 000) — the number of integers written in the row.
The next line contains n, the i'th of which is ai ( - 109 ≤ ai ≤ 109) — the value of the i'th number.
Output
Print n integers corresponding to the sequence b1, b2, ..., bn. It's guaranteed that the answer is unique and fits in 32-bit integer type.
Examples
Input
5
6 -4 8 -2 3
Output
2 4 6 1 3
Input
5
3 -2 -1 5 6
Output
1 -3 4 11 6
Note
In the first sample test, the crows report the numbers 6, - 4, 8, - 2, and 3 when he starts at indices 1, 2, 3, 4 and 5 respectively. It is easy to check that the sequence 2 4 6 1 3 satisfies the reports. For example, 6 = 2 - 4 + 6 - 1 + 3, and - 4 = 4 - 6 + 1 - 3.
In the second sample test, the sequence 1, - 3, 4, 11, 6 satisfies the reports. For example, 5 = 11 - 6 and 6 = 6. | ```python
n=int(input())
a=input().split()
for i in range (n):
a[i]=int(a[i])
a.reverse()
b=[]
b.append(a[0])
for i in range (n-1):
b.append(a[i]+a[i+1])
b.reverse()
print (" ".join(map(str, b)))
``` |
757_A. Gotta Catch Em' All! | Bash wants to become a Pokemon master one day. Although he liked a lot of Pokemon, he has always been fascinated by Bulbasaur the most. Soon, things started getting serious and his fascination turned into an obsession. Since he is too young to go out and catch Bulbasaur, he came up with his own way of catching a Bulbasaur.
Each day, he takes the front page of the newspaper. He cuts out the letters one at a time, from anywhere on the front page of the newspaper to form the word "Bulbasaur" (without quotes) and sticks it on his wall. Bash is very particular about case — the first letter of "Bulbasaur" must be upper case and the rest must be lower case. By doing this he thinks he has caught one Bulbasaur. He then repeats this step on the left over part of the newspaper. He keeps doing this until it is not possible to form the word "Bulbasaur" from the newspaper.
Given the text on the front page of the newspaper, can you tell how many Bulbasaurs he will catch today?
Note: uppercase and lowercase letters are considered different.
Input
Input contains a single line containing a string s (1 ≤ |s| ≤ 105) — the text on the front page of the newspaper without spaces and punctuation marks. |s| is the length of the string s.
The string s contains lowercase and uppercase English letters, i.e. <image>.
Output
Output a single integer, the answer to the problem.
Examples
Input
Bulbbasaur
Output
1
Input
F
Output
0
Input
aBddulbasaurrgndgbualdBdsagaurrgndbb
Output
2
Note
In the first case, you could pick: Bulbbasaur.
In the second case, there is no way to pick even a single Bulbasaur.
In the third case, you can rearrange the string to BulbasaurBulbasauraddrgndgddgargndbb to get two words "Bulbasaur". | ```python
from collections import Counter
k = Counter("Bulbasaur")
r = Counter(input())
print(min([r[c] // k[c] for c in k]))
``` |
802_F. Marmots (hard) | Your task is the exact same as for the easy version. But this time, the marmots subtract the village's population P from their random number before responding to Heidi's request.
Also, there are now villages with as few as a single inhabitant, meaning that <image>.
Can you help Heidi find out whether a village follows a Poisson or a uniform distribution?
Input
Same as for the easy and medium versions. But remember that now 1 ≤ P ≤ 1000 and that the marmots may provide positive as well as negative integers.
Output
Output one line per village, in the same order as provided in the input. The village's line shall state poisson if the village's distribution is of the Poisson type, and uniform if the answers came from a uniform distribution. | ```python
for i in range(int(input())):
a=list(map(int,input().split()))
mx=max(list(map(abs,a)))
std=(sum(list(map(lambda x:x*x,a)))/len(a))**0.5
print('poisson'if mx/std>2 else'uniform')
``` |
825_B. Five-In-a-Row | Alice and Bob play 5-in-a-row game. They have a playing field of size 10 × 10. In turns they put either crosses or noughts, one at a time. Alice puts crosses and Bob puts noughts.
In current match they have made some turns and now it's Alice's turn. She wonders if she can put cross in such empty cell that she wins immediately.
Alice wins if some crosses in the field form line of length not smaller than 5. This line can be horizontal, vertical and diagonal.
Input
You are given matrix 10 × 10 (10 lines of 10 characters each) with capital Latin letters 'X' being a cross, letters 'O' being a nought and '.' being an empty cell. The number of 'X' cells is equal to the number of 'O' cells and there is at least one of each type. There is at least one empty cell.
It is guaranteed that in the current arrangement nobody has still won.
Output
Print 'YES' if it's possible for Alice to win in one turn by putting cross in some empty cell. Otherwise print 'NO'.
Examples
Input
XX.XX.....
.....OOOO.
..........
..........
..........
..........
..........
..........
..........
..........
Output
YES
Input
XXOXX.....
OO.O......
..........
..........
..........
..........
..........
..........
..........
..........
Output
NO | ```python
mat=[]
n=10
m=10
for i in range(n):
s=input()
s=list(s)
mat.append(s)
f=0
def check(mat):
for i in range(10):
for j in range(10):
#horizontal
for k in range(5):
if (i+k)>=10 or mat[i+k][j]!='X':
break
else:
return 1
#vertical
for k in range(5):
if (j+k)>=10 or mat[i][j+k]!='X':
break
else :
return 1
#diag
for k in range(5):
if (i+k)>=10 or (j+k)>=10 or mat[i+k][j+k]!='X':
break
else :
return 1
for k in range(5):
if (i+k)>=10 or (j-k)<0 or mat[i+k][j-k]!='X':
break
else :
return 1
return 0
for i in range(n):
for j in range(m):
if mat[i][j]=='.':
mat[i][j]='X'
if check(mat):
f=1
print('YES')
exit()
else:
mat[i][j]='.'
print('NO')
``` |
847_M. Weather Tomorrow | Vasya came up with his own weather forecasting method. He knows the information about the average air temperature for each of the last n days. Assume that the average air temperature for each day is integral.
Vasya believes that if the average temperatures over the last n days form an arithmetic progression, where the first term equals to the average temperature on the first day, the second term equals to the average temperature on the second day and so on, then the average temperature of the next (n + 1)-th day will be equal to the next term of the arithmetic progression. Otherwise, according to Vasya's method, the temperature of the (n + 1)-th day will be equal to the temperature of the n-th day.
Your task is to help Vasya predict the average temperature for tomorrow, i. e. for the (n + 1)-th day.
Input
The first line contains a single integer n (2 ≤ n ≤ 100) — the number of days for which the average air temperature is known.
The second line contains a sequence of integers t1, t2, ..., tn ( - 1000 ≤ ti ≤ 1000) — where ti is the average temperature in the i-th day.
Output
Print the average air temperature in the (n + 1)-th day, which Vasya predicts according to his method. Note that the absolute value of the predicted temperature can exceed 1000.
Examples
Input
5
10 5 0 -5 -10
Output
-15
Input
4
1 1 1 1
Output
1
Input
3
5 1 -5
Output
-5
Input
2
900 1000
Output
1100
Note
In the first example the sequence of the average temperatures is an arithmetic progression where the first term is 10 and each following terms decreases by 5. So the predicted average temperature for the sixth day is - 10 - 5 = - 15.
In the second example the sequence of the average temperatures is an arithmetic progression where the first term is 1 and each following terms equals to the previous one. So the predicted average temperature in the fifth day is 1.
In the third example the average temperatures do not form an arithmetic progression, so the average temperature of the fourth day equals to the temperature of the third day and equals to - 5.
In the fourth example the sequence of the average temperatures is an arithmetic progression where the first term is 900 and each the following terms increase by 100. So predicted average temperature in the third day is 1000 + 100 = 1100. | ```python
n=int(input())
l=list(map(int,input().split()))
f=0
for i in range (2,len(l)):
if l[i]==l[i-1]+(l[1]-l[0]):
pass
else:
f=1
print(l[n-1])
break
if f==0:
if (l[n-1])==(l[0]+(n-1)*(l[1]-l[0])):
print(l[0]+(n*(l[1]-l[0])))
else:
print(l[n-1])
``` |
896_B. Ithea Plays With Chtholly | This is an interactive problem. Refer to the Interaction section below for better understanding.
Ithea and Chtholly want to play a game in order to determine who can use the kitchen tonight.
<image>
Initially, Ithea puts n clear sheets of paper in a line. They are numbered from 1 to n from left to right.
This game will go on for m rounds. In each round, Ithea will give Chtholly an integer between 1 and c, and Chtholly needs to choose one of the sheets to write down this number (if there is already a number before, she will erase the original one and replace it with the new one).
Chtholly wins if, at any time, all the sheets are filled with a number and the n numbers are in non-decreasing order looking from left to right from sheet 1 to sheet n, and if after m rounds she still doesn't win, she loses the game.
Chtholly really wants to win the game as she wants to cook something for Willem. But she doesn't know how to win the game. So Chtholly finds you, and your task is to write a program to receive numbers that Ithea gives Chtholly and help her make the decision on which sheet of paper write this number.
Input
The first line contains 3 integers n, m and c (<image>, <image> means <image> rounded up) — the number of sheets, the number of rounds and the largest possible number Ithea can give to Chtholly respectively. The remaining parts of input are given throughout the interaction process.
Interaction
In each round, your program needs to read one line containing a single integer pi (1 ≤ pi ≤ c), indicating the number given to Chtholly.
Your program should then output a line containing an integer between 1 and n, indicating the number of sheet to write down this number in.
After outputting each line, don't forget to flush the output. For example:
* fflush(stdout) in C/C++;
* System.out.flush() in Java;
* sys.stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
If Chtholly wins at the end of a round, no more input will become available and your program should terminate normally. It can be shown that under the constraints, it's always possible for Chtholly to win the game.
Example
Input
2 4 4
2
1
3
Output
1
2
2
Note
In the example, Chtholly initially knew there were 2 sheets, 4 rounds and each number was between 1 and 4. She then received a 2 and decided to write it in the 1st sheet. Then she received a 1 and wrote it in the 2nd sheet. At last, she received a 3 and replaced 1 with 3 in the 2nd sheet. At this time all the sheets were filled with a number and they were non-decreasing, so she won the game.
Note that it is required that your program terminate immediately after Chtholly wins and do not read numbers from the input for the remaining rounds. If not, undefined behaviour may arise and it won't be sure whether your program will be accepted or rejected. Also because of this, please be careful when hacking others' codes. In the sample, Chtholly won the game after the 3rd round, so it is required that your program doesn't read the number of the remaining 4th round.
The input format for hacking:
* The first line contains 3 integers n, m and c;
* The following m lines each contains an integer between 1 and c, indicating the number given to Chtholly in each round. | ```python
import sys
n, m, c=map(int, input().split())
a=[]
for i in range(n+1):
a.append(0)
cnt=0
while cnt<n:
i=0
x=int(input())
if x*2<=c:
i=1
while a[i] and a[i]<=x:
i+=1
else:
i=n
while a[i] and a[i]>=x:
i-=1
if a[i]==0:
cnt+=1
a[i]=x
print(i)
sys.stdout.flush()
``` |
93_C. Azembler | After the Search Ultimate program that searched for strings in a text failed, Igor K. got to think: "Why on Earth does my program work so slowly?" As he double-checked his code, he said: "My code contains no errors, yet I know how we will improve Search Ultimate!" and took a large book from the shelves. The book read "Azembler. Principally New Approach".
Having carefully thumbed through the book, Igor K. realised that, as it turns out, you can multiply the numbers dozens of times faster. "Search Ultimate will be faster than it has ever been!" — the fellow shouted happily and set to work.
Let us now clarify what Igor's idea was. The thing is that the code that was generated by a compiler was far from perfect. Standard multiplying does work slower than with the trick the book mentioned.
The Azembler language operates with 26 registers (eax, ebx, ..., ezx) and two commands:
* [x] — returns the value located in the address x. For example, [eax] returns the value that was located in the address, equal to the value in the register eax.
* lea x, y — assigns to the register x, indicated as the first operand, the second operand's address. Thus, for example, the "lea ebx, [eax]" command will write in the ebx register the content of the eax register: first the [eax] operation will be fulfilled, the result of it will be some value that lies in the address written in eax. But we do not need the value — the next operation will be lea, that will take the [eax] address, i.e., the value in the eax register, and will write it in ebx.
On the first thought the second operation seems meaningless, but as it turns out, it is acceptable to write the operation as
lea ecx, [eax + ebx],
lea ecx, [k*eax]
or even
lea ecx, [ebx + k*eax],
where k = 1, 2, 4 or 8.
As a result, the register ecx will be equal to the numbers eax + ebx, k*eax and ebx + k*eax correspondingly. However, such operation is fulfilled many times, dozens of times faster that the usual multiplying of numbers. And using several such operations, one can very quickly multiply some number by some other one. Of course, instead of eax, ebx and ecx you are allowed to use any registers.
For example, let the eax register contain some number that we should multiply by 41. It takes us 2 lines:
lea ebx, [eax + 4*eax] // now ebx = 5*eax
lea eax, [eax + 8*ebx] // now eax = eax + 8*ebx = 41*eax
Igor K. got interested in the following question: what is the minimum number of lea operations needed to multiply by the given number n and how to do it? Your task is to help him.
Consider that at the initial moment of time eax contains a number that Igor K. was about to multiply by n, and the registers from ebx to ezx contain number 0. At the final moment of time the result can be located in any register.
Input
The input data contain the only integer n (1 ≤ n ≤ 255), which Igor K. is about to multiply.
Output
On the first line print number p, which represents the minimum number of lea operations, needed to do that. Then print the program consisting of p commands, performing the operations. It is guaranteed that such program exists for any n from 1 to 255.
Use precisely the following format of commands (here k is equal to 1, 2, 4 or 8, and x, y and z are any, even coinciding registers):
lea x, [y]
lea x, [y + z]
lea x, [k*y]
lea x, [y + k*z]
Please note that extra spaces at the end of a command are unacceptable.
Examples
Input
41
Output
2
lea ebx, [eax + 4*eax]
lea ecx, [eax + 8*ebx]
Input
2
Output
1
lea ebx, [eax + eax]
Input
4
Output
1
lea ebx, [4*eax] | ```python
n=int(input())
mn=[float('inf')]*256
ans=""
done=set()
def gen(vals,st):
global mn,ans
#print(*vals)
if('|'.join([str(x) for x in vals]) in done):
return
done.add('|'.join([str(x) for x in vals]))
if(vals[-1]==n):
if(len(vals)<mn[n]):
mn[n]=len(vals)
ans=st
return
if(len(vals)>5):
return
"""if(len(vals)-2>mn[vals[-1]]):
return
mn[vals[-1]]=len(vals)"""
for i in range(len(vals)):
for z in [8,4,2,1]:
e=vals[i]*z
if(e>n):
continue
if(e>vals[-1]):
nw='e'+chr(ord('a')+len(vals))+'x'
I='e'+chr(ord('a')+i)+'x'
gen(vals+[e],st+"lea "+nw+", ["+str(z)+"*"+I+"]\n")
for j in range(len(vals)):
for z in [8,4,2,1]:
e=vals[i]+z*vals[j]
if(e>n):
continue
if(e>vals[-1]):
nw='e'+chr(ord('a')+len(vals))+'x'
I='e'+chr(ord('a')+i)+'x'
J='e'+chr(ord('a')+j)+'x'
gen(vals+[e],st+"lea "+nw+", ["+I+" + "+str(z)+"*"+J+"]\n")
gen([1],"")
print(ans.count("\n"))
print(ans,end="")
``` |
967_A. Mind the Gap | These days Arkady works as an air traffic controller at a large airport. He controls a runway which is usually used for landings only. Thus, he has a schedule of planes that are landing in the nearest future, each landing lasts 1 minute.
He was asked to insert one takeoff in the schedule. The takeoff takes 1 minute itself, but for safety reasons there should be a time space between the takeoff and any landing of at least s minutes from both sides.
Find the earliest time when Arkady can insert the takeoff.
Input
The first line of input contains two integers n and s (1 ≤ n ≤ 100, 1 ≤ s ≤ 60) — the number of landings on the schedule and the minimum allowed time (in minutes) between a landing and a takeoff.
Each of next n lines contains two integers h and m (0 ≤ h ≤ 23, 0 ≤ m ≤ 59) — the time, in hours and minutes, when a plane will land, starting from current moment (i. e. the current time is 0 0). These times are given in increasing order.
Output
Print two integers h and m — the hour and the minute from the current moment of the earliest time Arkady can insert the takeoff.
Examples
Input
6 60
0 0
1 20
3 21
5 0
19 30
23 40
Output
6 1
Input
16 50
0 30
1 20
3 0
4 30
6 10
7 50
9 30
11 10
12 50
14 30
16 10
17 50
19 30
21 10
22 50
23 59
Output
24 50
Input
3 17
0 30
1 0
12 0
Output
0 0
Note
In the first example note that there is not enough time between 1:20 and 3:21, because each landing and the takeoff take one minute.
In the second example there is no gaps in the schedule, so Arkady can only add takeoff after all landings. Note that it is possible that one should wait more than 24 hours to insert the takeoff.
In the third example Arkady can insert the takeoff even between the first landing. | ```python
# -*- coding: utf-8 -*-
# @Date : 2019-01-30 20:41:28
# @Author : raj lath ([email protected])
# @Link : link
# @Version : 1.0.0
from sys import stdin
max_val=int(10e12)
min_val=int(-10e12)
def read_int() : return int(stdin.readline())
def read_ints() : return [int(x) for x in stdin.readline().split()]
def read_str() : return input()
def read_strs() : return [x for x in stdin.readline().split()]
nb_landings, interval = read_ints()
prev_landing = 0
for _ in range(nb_landings):
hour, minute = read_ints()
last_landing = hour * 60 + minute
if last_landing - prev_landing <= interval:
prev_landing = last_landing + interval + 1
else:break
print(prev_landing // 60, prev_landing % 60)
``` |
993_A. Two Squares | You are given two squares, one with sides parallel to the coordinate axes, and another one with sides at 45 degrees to the coordinate axes. Find whether the two squares intersect.
The interior of the square is considered to be part of the square, i.e. if one square is completely inside another, they intersect. If the two squares only share one common point, they are also considered to intersect.
Input
The input data consists of two lines, one for each square, both containing 4 pairs of integers. Each pair represents coordinates of one vertex of the square. Coordinates within each line are either in clockwise or counterclockwise order.
The first line contains the coordinates of the square with sides parallel to the coordinate axes, the second line contains the coordinates of the square at 45 degrees.
All the values are integer and between -100 and 100.
Output
Print "Yes" if squares intersect, otherwise print "No".
You can print each letter in any case (upper or lower).
Examples
Input
0 0 6 0 6 6 0 6
1 3 3 5 5 3 3 1
Output
YES
Input
0 0 6 0 6 6 0 6
7 3 9 5 11 3 9 1
Output
NO
Input
6 0 6 6 0 6 0 0
7 4 4 7 7 10 10 7
Output
YES
Note
In the first example the second square lies entirely within the first square, so they do intersect.
In the second sample squares do not have any points in common.
Here are images corresponding to the samples:
<image> <image> <image> | ```python
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a1 = min(a[0::2])
b1 = max(a[0::2])
c1 = min(a[1::2])
d1 = max(a[1::2])
g = sum(b[0::2])/4
h = sum(b[1::2])/4
r = abs(b[0]-g) + abs(b[1]-h)
for i in range(a1,b1+1) :
for j in range (c1,d1+1) :
if abs(i-g) + abs(j-h)<=r :
exit(print("YES"))
print("NO")
``` |
p02627 AtCoder Beginner Contest 171 - αlphabet | An uppercase or lowercase English letter \alpha will be given as input. If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
Constraints
* \alpha is an uppercase (`A` - `Z`) or lowercase (`a` - `z`) English letter.
Input
Input is given from Standard Input in the following format:
α
Output
If \alpha is uppercase, print `A`; if it is lowercase, print `a`.
Examples
Input
B
Output
A
Input
a
Output
a | ```python
c = input()
print('A' if ord(c)<96 else 'a')
``` |
p02758 AtCoder Beginner Contest 158 - Removing Robots | There are N robots numbered 1 to N placed on a number line. Robot i is placed at coordinate X_i. When activated, it will travel the distance of D_i in the positive direction, and then it will be removed from the number line. All the robots move at the same speed, and their sizes are ignorable.
Takahashi, who is a mischievous boy, can do the following operation any number of times (possibly zero) as long as there is a robot remaining on the number line.
* Choose a robot and activate it. This operation cannot be done when there is a robot moving.
While Robot i is moving, if it touches another robot j that is remaining in the range [X_i, X_i + D_i) on the number line, Robot j also gets activated and starts moving. This process is repeated recursively.
How many possible sets of robots remaining on the number line are there after Takahashi does the operation some number of times? Compute this count modulo 998244353, since it can be enormous.
Constraints
* 1 \leq N \leq 2 \times 10^5
* -10^9 \leq X_i \leq 10^9
* 1 \leq D_i \leq 10^9
* X_i \neq X_j (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X_1 D_1
:
X_N D_N
Output
Print the number of possible sets of robots remaining on the number line, modulo 998244353.
Examples
Input
2
1 5
3 3
Output
3
Input
3
6 5
-1 10
3 3
Output
5
Input
4
7 10
-10 3
4 3
-4 3
Output
16
Input
20
-8 1
26 4
0 5
9 1
19 4
22 20
28 27
11 8
-3 20
-25 17
10 4
-18 27
24 28
-11 19
2 27
-2 18
-1 12
-24 29
31 29
29 7
Output
110 | ```python
import sys
input = sys.stdin.readline
class SegmentTree(object):
def __init__(self, init_array, seg_func=min, seg_func_null=10 ** 9 + 7):
self.seg_func = seg_func
self.seg_func_null = seg_func_null
self.n = 1
while self.n < len(init_array):
self.n *= 2
self.dat = [0] * (2 * self.n - 1)
for i in range(len(init_array)):
self.dat[self.n - 1 + i] = init_array[i]
for i in range(self.n - 2, -1, -1):
self.dat[i] = self.seg_func(self.dat[2 * i + 1], self.dat[2 * i + 2])
def update(self, k, a):
k += self.n - 1
self.dat[k] = a
while k > 0:
k = (k - 1) // 2
self.dat[k] = self.seg_func(self.dat[k * 2 + 1], self.dat[k * 2 + 2])
def query(self, p, q):
# [p, q)
if q <= p:
return self.seg_func_null
p += self.n - 1
q += self.n - 2
res = self.seg_func_null
while q - p > 1:
if p & 1 == 0:
res = self.seg_func(res, self.dat[p])
if q & 1 == 1:
res = self.seg_func(res, self.dat[q])
q -= 1
p = p // 2
q = (q-1) // 2
if p == q:
res = self.seg_func(res, self.dat[p])
else:
res = self.seg_func(self.seg_func(res, self.dat[p]), self.dat[q])
return res
#seg = SegmentTree(L) #RminQ
#seg = SegmentTree(L, max, -1) #RmaxQ
#seg.query(i,j)
#seg.update(i,a)
N = int(input())
XD = [None]*N
for i in range(N):
X, D = (int(i) for i in input().split())
XD[i] = (X, D)
XD.sort()
seg = SegmentTree(list(range(N)), max, -1)
L = list(range(N))
import bisect
for i in range(N)[::-1]:
x, d = XD[i]
b = bisect.bisect_left(XD, (x+d-0.5, d))-1
m = seg.query(i,b+1)
seg.update(i,m)
L[i] = m
ans = [0]*N
res = 1
for i in range(N)[::-1]:
if L[i] == i:
ans[i] = res
res *= 2
else:
ans[i] = ans[L[i]]
res += ans[i]
res %= 998244353
print(res)
``` |
p02893 AtCoder Grand Contest 039 - Division by Two with Something | Given are integers N and X. For each integer k between 0 and X (inclusive), find the answer to the following question, then compute the sum of all those answers, modulo 998244353.
* Let us repeat the following operation on the integer k. Operation: if the integer is currently odd, subtract 1 from it and divide it by 2; otherwise, divide it by 2 and add 2^{N-1} to it. How many operations need to be performed until k returns to its original value? (The answer is considered to be 0 if k never returns to its original value.)
Constraints
* 1 \leq N \leq 2\times 10^5
* 0 \leq X < 2^N
* X is given in binary and has exactly N digits. (In case X has less than N digits, it is given with leading zeroes.)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print the sum of the answers to the questions for the integers between 0 and X (inclusive), modulo 998244353.
Examples
Input
3
111
Output
40
Input
6
110101
Output
616
Input
30
001110011011011101010111011100
Output
549320998 | ```python
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 998244353
n = I()
x = S()
rx=x.replace("1","2").replace("0","1").replace("2","0")
D = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
if n // i % 2:
D += [i]
if i != n // i and i % 2:
D += [n // i]
D.sort()
cnt = [0]*len(D)
ans=0
for k in range(len(D)):
t=x[:D[k]]
rt=rx[:D[k]]
f=(t+rt)*(n//D[k]//2)+t
cnt[k]=cnt[k]+int(f<=x)+int(t,2)
cnt[k]%=mod
ans += cnt[k]*D[k]*2
for kk in range(k + 1, len(D)):
if D[kk] % D[k] == 0:
cnt[kk] -= cnt[k]
cnt[kk]%=mod
print(ans % mod)
``` |
p03028 M-SOLUTIONS Programming Contest - Random Tournament | We will host a rock-paper-scissors tournament with N people. The participants are called Person 1, Person 2, \ldots, Person N. For any two participants, the result of the match between them is determined in advance. This information is represented by positive integers A_{i,j} ( 1 \leq j < i \leq N ) as follows:
* If A_{i,j} = 0, Person j defeats Person i.
* If A_{i,j} = 1, Person i defeats Person j.
The tournament proceeds as follows:
* We will arrange the N participants in a row, in the order Person 1, Person 2, \ldots, Person N from left to right.
* We will randomly choose two consecutive persons in the row. They will play a match against each other, and we will remove the loser from the row. We will repeat this process N-1 times, and the last person remaining will be declared the champion.
Find the number of persons with the possibility of becoming the champion.
Constraints
* 1 \leq N \leq 2000
* A_{i,j} is 0 or 1.
Input
Input is given from Standard Input in the following format:
N
A_{2,1}
A_{3,1}A_{3,2}
:
A_{N,1}\ldotsA_{N,N-1}
Output
Print the number of persons with the possibility of becoming the champion.
Examples
Input
3
0
10
Output
2
Input
6
0
11
111
1111
11001
Output
3 | ```python
import sys
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline()[:-1]
def pbit(aa,L):
for a in aa:print(format(a,"b").zfill(L))
print()
def main():
n=II()
aa=[[int(c) for c in SI()] for _ in range(n-1)]
#p2D(aa)
# 人iが勝てる相手をbitで管理する
win=[0]*n
for i,row in enumerate(aa,1):
for j,a in enumerate(row):
if a:win[i]|=1<<j
else:win[j]|=1<<i
#pbit(win,n)
# dpl[i]...[j,i]の範囲で優勝できるjをbitで
# dpr[i]...[i,j]の範囲で優勝できるjをbitで
dpl=[1<<i for i in range(n)]
dpr=[1<<i for i in range(n)]
for d in range(1,n):
for i in range(n):
j=i+d
if j<n and dpl[j] & dpr[i+1] & win[i]:dpl[j]|=1<<i
j=i-d
if j>=0 and dpl[i-1] & dpr[j] & win[i]:dpr[j]|=1<<i
#pbit(dpl,n)
#pbit(dpr,n)
#print(format(dpl[n-1]&dpr[0],"b").zfill(n))
print(bin(dpl[n-1]&dpr[0]).count("1"))
main()
``` |
p03169 Educational DP Contest - Sushi | There are N dishes, numbered 1, 2, \ldots, N. Initially, for each i (1 \leq i \leq N), Dish i has a_i (1 \leq a_i \leq 3) pieces of sushi on it.
Taro will perform the following operation repeatedly until all the pieces of sushi are eaten:
* Roll a die that shows the numbers 1, 2, \ldots, N with equal probabilities, and let i be the outcome. If there are some pieces of sushi on Dish i, eat one of them; if there is none, do nothing.
Find the expected number of times the operation is performed before all the pieces of sushi are eaten.
Constraints
* All values in input are integers.
* 1 \leq N \leq 300
* 1 \leq a_i \leq 3
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 \ldots a_N
Output
Print the expected number of times the operation is performed before all the pieces of sushi are eaten. The output is considered correct when the relative difference is not greater than 10^{-9}.
Examples
Input
3
1 1 1
Output
5.5
Input
1
3
Output
3
Input
2
1 2
Output
4.5
Input
10
1 3 2 3 3 2 3 2 1 3
Output
54.48064457488221 | ```python
n=int(input())
k=[0,0,0]
a,s,d=0,0,0
for i in input().split():
if i=="1":a+=1
elif i=="2":s+=1
else:d+=1
dp=[[ [0]*(n+1) for j in range(n+1)] for i in range(n+1)]
for i in range(d+1):
for j in range(d+s+1):
for k in range(n+1-i-j):
su=i+j+k
ret=0
if su:
ret+=n/su
if i>=1:
ret+=dp[i-1][j+1][k]*i/su
if j>=1 :
ret+=dp[i][j-1][k+1]*j/su
if k>=1:
ret+=dp[i][j][k-1]*k/su
dp[i][j][k]=ret
print(dp[d][s][a])
``` |
p03314 AtCoder Regular Contest 100 - Colorful Sequences | You are given integers N, K, and an integer sequence A of length M.
An integer sequence where each element is between 1 and K (inclusive) is said to be colorful when there exists a contiguous subsequence of length K of the sequence that contains one occurrence of each integer between 1 and K (inclusive).
For every colorful integer sequence of length N, count the number of the contiguous subsequences of that sequence which coincide with A, then find the sum of all the counts. Here, the answer can be extremely large, so find the sum modulo 10^9+7.
Constraints
* 1 \leq N \leq 25000
* 1 \leq K \leq 400
* 1 \leq M \leq N
* 1 \leq A_i \leq K
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K M
A_1 A_2 ... A_M
Output
For every colorful integer sequence of length N, count the number of the contiguous subsequences of that sequence which coincide with A, then print the sum of all the counts modulo 10^9+7.
Examples
Input
3 2 1
1
Output
9
Input
4 2 2
1 2
Output
12
Input
7 4 5
1 2 3 1 2
Output
17
Input
5 4 3
1 1 1
Output
0
Input
10 3 5
1 1 2 3 3
Output
1458
Input
25000 400 4
3 7 31 127
Output
923966268
Input
9954 310 12
267 193 278 294 6 63 86 166 157 193 168 43
Output
979180369 | ```python
MOD = 10 ** 9 + 7
n, k, m = map(int, input().split())
a = list(map(int, input().split()))
def include_perm(a):
for i in range(m - k + 1):
seen = [False] * (k + 1)
for j in range(i, i + k):
if seen[a[j]]:
break
seen[a[j]] = True
else:
return True
return False
def unique_len(a):
seen = [False] * (k+1)
ans = 0
for ai in a:
if seen[ai]:
break
seen[ai] = True
ans += 1
return ans
if unique_len(a) < m:
dp_fw = [[0] * k for _ in range(n-m+1)]
dp_bw = [[0] * k for _ in range(n-m+1)]
if not include_perm(a):
dp_fw[0][unique_len(reversed(a))] = 1
dp_bw[0][unique_len(a)] = 1
for i in range(n-m):
for j in range(k):
dp_fw[i+1][j] = dp_fw[i][j]
dp_bw[i+1][j] = dp_bw[i][j]
for j in range(k-2, 0, -1):
dp_fw[i+1][j] += dp_fw[i+1][j+1]
dp_fw[i+1][j] %= MOD
dp_bw[i+1][j] += dp_bw[i+1][j+1]
dp_bw[i+1][j] %= MOD
for j in range(k-1):
dp_fw[i+1][j+1] += dp_fw[i][j] * (k-j)
dp_fw[i+1][j] %= MOD
dp_bw[i+1][j+1] += dp_bw[i][j] * (k-j)
dp_bw[i+1][j] %= MOD
ans = 0
tot = pow(k, n-m, MOD)
for i in range(n-m+1):
lcnt = i
rcnt = n - m - i
t = tot - sum(dp_fw[rcnt]) * sum(dp_bw[lcnt])
ans = (ans + t) % MOD
print(ans)
else:
dp = [[0] * k for _ in range(n+1)]
dp2 = [[0] * k for _ in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(1, k):
dp[i+1][j] = dp[i][j]
dp2[i+1][j] = dp2[i][j]
for j in range(k-2, 0, -1):
dp[i+1][j] += dp[i+1][j+1]
dp[i+1][j] %= MOD
dp2[i+1][j] += dp2[i+1][j+1]
dp2[i+1][j] %= MOD
for j in range(k-1):
dp[i+1][j+1] += dp[i][j] * (k-j)
dp[i+1][j+1] %= MOD
dp2[i+1][j+1] += dp2[i][j] * (k-j)
dp2[i+1][j+1] %= MOD
for j in range(m, k):
dp2[i+1][j] += dp[i+1][j]
dp2[i+1][j] %= MOD
f = 1
for i in range(m):
f = f * (k - i) % MOD
t = sum(dp2[n]) * pow(f, MOD-2, MOD) % MOD
ans = ((n-m+1) * pow(k, n-m, MOD) - t) % MOD
print(ans)
``` |
p03471 AtCoder Beginner Contest 085 - Otoshidama | The commonly used bills in Japan are 10000-yen, 5000-yen and 1000-yen bills. Below, the word "bill" refers to only these.
According to Aohashi, he received an otoshidama (New Year money gift) envelope from his grandfather that contained N bills for a total of Y yen, but he may be lying. Determine whether such a situation is possible, and if it is, find a possible set of bills contained in the envelope. Assume that his grandfather is rich enough, and the envelope was large enough.
Constraints
* 1 ≤ N ≤ 2000
* 1000 ≤ Y ≤ 2 × 10^7
* N is an integer.
* Y is a multiple of 1000.
Input
Input is given from Standard Input in the following format:
N Y
Output
If the total value of N bills cannot be Y yen, print `-1 -1 -1`.
If the total value of N bills can be Y yen, let one such set of bills be "x 10000-yen bills, y 5000-yen bills and z 1000-yen bills", and print x, y, z with spaces in between. If there are multiple possibilities, any of them may be printed.
Examples
Input
9 45000
Output
4 0 5
Input
20 196000
Output
-1 -1 -1
Input
1000 1234000
Output
14 27 959
Input
2000 20000000
Output
2000 0 0 | ```python
n, y = map(int,input().split())
ans = [-1,-1,-1]
for i in range(n+1):
for j in range(n+1-i):
if 10000*i + 5000*j + 1000*(n-i-j) == y:
ans = [i,j,n-i-j]
print(*ans)
``` |
p03633 AtCoder Beginner Contest 070 - Multiple Clocks | We have N clocks. The hand of the i-th clock (1≤i≤N) rotates through 360° in exactly T_i seconds.
Initially, the hand of every clock stands still, pointing directly upward.
Now, Dolphin starts all the clocks simultaneously.
In how many seconds will the hand of every clock point directly upward again?
Constraints
* 1≤N≤100
* 1≤T_i≤10^{18}
* All input values are integers.
* The correct answer is at most 10^{18} seconds.
Input
Input is given from Standard Input in the following format:
N
T_1
:
T_N
Output
Print the number of seconds after which the hand of every clock point directly upward again.
Examples
Input
2
2
3
Output
6
Input
5
2
5
10
1000000000000000000
1000000000000000000
Output
1000000000000000000 | ```python
from fractions import gcd
from functools import reduce
n, *T = map(int, open(0).read().split())
print(reduce(lambda x, y:x*y//gcd(x, y), T))
``` |
p03791 Mujin Programming Challenge 2017 - Robot Racing | You are developing frog-shaped robots, and decided to race them against each other.
First, you placed N robots onto a number line. These robots are numbered 1 through N. The current coordinate of robot i is x_i. Here, all x_i are integers, and 0 < x_1 < x_2 < ... < x_N.
You will repeatedly perform the following operation:
* Select a robot on the number line. Let the coordinate of the robot be x. Select the destination coordinate, either x-1 or x-2, that is not occupied by another robot. The robot now jumps to the selected coordinate.
When the coordinate of a robot becomes 0 or less, the robot is considered finished and will be removed from the number line immediately. You will repeat the operation until all the robots finish the race.
Depending on your choice in the operation, the N robots can finish the race in different orders. In how many different orders can the N robots finish the race? Find the answer modulo 10^9+7.
Constraints
* 2 ≤ N ≤ 10^5
* x_i is an integer.
* 0 < x_1 < x_2 < ... < x_N ≤ 10^9
Input
The input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
Output
Print the number of the different orders in which the N robots can finish the race, modulo 10^9+7.
Examples
Input
3
1 2 3
Output
4
Input
3
2 3 4
Output
6
Input
8
1 2 3 5 7 11 13 17
Output
10080
Input
13
4 6 8 9 10 12 14 15 16 18 20 21 22
Output
311014372 | ```python
input()
a=b=1
for r in input().split():
a=a*b%(10**9+7)
if b*2<eval(r+'+2'):b+=1
print(a)
``` |
p03959 CODE FESTIVAL 2016 qual C - Two Alpinists | Mountaineers Mr. Takahashi and Mr. Aoki recently trekked across a certain famous mountain range. The mountain range consists of N mountains, extending from west to east in a straight line as Mt. 1, Mt. 2, ..., Mt. N. Mr. Takahashi traversed the range from the west and Mr. Aoki from the east.
The height of Mt. i is h_i, but they have forgotten the value of each h_i. Instead, for each i (1 ≤ i ≤ N), they recorded the maximum height of the mountains climbed up to the time they reached the peak of Mt. i (including Mt. i). Mr. Takahashi's record is T_i and Mr. Aoki's record is A_i.
We know that the height of each mountain h_i is a positive integer. Compute the number of the possible sequences of the mountains' heights, modulo 10^9 + 7.
Note that the records may be incorrect and thus there may be no possible sequence of the mountains' heights. In such a case, output 0.
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ T_i ≤ 10^9
* 1 ≤ A_i ≤ 10^9
* T_i ≤ T_{i+1} (1 ≤ i ≤ N - 1)
* A_i ≥ A_{i+1} (1 ≤ i ≤ N - 1)
Input
The input is given from Standard Input in the following format:
N
T_1 T_2 ... T_N
A_1 A_2 ... A_N
Output
Print the number of possible sequences of the mountains' heights, modulo 10^9 + 7.
Examples
Input
5
1 3 3 3 3
3 3 2 2 2
Output
4
Input
5
1 1 1 2 2
3 2 1 1 1
Output
0
Input
10
1 3776 3776 8848 8848 8848 8848 8848 8848 8848
8848 8848 8848 8848 8848 8848 8848 8848 3776 5
Output
884111967
Input
1
17
17
Output
1 | ```python
N=int(input())
T = list(map(int, input().split()))
A = list(map(int, input().split()))
a = 1
if T[0]>A[0] or A[-1]>T[-1] or T[-1]!=A[0]:
a*=0
for i in range(1,N-1):
if T[i-1]!=T[i]:
if T[i]>A[i]:
a*=0
break
else:
a*=1
elif A[i]!=A[i+1]:
if T[i]<A[i]:
a*=0
break
else:
a*=1
else:
a=(a*min(T[i],A[i]))%(10**9+7)
print(a)
``` |
p00051 Differential II | When you enter 8 numbers from 0 to 9, write a program that outputs the difference between the largest integer and the smallest integer that can sort the 8 numbers. The number that can be sorted may start from 0, such as 00135569.
Input
Given multiple datasets. The number of datasets n (n ≤ 50) is given on the first line. Then n rows of data are given. Each data is a sequence of 8 numbers (0 to 9 numbers).
Output
For each dataset, output the difference between the largest and smallest integers that can be rearranged in the entered numbers on one line.
Example
Input
2
65539010
65539010
Output
96417531
96417531 | ```python
n=int(input())
for _ in range(n):
c=[i for i in input()]
Max=int("".join(sorted(c,reverse=True)))
Min=int("".join(sorted(c)))
print(Max-Min)
``` |
p00181 Bookshelf | Taro is addicted to a novel. The novel has n volumes in total, and each volume has a different thickness. Taro likes this novel so much that he wants to buy a bookshelf dedicated to it. However, if you put a large bookshelf in the room, it will be quite small, so you have to devise to make the width of the bookshelf as small as possible. When I measured the height from the floor to the ceiling, I found that an m-level bookshelf could be placed. So, how can we divide the n volumes of novels to minimize the width of the bookshelf in m columns? Taro is particular about it, and the novels to be stored in each column must be arranged in the order of the volume numbers. ..
Enter the number of bookshelves, the number of volumes of the novel, and the thickness of each book as input, and create a program to find the width of the bookshelf that has the smallest width that can accommodate all volumes in order from one volume. However, the size of the bookshelf frame is not included in the width.
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
m n
w1
w2
::
wn
The first line gives m (1 ≤ m ≤ 20) the number of bookshelves that can be placed in the room and n (1 ≤ n ≤ 100) the number of volumes in the novel. The next n lines are given the integer wi (1 ≤ wi ≤ 1000000), which represents the thickness of the book in Volume i.
However, the width of the bookshelf shall not exceed 1500000.
The number of datasets does not exceed 50.
Output
Outputs the minimum bookshelf width for each dataset on one line.
Example
Input
3 9
500
300
800
200
100
600
900
700
400
4 3
1000
1000
1000
0 0
Output
1800
1000 | ```python
import bisect
def main():
m,n = list(map(int,input().split()))
if n==0:
exit()
W = [int(input()) for _ in range(n)]
w_total = 0
w_sum =[]
for w in W:
w_total+=w
w_sum.append(w_total)
def judge(shelf_length):
last_val = 0
for i in range(m):
_index= bisect.bisect_right(w_sum,last_val+shelf_length)
#print(_index)
if _index == n:
return True
if _index == 0:
return False
last_val =w_sum[ _index-1]
return False
def nibun(func ,min_ ,max_ ):
left = min_
right= max_
while not(left==right):
mid = (left+right) //2
tmp = func(mid)
if tmp:
right = mid
else:
left = mid+1
return left
print(nibun(judge,0,1500009))
while True:
main()
``` |
p00337 Road Planning | Villages were scattered in the Wakamatsu Plain of Aizu. Several settlements are connected by straight roads that allow them to travel to and from each other, and any settlement in the plain can be traced back and forth. Each road has a lengthy maintenance fee, but all the settlements funded the road to maintain it.
At one point, it was decided that all the settlements would be united in one village, and the boundaries surrounding the villages would be drawn. According to national rules, no straight line connecting any of the two settlements that make up a village should pass outside the village (it is permissible to pass on the border). In addition, in Aizu, there must be a road on the border that surrounds the village. Where there is no road on the border, the country will create a new one.
However, the village pays for the maintenance of the road, so the villagers want to keep the boundaries as short as possible. In addition, the villagers decided to minimize the total length of the roads by eliminating roads that were not on the border, while maintaining the ability to travel between all settlements.
Information on the location of the village and the original road is given. Create a program that calculates the minimum total length of the roads when the roads are on the border and all settlements are allowed to come and go. However, the village shall be a point with no size, and the road shall be a line segment with no width.
Input
The input is given in the following format.
VR
x1 y1
x2 y2
::
xV yV
s1 t1
s2 t2
::
sR tR
The number of settlements V (3 ≤ V ≤ 100) and the number of roads R (2 ≤ R ≤ 1000) are given in the first line.
The following V line gives information on the points that represent the settlement. The two integers xi, yi (-1000 ≤ xi, yi ≤ 1000) given in each row represent the x-coordinate and y-coordinate of the i-th settlement, respectively.
The following R line is given information on the original road. The two integers si, ti (1 ≤ si <ti ≤ V) given in each row indicate that the i-th road connects the si-th and ti-th settlements.
The input satisfies the following conditions.
* If i ≠ j, the coordinates of the i-th and j-th settlements are different.
* In each of the two settlements, there is at most one way to connect them directly.
* Two different roads do not share any points other than the endpoints.
* Three or more settlements are never lined up on the same straight line.
Output
The minimum value of the total length of roads that satisfy the conditions is output as a real number on one line. However, the error must not exceed plus or minus 0.001. If this condition is satisfied, any number of digits after the decimal point may be displayed.
Examples
Input
5 5
0 0
1 1
3 0
3 2
0 2
1 2
2 3
2 4
3 4
1 5
Output
11.4142
Input
7 6
0 2
3 0
2 2
1 0
4 1
2 3
3 5
1 3
2 4
2 3
3 5
3 7
6 7
Output
18.2521 | ```python
import sys
def graham_scan(vertices: list):
from math import atan2
from operator import itemgetter
vertices.sort(key=itemgetter(1))
base_x, base_y = vertices[0][:2]
vertices = sorted(vertices[1:], key=lambda p: atan2(p[1]-base_y, p[0]-base_x)) + vertices[:1]
convex = vertices[-1:] + vertices[:1]
pop, append = convex.pop, convex.append
last_x, last_y = convex[-1][:2]
for point, (x, y, *_) in zip(vertices[1:], vertices[1:]):
while ((x - last_x) * (convex[-2][1] - last_y) -
(y - last_y) * (convex[-2][0] - last_x) < 0):
pop()
last_x, last_y = convex[-1][:2]
append(point)
last_x, last_y = x, y
return convex[:-1]
def kruskal(v_count: int, edges: list, border) -> int:
"""
:param v_count: 頂点数
:param edges: [(weight, from, to), ... ]
"""
from itertools import islice
tree = [-1]*v_count
def get_root(x) -> int:
if tree[x] < 0:
return x
tree[x] = get_root(tree[x])
return tree[x]
def unite(a) -> bool:
x, y = get_root(a[1]), get_root(a[2])
if x != y:
big, small = (x, y) if tree[x] < tree[y] else (y, x)
tree[big] += tree[small]
tree[small] = big
return x != y
cost = 0
for c, s, t in border_edges:
cost += c
unite((0, s, t))
v_count -= len(border_edges)-1
for w, _s, _t in islice(filter(unite, sorted(edges)), v_count-1):
cost += w
return cost
if __name__ == "__main__":
from math import hypot
V, R = map(int, input().split())
vertices = [list(map(int, sys.stdin.readline().split()))+[i] for i in range(V)]
edges = [(hypot(vertices[s-1][0]-vertices[t-1][0], vertices[s-1][1]-vertices[t-1][1]), s-1, t-1)
for l in sys.stdin for s, t in (map(int, l.split()),)]
convex = graham_scan(vertices)
border_edges = [(hypot(x1-x2, y1-y2), s, t) for (x1, y1, s), (x2, y2, t) in zip(convex, convex[1:]+convex[:1])]
cost = kruskal(V, edges, border_edges)
print(cost)
``` |
p00528 Modern Mansion | Modern Mansion
You got lost in a big mansion. This mansion has a structure in which square rooms are arranged in a grid pattern from north, south, east, and west, with M columns in the east-west direction and N rows in the north-south direction, for a total of M x N. The room in the xth column (1 ≤ x ≤ M) from the west and the yth row (1 ≤ y ≤ N) from the south is represented by (x, y).
The two rooms adjacent to the north, south, east and west are connected by a door in the center of the wall. Each door is either closed and impassable, or open and impassable. When the doors are open, it takes a minute to move between the centers of those rooms. In addition, there is a switch in the center of some rooms, and if you hold down the switch for 1 minute, all the doors in the mansion will be opened and closed.
Now, all the doors connecting the two adjacent rooms in the east and west are closed, and all the doors connecting the two adjacent rooms in the north and south are open. You are now in the center of room (1, 1) and want to move to the center of room (M, N) in the shortest amount of time.
Task
The size of the mansion M, N and the positions of K rooms with switches (X1, Y1), (X2, Y2), ..., (XK, YK) are given. All doors connecting the two adjacent rooms in the east and west are closed, and all doors connecting the two adjacent rooms in the north and south are open, starting from the center of the room (1, 1) to the room (M, N). Create a program that finds how many minutes it will take at the shortest to move to the center of the door. However, if you cannot reach the room (M, N), point it out.
Limits
* 2 ≤ M ≤ 100 000 Number of rooms in the east-west direction of the mansion
* 2 ≤ N ≤ 100 000 Number of rooms in the north-south direction of the mansion
* 1 ≤ K ≤ 200 000 Number of rooms with switches
* 1 ≤ Xi ≤ M The east-west position of the room with the switch
* 1 ≤ Yi ≤ N The north-south position of the room with the switch
input
Read the following data from standard input.
* On the first line, the integers M, N, and K are written with blanks as delimiters. M is the number of rooms in the east-west direction of the mansion, N is the number of rooms in the north-south direction of the mansion, and K is the number of rooms with switches.
* On the i-th line (1 ≤ i ≤ K) of the following K lines, the integers Xi and Yi are written separated by blanks. This means that there is a switch in the center of the room (Xi, Yi). The K pairs (X1, Y1), (X2, Y2), ..., (XK, YK) are different from each other.
output
Print an integer on one line to the standard output, which indicates how many minutes it will take to move at the shortest. However, if the room (M, N) cannot be reached, output the integer -1 instead.
Scoring criteria
* Of the scoring data, 20% of the points are satisfied with M ≤ 1 000 and N ≤ 1 000.
* Of the scoring data, 30% of the points are given by satisfying K ≤ 20000.
* Of the scoring data, 50% of the scores satisfy at least one of these two conditions. In addition, there is no scoring data that satisfies both of these two conditions.
Input / output example
Input example 1
3 2 1
1 2
Output example 1
Four
In this example, the following actions can move from the center of the room (1, 1) to the center of the room (3, 2) in 4 minutes, which is the shortest.
1. Move to the center of room (1, 2).
2. Press the switch in the center of the room (1, 2).
3. Move to the center of room (2, 2).
4. Move to the center of room (3, 2).
The state of the mansion at this time is shown in the figure below. In the figure, the right direction is east, the upward direction is north, the x mark indicates your position, and the ○ mark indicates the switch.
<image>
Input example 2
3 2 1
twenty one
Output example 2
-1
In this example, you cannot reach the room (3, 2).
Input example 3
8 9 15
3 1
3 2
3 7
3 8
1 1
4 5
4 3
5 6
5 8
6 3
6 2
7 5
8 9
8 6
8 5
Output example 3
twenty five
In this example, the appearance of the first mansion is as shown in the figure below. Note that there may be a switch in the center of the room (1, 1) or room (M, N).
<image>
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
3 2 1
1 2
Output
4 | ```python
from heapq import heappush, heappop
M, N, K = map(int, input().split())
X = [[] for i in range(M)]
Y = [[] for i in range(N)]
for i in range(K):
x, y = map(int, input().split()); x -= 1; y -= 1
X[x].append((y, i))
Y[y].append((x, i))
G0 = [[] for i in range(K)]
G1 = [[] for i in range(K)]
for x in range(M):
vs = X[x]
if vs:
vs.sort()
prv = vs[0]
for v in vs[1:]:
d = v[0] - prv[0]
G0[prv[1]].append((v[1], d))
G0[v[1]].append((prv[1], d))
prv = v
for y in range(N):
vs = Y[y]
if vs:
vs.sort()
prv = vs[0]
for v in vs[1:]:
d = v[0] - prv[0]
G1[prv[1]].append((v[1], d))
G1[v[1]].append((prv[1], d))
prv = v
INF = 10**18
que = []
D0 = [INF]*K; D1 = [INF]*K
if X[0]:
y0, k = X[0][0]
que.append((y0, 0, k))
while que:
cost, t, v = heappop(que)
if not t:
if D0[v] < cost:
continue
for w, d in G0[v]:
if cost + d < D0[w]:
D0[w] = cost + d
heappush(que, (cost + d, 0, w))
if cost + 1 < D1[v]:
D1[v] = cost + 1
heappush(que, (cost + 1, 1, v))
else:
if D1[v] < cost:
continue
for w, d in G1[v]:
if cost + d < D1[w]:
D1[w] = cost + d
heappush(que, (cost + d, 1, w))
if cost + 1 < D0[v]:
D0[v] = cost + 1
heappush(que, (cost + 1, 0, v))
ans = INF
if X[M-1]:
y0, k = X[M-1][-1]
ans = min(ans, D0[k] + (N-1-y0))
if Y[N-1]:
x0, k = Y[N-1][-1]
ans = min(ans, D1[k] + (M-1-x0))
if ans < INF:
print(ans)
else:
print(-1)
``` |
p00695 Get a Rectangular Field | Karnaugh is a poor farmer who has a very small field. He wants to reclaim wasteland in the kingdom to get a new field. But the king who loves regular shape made a rule that a settler can only get a rectangular land as his field. Thus, Karnaugh should get the largest rectangular land suitable for reclamation.
The map of the wasteland is represented with a 5 x 5 grid as shown in the following figures, where '1' represents a place suitable for reclamation and '0' represents a sandy place. Your task is to find the largest rectangle consisting only of 1's in the map, and to report the size of the rectangle. The size of a rectangle is defined by the number of 1's in it. Note that there may be two or more largest rectangles of the same size.
<image>
Figure 1. The size of the largest rectangles is 4.
There are two largest rectangles (shaded).
<image>
Figure 2. The size of the largest rectangle is 3.
There is one largest rectangle (shaded).
Input
The input consists of maps preceded by an integer m indicating the number of input maps.
m
map1
map2
map3
...
mapm
Two maps are separated by an empty line.
Each mapk is in the following format:
p p p p p
p p p p p
p p p p p
p p p p p
p p p p p
Each p is a character either '1' or '0'. Two p's in the same line are separated by a space character. Here, the character '1' shows a place suitable for reclamation and '0' shows a sandy place. Each map contains at least one '1'.
Output
The size of the largest rectangle(s) for each input map should be shown each in a separate line.
Example
Input
3
1 1 0 1 0
0 1 1 1 1
1 0 1 0 1
0 1 1 1 0
0 1 1 0 0
0 1 0 1 1
0 1 0 1 0
0 0 1 0 0
0 0 1 1 0
1 0 1 0 0
1 1 1 1 0
0 1 1 1 0
0 1 1 0 1
0 1 1 1 0
0 0 0 0 1
Output
4
3
8 | ```python
# AOJ 1114: Get a Rectangular Field
# Python3 2018.7.8 bal4u
s = [[0 for c in range(6)] for r in range(6)]
for k in range(int(input())):
if k > 0: input()
for r in range(5):
a = list(map(int, input().split()))
for c in range(5): s[r+1][c+1] = s[r+1][c]+a[c]
ans = 0;
for r in range(1, 6):
for c in range(1, 6):
for c2 in range(5, c-1, -1):
w2 = w = c2-c+1
if w2 > s[r][c2]-s[r][c-1]: continue
ans = max(ans, w2)
for r2 in range(r+1, 6):
if w > s[r2][c2]-s[r2][c-1]: break
w2 += w
ans = max(ans, w2)
print(ans)
``` |
p00836 Sum of Consecutive prime Numbers | Some positive integers can be represented by a sum of one or more consecutive prime numbers. How many such representations does a given positive integer have? For example, the integer 53 has two representations 5 + 7 + 11 + 13 + 17 and 53. The integer 41 has three representations 2 + 3 + 5 + 7 + 11 + 13, 11 + 13 + 17, and 41. The integer 3 has only one representation, which is 3. The integer 20 has no such representations. Note that summands must be consecutive prime numbers, so neither 7 + 13 nor 3 + 5 + 5 + 7 is a valid representation for the integer 20.
Your mission is to write a program that reports the number of representations for the given positive integer.
Input
The input is a sequence of positive integers each in a separate line. The integers are between 2 and 10 000, inclusive. The end of the input is indicated by a zero.
Output
The output should be composed of lines each corresponding to an input line except the last zero. An output line includes the number of representations for the input integer as the sum of one or more consecutive prime numbers. No other characters should be inserted in the output.
Example
Input
2
3
17
41
20
666
12
53
0
Output
1
1
2
3
0
0
1
2 | ```python
def solve():
# making a list of prime numbers
primes = [2, 3]
for n in range(5, 10000, 2):
l = n ** 0.5
for p in primes:
if n % p == 0:
break
if l < p:
primes.append(n)
break
primes = [0] + primes
from itertools import accumulate
ac_primes = list(accumulate(primes))
from bisect import bisect_left, bisect_right
from sys import stdin
file_input = stdin
for line in file_input:
n = int(line)
if n == 0:
break
low = bisect_left(ac_primes, n)
high = bisect_right(primes, n)
ans = 0
for x in ac_primes[low:high]:
t = x - n
if t == ac_primes[bisect_left(ac_primes, t)]:
ans += 1
print(ans)
solve()
``` |
p00968 Digits Are Not Just Characters | Digits Are Not Just Characters
Mr. Manuel Majorana Minore made a number of files with numbers in their names. He wants to have a list of the files, but the file listing command commonly used lists them in an order different from what he prefers, interpreting digit sequences in them as ASCII code sequences, not as numbers. For example, the files file10, file20 and file3 are listed in this order.
Write a program which decides the orders of file names interpreting digit sequences as numeric values.
Each file name consists of uppercase letters (from 'A' to 'Z'), lowercase letters (from 'a' to 'z'), and digits (from '0' to '9').
A file name is looked upon as a sequence of items, each being either a letter or a number. Each single uppercase or lowercase letter forms a letter item. Each consecutive sequence of digits forms a number item.
Two item are ordered as follows.
* Number items come before letter items.
* Two letter items are ordered by their ASCII codes.
* Two number items are ordered by their values when interpreted as decimal numbers.
Two file names are compared item by item, starting from the top, and the order of the first different corresponding items decides the order of the file names. If one of them, say $A$, has more items than the other, $B$, and all the items of $B$ are the same as the corresponding items of $A$, $B$ should come before.
For example, three file names in Sample Input 1, file10, file20, and file3 all start with the same sequence of four letter items f, i, l, and e, followed by a number item, 10, 20, and 3, respectively. Comparing numeric values of these number items, they are ordered as file3 $<$ file10 $<$ file20.
Input
The input consists of a single test case of the following format.
$n$
$s_0$
$s_1$
:
$s_n$
The integer $n$ in the first line gives the number of file names ($s_1$ through $s_n$) to be compared with the file name given in the next line ($s_0$). Here, $n$ satisfies $1 \leq n \leq 1000$.
The following $n + 1$ lines are file names, $s_0$ through $s_n$, one in each line. They have at least one and no more than nine characters. Each of the characters is either an uppercase letter, a lowercase letter, or a digit.
Sequences of digits in the file names never start with a digit zero (0).
Output
For each of the file names, $s_1$ through $s_n$, output one line with a character indicating whether it should come before $s_0$ or not. The character should be "-" if it is to be listed before $s_0$; otherwise, it should be "+", including cases where two names are identical.
Sample Input 1
2
file10
file20
file3
Sample Output 1
+
-
Sample Input 2
11
X52Y
X
X5
X52
X52Y
X52Y6
32
ABC
XYZ
x51y
X8Y
X222
Sample Output 2
-
-
-
+
+
-
-
+
+
-
+
Example
Input
2
file10
file20
file3
Output
+
- | ```python
n = int(input())
ss = [input() for _ in range(n + 1)]
sp = [[s[0]] for s in ss]
for i, s in enumerate(ss):
for j in range(1, len(s)):
if s[j - 1].isdigit() != s[j].isdigit():
sp[i].append('')
sp[i][-1] += s[j]
s0 = sp[0]
for s in sp[1:]:
p = 0
m = min(len(s0), len(s))
while p < m and s0[p] == s[p]:
p += 1
if p == m:
print('-+'[len(s0) <= len(s)])
continue
a = s0[p].isdigit()
b = s[p].isdigit()
if a and b:
print('-+'[int(s0[p]) <= int(s[p])])
elif a or b:
print('-+'[a])
else:
print('-+'[s0[p] <= s[p]])
``` |
p01100 Gift Exchange Party | Gift Exchange Party
A gift exchange party will be held at a school in TKB City.
For every pair of students who are close friends, one gift must be given from one to the other at this party, but not the other way around. It is decided in advance the gift directions, that is, which student of each pair receives a gift. No other gift exchanges are made.
If each pair randomly decided the gift direction, some might receive countless gifts, while some might receive only few or even none.
You'd like to decide the gift directions for all the friend pairs that minimize the difference between the smallest and the largest numbers of gifts received by a student. Find the smallest and the largest numbers of gifts received when the difference between them is minimized. When there is more than one way to realize that, find the way that maximizes the smallest number of received gifts.
Input
The input consists of at most 10 datasets, each in the following format.
n m
u1 v1
...
um vm
n is the number of students, and m is the number of friendship relations (2 ≤ n ≤ 100, 1 ≤ m ≤ n (n-1)/2). Students are denoted by integers between 1 and n, inclusive. The following m lines describe the friendship relations: for each i, student ui and vi are close friends (ui < vi). The same friendship relations do not appear more than once.
The end of the input is indicated by a line containing two zeros.
Output
For each dataset, output a single line containing two integers l and h separated by a single space. Here, l and h are the smallest and the largest numbers, respectively, of gifts received by a student.
Sample Input
3 3
1 2
2 3
1 3
4 3
1 2
1 3
1 4
4 6
1 2
1 3
1 4
2 3
3 4
2 4
0 0
Output for the Sample Input
1 1
0 1
1 2
Example
Input
3 3
1 2
2 3
1 3
4 3
1 2
1 3
1 4
4 6
1 2
1 3
1 4
2 3
3 4
2 4
0 0
Output
1 1
0 1
1 2 | ```python
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, M = map(int, readline().split())
if N == M == 0:
return False
G = [[] for i in range(N)]
cs = [0]*N
for i in range(M):
u, v = map(int, readline().split())
forward = [v-1, 1, None]
backward = forward[2] = [u-1, 0, forward]
G[u-1].append(forward)
G[v-1].append(backward)
cs[v-1] += 1
prv = [0]*N
while 1:
que = deque()
used = [0]*N
mi = min(cs); ma = max(cs)
for i in range(N):
if mi < cs[i]:
continue
que.append(i)
used[i] = 1
prv[i] = None
j = -1
while que:
v = que.popleft()
if mi+2 <= cs[v]:
j = v
break
for w, d, rev in G[v]:
if d and not used[w]:
que.append(w)
prv[w] = rev
used[w] = 1
if j == -1:
break
v = j
while prv[v] is not None:
e = prv[v]
e[1] = 1; e[2][1] = 0
v = prv[v][0]
cs[v] += 1; cs[j] -= 1
while 1:
que = deque()
used = [0]*N
mi = min(cs); ma = max(cs)
for i in range(N):
if cs[i] < ma:
continue
que.append(i)
used[i] = 1
prv[i] = None
j = -1
while que:
v = que.popleft()
if cs[v] <= ma-2:
j = v
break
for w, d, rev in G[v]:
if not d and not used[w]:
que.append(w)
prv[w] = rev
used[w] = 1
if j == -1:
break
v = j
while prv[v] is not None:
e = prv[v]
e[1] = 0; e[2][1] = 1
v = prv[v][0]
cs[v] -= 1; cs[j] += 1
write("%d %d\n" % (min(cs), max(cs)))
return True
while solve():
...
``` |
p01552 YAML | YAML (YAML Ain't Markup Language) is one of the formats for expressing an object as a character string.
You will be given an object represented by a subset of YAML and a query that specifies the property, so please answer the value of the specified property.
Subset of YAML
A subset of YAML follows the syntax rules expressed in extended BNF notation:
yaml: mapping (0)
mapping (n): mapping-item (n) | mapping-item (n) mapping (n)
mapping-item (n): indent (n) key':''' string'\ n'
| indent (n) key':''\ n'mapping (m) (but m> n)
key: [a-z0-9] + (* One or more character strings consisting of lowercase letters or numbers)
string: [a-z0-9] + (* One or more character strings consisting of lowercase letters or numbers or spaces)
indent (0): "" (* empty string)
indent (n + 1):'' indent (n) (* Character string with n + 1 spaces arranged)
'\ n'represents a newline character.
mapping (n) represents the object, and mapping-item (n) contained in mapping (n) represents the properties contained in the object.
`mapping-item (n): indent (n) key':''' string'\ n'` indicates that the value of the property represented by key is a string represented by string.
`mapping-item (n): indent (n) key':''\ n'mapping (m)` indicates that the value of the property represented by key is the object represented by mapping (m). I will.
An object cannot contain more than one property with the same key.
Format of the query that specifies the property
The query that specifies the property is
.key_1.key_2 (.. omitted ..) .key_n
It is given in the form of alternating'`.`' and key, such as "The property with key2 of the object given by yaml, which is the value of the property with key1. Represents a property with a key (.. omitted ..) keyn of an object that is the value of.
For a certain i (1 ≤ i ≤ n -1), the value of the property represented by .key_1.key_2. (.. omitted ..). Key_i is not an object, or it is an object but is called key_i + 1. If it does not contain a property, it is considered that the property represented by .key_1.key_2 (.. omitted ..) .key_n does not exist.
Input
> .key_1.key_2 (...) .key_n
> yaml
>
1 ≤ n ≤ 20
Number of characters in the entire input ≤ 50,000
Output
Print the property value on one line.
Outputs `no such property` if the specified property does not exist,` object` if the property value is an object, and `string" <string content> "` if the property value is a string. please.
Examples
Input
.tweets.1
name: shimeji
id: shimejitan
tweets:
1: shimejilove
2: azupero
Output
string "shimejilove"
Input
.tweets.1
name: shimeji
id: shimejitan
tweets:
1: shimejilove
2: azupero
Output
string "shimejilove"
Input
.a
a: sample case
Output
string "sample case"
Input
.my.obj
my:
str: string value
obj:
a: a
b: b
c: c
Output
object
Input
.str.inner
str: inner
Output
no such property
Input
.no.such.property
object:
prop1: str
prop2: str
Output
no such property | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+9
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(ks):
a = []
while 1:
try:
s = S()
if s == '':
break
a.append(s)
except:
break
y = {}
keys = []
for l in a:
while 1:
yi = y
for k in keys:
yi = yi[k]
ti = 0
for c in l:
if c != ' ':
break
ti += 1
if '_ind' not in yi:
yi['_ind'] = ti
if yi['_ind'] != ti:
keys = keys[:-1]
continue
k = l.split(':')[0].split(' ')[-1]
if l[-1] == ':':
keys.append(k)
yi[k] = {}
else:
yi[k] = l.split(':')[1][1:]
break
ka = ks.split('.')[1:]
yi = y
for k in ka:
if isinstance(yi, str) or k not in yi:
return 'no such property'
yi = yi[k]
if isinstance(yi, str):
return 'string "{}"'.format(yi)
return 'object'
while 1:
n = S()
if n == 0:
break
rr.append(f(n))
break
return '\n'.join(map(str, rr))
print(main())
``` |
p01708 Points and Lines | Problem Statement
One day, you found an old scroll with strange texts on it.
You revealed that the text was actually an expression denoting the position of treasure. The expression consists of following three operations:
* From two points, yield a line on which the points lie.
* From a point and a line, yield a point that is symmetric to the given point with respect to the line.
* From two lines, yield a point that is the intersection of the lines.
The syntax of the expression is denoted by following BNF:
<expression> ::= <point>
<point> ::= <point-factor> | <line> "@" <line-factor> | <line> "@" <point-factor> | <point> "@" <line-factor>
<point-factor> ::= "(" <number> "," <number> ")" | "(" <point> ")"
<line> ::= <line-factor> | <point> "@" <point-factor>
<line-factor> ::= "(" <line> ")"
<number> ::= <zero-digit> | <positive-number> | <negative-number>
<positive-number> ::= <nonzero-digit> | <positive-number> <digit>
<negative-number> ::= "-" <positive-number>
<digit> ::= <zero-digit> | <nonzero-digit>
<zero-digit> ::= "0"
<nonzero-digit> ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
Each <point> or <point-factor> denotes a point, whereas each <line> or <line-factor> denotes a line. The former notion of <point-factor> $(X,Y)$ represents a point which has $X$ for $x$-coordinate and $Y$ for $y$-coordinate on the $2$-dimensional plane. "@" indicates the operations on two operands. Since each operation is distinguishable from others by its operands' types (i.e. a point or a line), all of these operations are denoted by the same character "@". Note that "@" is left-associative, as can be seen from the BNF.
Your task is to determine where the treasure is placed.
Input
The input consists of multiple datasets. Each dataset is a single line which contains an expression denoting the position of treasure.
It is guaranteed that each dataset satisfies the following conditions:
* The length of the string never exceeds $10^2$.
* If both operands of "@" are points, their distance is greater than $1$.
* If both operands of "@" are lines, they are never parallel.
* The absolute values of points' coordinates never exceed $10^2$ at any point of evaluation.
You can also assume that there are at most $100$ datasets.
The input ends with a line that contains only a single "#".
Output
For each dataset, print the $X$ and $Y$ coordinates of the point, denoted by the expression, in this order.
The output will be considered correct if its absolute or relative error is at most $10^{-2}$.
Sample Input
((0,0)@(1,1))@((4,1)@(2,5))
((0,0)@(3,1))@((1,-3)@(2,-1))
(0,0)@(1,1)@(4,1)
(0,0)@((1,1)@(4,1))
(((0,0)@((10,20)@(((30,40))))))
((0,0)@(3,1))@((1,-3)@(2,-1))@(100,-100)@(100,100)
Output for the Sample Input
3.00000000 3.00000000
3.00000000 1.00000000
1.00000000 4.00000000
0.00000000 2.00000000
-10.00000000 10.00000000
-99.83681795 -91.92248853
Example
Input
((0,0)@(1,1))@((4,1)@(2,5))
((0,0)@(3,1))@((1,-3)@(2,-1))
(0,0)@(1,1)@(4,1)
(0,0)@((1,1)@(4,1))
(((0,0)@((10,20)@(((30,40))))))
((0,0)@(3,1))@((1,-3)@(2,-1))@(100,-100)@(100,100)
#
Output
3.00000000 3.00000000
3.00000000 1.00000000
1.00000000 4.00000000
0.00000000 2.00000000
-10.00000000 10.00000000
-99.83681795 -91.92248853 | ```python
digits = "-0123456789"
def cross_point(P, Q):
x0, y0, x1, y1 = P
x2, y2, x3, y3 = Q
dx0 = x1 - x0; dy0 = y1 - y0
dx1 = x3 - x2; dy1 = y3 - y2
s = (y0-y2)*dx1 - (x0-x2)*dy1
sm = dx0*dy1 - dy0*dx1
if s < 0:
s = -s
sm = -sm
if s == 0:
x = x0
y = y0
else:
x = x0 + s*dx0/sm
y = y0 + s*dy0/sm
return x, y
def reflection(line, point):
x0, y0, x1, y1 = line
p, q = point
x1 -= x0; y1 -= y0
p -= x0; q -= y0
cv = p*x1 + q*y1
sv = p*y1 - q*x1
cv2 = cv**2 - sv**2
sv2 = 2*cv*sv
dd = (p**2 + q**2)*(x1**2 + y1**2)
if dd == 0:
return x0 + p, y0 + q
return x0 + (cv2 * p - sv2 * q) / dd, y0 + (sv2 * p + cv2 * q) / dd
def parse(S):
S = S + "$"
cur = 0
def expr():
nonlocal cur
res = None
while S[cur] == '(':
cur += 1 # '('
if S[cur] in digits:
x = number()
cur += 1 # ','
y = number()
r = (0, x, y)
else:
r = expr()
cur += 1 # ')'
if res is None:
res = r
else:
if res[0] == r[0] == 0:
# (point)@(point)
res = (1, res[1], res[2], r[1], r[2])
elif res[0] == r[0] == 1:
# (line)@(line)
x, y = cross_point(res[1:], r[1:])
res = (0, x, y)
else:
# (line)@(point) or (point)@(line)
point, line = (res, r) if r[0] else (r, res)
x, y = reflection(line[1:], point[1:])
res = (0, x, y)
if S[cur] != '@':
break
cur += 1 # '@'
return res
def number():
nonlocal cur
v = 0; mns = 0
if S[cur] == '-':
mns = 1
cur += 1 # '-'
while S[cur] in digits:
v = 10*v + int(S[cur])
cur += 1
return -v if mns else v
return expr()
def solve():
s = input()
if s == '#':
return False
res = parse(s)
print("%.16f %.16f" % res[1:])
return True
while solve():
...
``` |
p01853 Lie with Mean Value | Problem statement
N first-year students of the Faculty of Information Science and Technology of R University take the final exam of the lecture called Programming Exercise 1. The test is a perfect score of m. In other words, the score that one student can get is an integer between 0 and m.
Since the teacher in charge is nasty, I am concerned about the score distribution that maximizes the difference between the average value and the median value. Output one such way of scoring.
Note: The average value is the sum of the points divided by n, and the median is the (n + 1) / second (1 − indexed) from the front if n is an odd number when the points are arranged in ascending order. If it is an even number, it is the score obtained by adding the n / 2nd and n / 2 + 1th scores from the front and dividing by 2.
input
n \ m
Constraint
* An integer
* 1 ≤ n ≤ 100
* 1 ≤ m ≤ 100
output
Output the n-point column of the answer on a single line separated by spaces, and finally output a line break. If there are multiple types, any one can be output.
sample
Sample input 1
3 100
Sample output 1
0 0 100
100 \ 100 \ 0 etc. are also correct answers.
Sample input 2
1 100
Sample output 2
50
Example
Input
3 100
Output
0 0 100 | ```python
# -*- coding: utf-8 -*-
(n,m)=[int(a) for a in input().split()]
for i in range(n):
if i:print(" ",end="")
if i<=n/2: print("0",end="")
else: print("{}".format(m),end="")
print("")
``` |
p02275 Counting Sort | Counting sort can be used for sorting elements in an array which each of the n input elements is an integer in the range 0 to k. The idea of counting sort is to determine, for each input element x, the number of elements less than x as C[x]. This information can be used to place element x directly into its position in the output array B. This scheme must be modified to handle the situation in which several elements have the same value. Please see the following pseudocode for the detail:
Counting-Sort(A, B, k)
1 for i = 0 to k
2 do C[i] = 0
3 for j = 1 to length[A]
4 do C[A[j]] = C[A[j]]+1
5 /* C[i] now contains the number of elements equal to i */
6 for i = 1 to k
7 do C[i] = C[i] + C[i-1]
8 /* C[i] now contains the number of elements less than or equal to i */
9 for j = length[A] downto 1
10 do B[C[A[j]]] = A[j]
11 C[A[j]] = C[A[j]]-1
Write a program which sorts elements of given array ascending order based on the counting sort.
Constraints
* 1 ≤ n ≤ 2,000,000
* 0 ≤ A[i] ≤ 10,000
Input
The first line of the input includes an integer n, the number of elements in the sequence.
In the second line, n elements of the sequence are given separated by spaces characters.
Output
Print the sorted sequence. Two contiguous elements of the sequence should be separated by a space character.
Example
Input
7
2 5 1 3 2 3 0
Output
0 1 2 2 3 3 5 | ```python
# 計数ソート
# https://onlinejudge.u-aizu.ac.jp/courses/lesson/1/ALDS1/6/ALDS1_6_A
# 計算量 O(n+k)
import sys
input = sys.stdin.buffer.readline
n = int(input())
A = [int(i) for i in input().split()]
B = [None] * n
C = [0] * 10001
for a in A:
C[a] += 1
for i in range(10001):
C[i] = C[i - 1] + C[i]
for j in range(n)[::-1]:
ptr = C[A[j]] - 1
B[ptr] = A[j]
C[A[j]] -= 1
print(" ".join([str(b) for b in B]))
``` |
p02422 Transformation | Transformation
Write a program which performs a sequence of commands to a given string $str$. The command is one of:
* print a b: print from the a-th character to the b-th character of $str$
* reverse a b: reverse from the a-th character to the b-th character of $str$
* replace a b p: replace from the a-th character to the b-th character of $str$ with p
Note that the indices of $str$ start with 0.
Constraints
* $1 \leq $ length of $str \leq 1000$
* $1 \leq q \leq 100$
* $0 \leq a \leq b < $ length of $str$
* for replace command, $b - a + 1 = $ length of $p$
Input
In the first line, a string $str$ is given. $str$ consists of lowercase letters. In the second line, the number of commands q is given. In the next q lines, each command is given in the above mentioned format.
Output
For each print command, print a string in a line.
Examples
Input
abcde
3
replace 1 3 xyz
reverse 0 2
print 1 4
Output
xaze
Input
xyz
3
print 0 2
replace 0 2 abc
print 0 2
Output
xyz
abc | ```python
str = input("")
q = int(input())
for i in range(q):
line = input().split()
c = line[0]
a = int(line[1])
b = int(line[2]) + 1
if c == 'replace':
str = str[:a] + line[3] + str[b:]
elif c == 'reverse':
str = str[:a] + str[a:b][::-1] + str[b:]
else:
print(str[a:b])
``` |
1011_D. Rocket | This is an interactive problem.
Natasha is going to fly to Mars. Finally, Natasha sat in the rocket. She flies, flies... but gets bored. She wishes to arrive to Mars already! So she decides to find something to occupy herself. She couldn't think of anything better to do than to calculate the distance to the red planet.
Let's define x as the distance to Mars. Unfortunately, Natasha does not know x. But it is known that 1 ≤ x ≤ m, where Natasha knows the number m. Besides, x and m are positive integers.
Natasha can ask the rocket questions. Every question is an integer y (1 ≤ y ≤ m). The correct answer to the question is -1, if x<y, 0, if x=y, and 1, if x>y. But the rocket is broken — it does not always answer correctly. Precisely: let the correct answer to the current question be equal to t, then, if the rocket answers this question correctly, then it will answer t, otherwise it will answer -t.
In addition, the rocket has a sequence p of length n. Each element of the sequence is either 0 or 1. The rocket processes this sequence in the cyclic order, that is 1-st element, 2-nd, 3-rd, …, (n-1)-th, n-th, 1-st, 2-nd, 3-rd, …, (n-1)-th, n-th, …. If the current element is 1, the rocket answers correctly, if 0 — lies. Natasha doesn't know the sequence p, but she knows its length — n.
You can ask the rocket no more than 60 questions.
Help Natasha find the distance to Mars. Assume, that the distance to Mars does not change while Natasha is asking questions.
Your solution will not be accepted, if it does not receive an answer 0 from the rocket (even if the distance to Mars is uniquely determined by the already received rocket's answers).
Input
The first line contains two integers m and n (1 ≤ m ≤ 10^9, 1 ≤ n ≤ 30) — the maximum distance to Mars and the number of elements in the sequence p.
Interaction
You can ask the rocket no more than 60 questions.
To ask a question, print a number y (1≤ y≤ m) and an end-of-line character, then do the operation flush and read the answer to the question.
If the program reads 0, then the distance is correct and you must immediately terminate the program (for example, by calling exit(0)). If you ignore this, you can get any verdict, since your program will continue to read from the closed input stream.
If at some point your program reads -2 as an answer, it must immediately end (for example, by calling exit(0)). You will receive the "Wrong answer" verdict, and this will mean that the request is incorrect or the number of requests exceeds 60. If you ignore this, you can get any verdict, since your program will continue to read from the closed input stream.
If your program's request is not a valid integer between -2^{31} and 2^{31}-1 (inclusive) without leading zeros, then you can get any verdict.
You can get "Idleness limit exceeded" if you don't print anything or if you forget to flush the output.
To flush the output buffer you can use (after printing a query and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking
Use the following format for hacking:
In the first line, print 3 integers m,n,x (1≤ x≤ m≤ 10^9, 1≤ n≤ 30) — the maximum distance to Mars, the number of elements in the sequence p and the current distance to Mars.
In the second line, enter n numbers, each of which is equal to 0 or 1 — sequence p.
The hacked solution will not have access to the number x and sequence p.
Example
Input
5 2
1
-1
-1
1
0
Output
1
2
4
5
3
Note
In the example, hacking would look like this:
5 2 3
1 0
This means that the current distance to Mars is equal to 3, Natasha knows that it does not exceed 5, and the rocket answers in order: correctly, incorrectly, correctly, incorrectly ...
Really:
on the first query (1) the correct answer is 1, the rocket answered correctly: 1;
on the second query (2) the correct answer is 1, the rocket answered incorrectly: -1;
on the third query (4) the correct answer is -1, the rocket answered correctly: -1;
on the fourth query (5) the correct answer is -1, the rocket answered incorrectly: 1;
on the fifth query (3) the correct and incorrect answer is 0. | ```python
from sys import stdin
from math import *
from sys import stdout
line = stdin.readline().rstrip().split()
m = int(line[0])
n = int(line[1])
bits = []
for i in range(n):
print(m)
stdout.flush()
line = stdin.readline().rstrip().split()
res = int(line[0])
if res == 0:
exit(0)
if res == 1:
bits.append(-1)
else:
bits.append(1)
minN = 1
maxN = m
i = 0
while True:
current = int((minN + maxN) / 2)
print(current)
stdout.flush()
line = stdin.readline().rstrip().split()
res = int(line[0])
if res == 0:
exit(0)
res *= bits[i]
i = (i+1) % n
if res == 1:
minN = current + 1
else:
maxN = current - 1
``` |
1036_E. Covered Points | You are given n segments on a Cartesian plane. Each segment's endpoints have integer coordinates. Segments can intersect with each other. No two segments lie on the same line.
Count the number of distinct points with integer coordinates, which are covered by at least one segment.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of segments.
Each of the next n lines contains four integers Ax_i, Ay_i, Bx_i, By_i (-10^6 ≤ Ax_i, Ay_i, Bx_i, By_i ≤ 10^6) — the coordinates of the endpoints A, B (A ≠ B) of the i-th segment.
It is guaranteed that no two segments lie on the same line.
Output
Print a single integer — the number of distinct points with integer coordinates, which are covered by at least one segment.
Examples
Input
9
0 0 4 4
-1 5 4 0
4 0 4 4
5 2 11 2
6 1 6 7
5 6 11 6
10 1 10 7
7 0 9 8
10 -1 11 -1
Output
42
Input
4
-1 2 1 2
-1 0 1 0
-1 0 0 3
0 3 1 0
Output
7
Note
The image for the first example:
<image>
Several key points are marked blue, the answer contains some non-marked points as well.
The image for the second example:
<image> | ```python
import sys
from math import gcd
class Segment:
def __init__(self, x1, y1, x2, y2):
self.x1 = x1
self.y1 = y1
self.x2 = x2
self.y2 = y2
def dx(self):
return self.x2 - self.x1
def dy(self):
return self.y2 - self.y1
def pt_cnt(self):
return gcd(abs(self.dx()), abs(self.dy())) + 1
def A(self):
return self.y1 - self.y2
def B(self):
return self.x2 - self.x1
def C(self):
return -self.A() * self.x1 - self.B() * self.y1
def inner_x(self, x):
l = self.x1
r = self.x2
if l > r:
l, r = r, l
return l <= x <= r
def inner_y(self, y):
l = self.y1
r = self.y2
if l > r:
l, r = r, l
return l <= y <= r
def inner(self, x, y):
return self.inner_x(x) and self.inner_y(y)
def intersect(self, other):
dx = det(self.C(), self.B(), other.C(), other.B())
dy = det(self.A(), self.C(), other.A(), other.C())
d = det(self.A(), self.B(), other.A(), other.B())
if d == 0:
return False, 0, 0
if dx % d != 0 or dy % d != 0:
return False, 0, 0
x = -dx // d
y = -dy // d
if not self.inner(x, y) or not other.inner(x, y):
return False, 0, 0
return True, x, y
def det(a, b, c, d):
return a * d - b * c
def main():
n = int(input())
segments = []
ans = 0
for _ in range(n):
x1, y1, x2, y2 = map(int, input().split())
segment = Segment(x1, y1, x2, y2)
ans += segment.pt_cnt()
pt = set()
for other in segments:
result, x, y = segment.intersect(other)
if result:
pt.add((x, y))
ans -= len(pt)
segments.append(segment)
print(ans)
if __name__ == '__main__':
main()
``` |
1059_D. Nature Reserve | There is a forest that we model as a plane and live n rare animals. Animal number i has its lair in the point (x_{i}, y_{i}). In order to protect them, a decision to build a nature reserve has been made.
The reserve must have a form of a circle containing all lairs. There is also a straight river flowing through the forest. All animals drink from this river, therefore it must have at least one common point with the reserve. On the other hand, ships constantly sail along the river, so the reserve must not have more than one common point with the river.
For convenience, scientists have made a transformation of coordinates so that the river is defined by y = 0. Check whether it is possible to build a reserve, and if possible, find the minimum possible radius of such a reserve.
Input
The first line contains one integer n (1 ≤ n ≤ 10^5) — the number of animals.
Each of the next n lines contains two integers x_{i}, y_{i} (-10^7 ≤ x_{i}, y_{i} ≤ 10^7) — the coordinates of the i-th animal's lair. It is guaranteed that y_{i} ≠ 0. No two lairs coincide.
Output
If the reserve cannot be built, print -1. Otherwise print the minimum radius. Your answer will be accepted if absolute or relative error does not exceed 10^{-6}.
Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.
Examples
Input
1
0 1
Output
0.5
Input
3
0 1
0 2
0 -3
Output
-1
Input
2
0 1
1 1
Output
0.625
Note
In the first sample it is optimal to build the reserve with the radius equal to 0.5 and the center in (0,\ 0.5).
In the second sample it is impossible to build a reserve.
In the third sample it is optimal to build the reserve with the radius equal to 5/8 and the center in (1/2,\ 5/8). | ```python
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
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")
def check(m):
r = -1
for j in range(n):
r = max(r, (x[j]-m)**2/(2*y[j])+(y[j]/2))
return r
n=int(input())
x=[]
y=[]
for j in range(n):
a,b=map(int,input().split())
x.append(a)
y.append(b)
p=0
q=0
for j in y:
if j<0:
p=1
else:
q=1
if p==1 and q==1:
print(-1)
else:
if p==1:
for j in range(n):
y[j]=abs(y[j])
l=-10**7
h=10**7
for i in range(100):
m1=(2*l+h)/3
m2=(2*h+l)/3
if check(m1)>check(m2):
l=m1
else:
h=m2
print(check(l))
``` |
10_E. Greedy Change | Billy investigates the question of applying greedy algorithm to different spheres of life. At the moment he is studying the application of greedy algorithm to the problem about change. There is an amount of n coins of different face values, and the coins of each value are not limited in number. The task is to collect the sum x with the minimum amount of coins. Greedy algorithm with each its step takes the coin of the highest face value, not exceeding x. Obviously, if among the coins' face values exists the face value 1, any sum x can be collected with the help of greedy algorithm. However, greedy algorithm does not always give the optimal representation of the sum, i.e. the representation with the minimum amount of coins. For example, if there are face values {1, 3, 4} and it is asked to collect the sum 6, greedy algorithm will represent the sum as 4 + 1 + 1, while the optimal representation is 3 + 3, containing one coin less. By the given set of face values find out if there exist such a sum x that greedy algorithm will collect in a non-optimal way. If such a sum exists, find out the smallest of these sums.
Input
The first line contains an integer n (1 ≤ n ≤ 400) — the amount of the coins' face values. The second line contains n integers ai (1 ≤ ai ≤ 109), describing the face values. It is guaranteed that a1 > a2 > ... > an and an = 1.
Output
If greedy algorithm collects any sum in an optimal way, output -1. Otherwise output the smallest sum that greedy algorithm collects in a non-optimal way.
Examples
Input
5
25 10 5 2 1
Output
-1
Input
3
4 3 1
Output
6 | ```python
__author__ = 'Darren'
def solve():
n = int(input())
coins = list(map(int, input().split()))
def greedy(amount):
num = 0
for i in range(n):
num += amount // coins[i]
amount %= coins[i]
return num
result = 1 << 31
for i in range(1, n):
for j in range(i, n):
temp = coins[i-1] - 1
count, value = 0, 0
for k in range(j+1):
c = temp // coins[k]
count += c
value += coins[k] * c
temp %= coins[k]
value += coins[j]
count += 1
if count < greedy(value):
result = min(result, value)
if result == 1 << 31:
print(-1)
else:
print(result)
if __name__ == '__main__':
solve()
``` |
1121_D. Diana and Liana | At the first holiday in spring, the town Shortriver traditionally conducts a flower festival. Townsfolk wear traditional wreaths during these festivals. Each wreath contains exactly k flowers.
The work material for the wreaths for all n citizens of Shortriver is cut from the longest flowered liana that grew in the town that year. Liana is a sequence a_1, a_2, ..., a_m, where a_i is an integer that denotes the type of flower at the position i. This year the liana is very long (m ≥ n ⋅ k), and that means every citizen will get a wreath.
Very soon the liana will be inserted into a special cutting machine in order to make work material for wreaths. The machine works in a simple manner: it cuts k flowers from the beginning of the liana, then another k flowers and so on. Each such piece of k flowers is called a workpiece. The machine works until there are less than k flowers on the liana.
Diana has found a weaving schematic for the most beautiful wreath imaginable. In order to weave it, k flowers must contain flowers of types b_1, b_2, ..., b_s, while other can be of any type. If a type appears in this sequence several times, there should be at least that many flowers of that type as the number of occurrences of this flower in the sequence. The order of the flowers in a workpiece does not matter.
Diana has a chance to remove some flowers from the liana before it is inserted into the cutting machine. She can remove flowers from any part of the liana without breaking liana into pieces. If Diana removes too many flowers, it may happen so that some of the citizens do not get a wreath. Could some flowers be removed from the liana so that at least one workpiece would conform to the schematic and machine would still be able to create at least n workpieces?
Input
The first line contains four integers m, k, n and s (1 ≤ n, k, m ≤ 5 ⋅ 10^5, k ⋅ n ≤ m, 1 ≤ s ≤ k): the number of flowers on the liana, the number of flowers in one wreath, the amount of citizens and the length of Diana's flower sequence respectively.
The second line contains m integers a_1, a_2, ..., a_m (1 ≤ a_i ≤ 5 ⋅ 10^5) — types of flowers on the liana.
The third line contains s integers b_1, b_2, ..., b_s (1 ≤ b_i ≤ 5 ⋅ 10^5) — the sequence in Diana's schematic.
Output
If it's impossible to remove some of the flowers so that there would be at least n workpieces and at least one of them fullfills Diana's schematic requirements, output -1.
Otherwise in the first line output one integer d — the number of flowers to be removed by Diana.
In the next line output d different integers — the positions of the flowers to be removed.
If there are multiple answers, print any.
Examples
Input
7 3 2 2
1 2 3 3 2 1 2
2 2
Output
1
4
Input
13 4 3 3
3 2 6 4 1 4 4 7 1 3 3 2 4
4 3 4
Output
-1
Input
13 4 1 3
3 2 6 4 1 4 4 7 1 3 3 2 4
4 3 4
Output
9
1 2 3 4 5 9 11 12 13
Note
In the first example, if you don't remove any flowers, the machine would put out two workpieces with flower types [1, 2, 3] and [3, 2, 1]. Those workpieces don't fit Diana's schematic. But if you remove flower on 4-th place, the machine would output workpieces [1, 2, 3] and [2, 1, 2]. The second workpiece fits Diana's schematic.
In the second example there is no way to remove flowers so that every citizen gets a wreath and Diana gets a workpiece that fits here schematic.
In the third example Diana is the only citizen of the town and that means she can, for example, just remove all flowers except the ones she needs. | ```python
def main():
m, k, n, s = map(int, input().split())
a = list(map(int, input().split())) # prevbug: input in a line!
b = list(map(int, input().split())) # prevbug: convert to list
b_dict = {}
for x in b:
b_dict.setdefault(x, 0)
b_dict[x] += 1 # prevbug: b or b_dict
left = 0
right = 0
max_cut = m - n * k
condition_not_met = len(b_dict)
a_dict = {}
while right < m and condition_not_met > 0:
x = a[right]
a_dict.setdefault(x, 0)
a_dict[x] += 1
if x in b_dict and a_dict[x] == b_dict[x]:
condition_not_met -= 1
right += 1 # prevbug: ftl
if condition_not_met > 0:
print(-1)
return
def num_to_remove(lft, rgt):
lft = lft // k * k
num_in_seq = rgt - lft
if num_in_seq < k:
return 0 # prevbug: if sequence is shorter than k, then no need to remove flowers
return num_in_seq - k
def test_plan():
nonlocal left
if num_to_remove(left, right) <= max_cut:
tot = num_to_remove(left, right)
print(tot)
left = left // k * k
while tot > 0:
x = a[left]
if x in b_dict:
b_dict[x] -= 1
if b_dict[x] == 0:
del b_dict[x]
else:
print(left + 1, end=' ')
tot -= 1 # prevbug: ftl
left += 1
return True
return False
while True:
while left < right: # prevbug: should shift left before shifting right
x = a[left]
if x in b_dict and a_dict[x] - 1 < b_dict[x]:
break
else:
a_dict[x] -= 1
if a_dict[x] == 0:
del a_dict[x] # prevbug: ftl
left += 1
if test_plan():
return
if right < m:
a_dict.setdefault(a[right], 0)
a_dict[a[right]] += 1
right += 1
else:
break
print(-1)
if __name__ == '__main__':
main()
``` |
116_C. Party | A company has n employees numbered from 1 to n. Each employee either has no immediate manager or exactly one immediate manager, who is another employee with a different number. An employee A is said to be the superior of another employee B if at least one of the following is true:
* Employee A is the immediate manager of employee B
* Employee B has an immediate manager employee C such that employee A is the superior of employee C.
The company will not have a managerial cycle. That is, there will not exist an employee who is the superior of his/her own immediate manager.
Today the company is going to arrange a party. This involves dividing all n employees into several groups: every employee must belong to exactly one group. Furthermore, within any single group, there must not be two employees A and B such that A is the superior of B.
What is the minimum number of groups that must be formed?
Input
The first line contains integer n (1 ≤ n ≤ 2000) — the number of employees.
The next n lines contain the integers pi (1 ≤ pi ≤ n or pi = -1). Every pi denotes the immediate manager for the i-th employee. If pi is -1, that means that the i-th employee does not have an immediate manager.
It is guaranteed, that no employee will be the immediate manager of him/herself (pi ≠ i). Also, there will be no managerial cycles.
Output
Print a single integer denoting the minimum number of groups that will be formed in the party.
Examples
Input
5
-1
1
2
1
-1
Output
3
Note
For the first example, three groups are sufficient, for example:
* Employee 1
* Employees 2 and 4
* Employees 3 and 5 | ```python
def findDepth(a, i):
depth = 1
nextLevel = a[i][:]
while len(nextLevel) > 0:
depth += 1
children = nextLevel[:]
nextLevel = []
for child in children:
nextLevel += a[child]
return depth
n = int(input())
a = []
for i in range(n):
a.append([])
roots = []
for i in range(n):
x = int(input())
if x > 0:
a[x-1].append(i)
else:
roots.append(i)
print(max([findDepth(a, i) for i in roots]))
``` |
1188_B. Count Pairs | You are given a prime number p, n integers a_1, a_2, …, a_n, and an integer k.
Find the number of pairs of indexes (i, j) (1 ≤ i < j ≤ n) for which (a_i + a_j)(a_i^2 + a_j^2) ≡ k mod p.
Input
The first line contains integers n, p, k (2 ≤ n ≤ 3 ⋅ 10^5, 2 ≤ p ≤ 10^9, 0 ≤ k ≤ p-1). p is guaranteed to be prime.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ p-1). It is guaranteed that all elements are different.
Output
Output a single integer — answer to the problem.
Examples
Input
3 3 0
0 1 2
Output
1
Input
6 7 2
1 2 3 4 5 6
Output
3
Note
In the first example:
(0+1)(0^2 + 1^2) = 1 ≡ 1 mod 3.
(0+2)(0^2 + 2^2) = 8 ≡ 2 mod 3.
(1+2)(1^2 + 2^2) = 15 ≡ 0 mod 3.
So only 1 pair satisfies the condition.
In the second example, there are 3 such pairs: (1, 5), (2, 3), (4, 6). | ```python
def check(num1, num2, p, k):
v = num1 + num2
v *= num1 * num1 + num2 * num2
v %= p
v += p
v %= p
return v == k % p
if __name__ == '__main__':
n, p, k = (int(x) for x in input().split())
idx___number = [int(x) for x in input().split()]
idx___precount = [((pow(x, 4, p) - k * x) % p + p) % p for x in idx___number]
met_precount___vals = {}
ans = 0
for number, precount in zip(idx___number[::-1], idx___precount[::-1]):
if precount not in met_precount___vals:
met_precount___vals[precount] = []
else:
for val in met_precount___vals[precount]:
if check(number, val, p, k):
ans += 1
met_precount___vals[precount].append(number)
print(ans)
``` |
1207_C. Gas Pipeline | You are responsible for installing a gas pipeline along a road. Let's consider the road (for simplicity) as a segment [0, n] on OX axis. The road can have several crossroads, but for simplicity, we'll denote each crossroad as an interval (x, x + 1) with integer x. So we can represent the road as a binary string consisting of n characters, where character 0 means that current interval doesn't contain a crossroad, and 1 means that there is a crossroad.
Usually, we can install the pipeline along the road on height of 1 unit with supporting pillars in each integer point (so, if we are responsible for [0, n] road, we must install n + 1 pillars). But on crossroads we should lift the pipeline up to the height 2, so the pipeline won't obstruct the way for cars.
We can do so inserting several zig-zag-like lines. Each zig-zag can be represented as a segment [x, x + 1] with integer x consisting of three parts: 0.5 units of horizontal pipe + 1 unit of vertical pipe + 0.5 of horizontal. Note that if pipeline is currently on height 2, the pillars that support it should also have length equal to 2 units.
<image>
Each unit of gas pipeline costs us a bourles, and each unit of pillar — b bourles. So, it's not always optimal to make the whole pipeline on the height 2. Find the shape of the pipeline with minimum possible cost and calculate that cost.
Note that you must start and finish the pipeline on height 1 and, also, it's guaranteed that the first and last characters of the input string are equal to 0.
Input
The fist line contains one integer T (1 ≤ T ≤ 100) — the number of queries. Next 2 ⋅ T lines contain independent queries — one query per two lines.
The first line contains three integers n, a, b (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ a ≤ 10^8, 1 ≤ b ≤ 10^8) — the length of the road, the cost of one unit of the pipeline and the cost of one unit of the pillar, respectively.
The second line contains binary string s (|s| = n, s_i ∈ \{0, 1\}, s_1 = s_n = 0) — the description of the road.
It's guaranteed that the total length of all strings s doesn't exceed 2 ⋅ 10^5.
Output
Print T integers — one per query. For each query print the minimum possible cost of the constructed pipeline.
Example
Input
4
8 2 5
00110010
8 1 1
00110010
9 100000000 100000000
010101010
2 5 1
00
Output
94
25
2900000000
13
Note
The optimal pipeline for the first query is shown at the picture above.
The optimal pipeline for the second query is pictured below:
<image>
The optimal (and the only possible) pipeline for the third query is shown below:
<image>
The optimal pipeline for the fourth query is shown below:
<image> | ```python
import math
t = int(input())
for _ in range(t):
(n, a, b) = [int(x) for x in input().split()]
s = input()
#print((n, a, b, s))
gap = math.ceil((2 * a) / b) + 1
#print((a, b, gap))
cost = b
state = 0
b2 = 2 * b
streak0 = 0
for i in range(n-1):
if s[i] == '1':
streak0 = 0
else:
streak0 += 1
if s[i+1] == '1':
if streak0 >= gap and state:
cost -= (streak0 - 1) * b
cost += 2 * a
#print('down\nup')
if not state:
state = 1
cost += a
#print('up')
cost += a + b
if state:
cost += b
#print(streak0, state, gap, s[i+1])
#print(str(i) + ' ' + str(cost))
cost += a + b
streak0 += 1
if state:
cost -= (streak0-1) * b
cost += a
#print('down')
print(cost)
``` |
1225_D. Power Products | You are given n positive integers a_1, …, a_n, and an integer k ≥ 2. Count the number of pairs i, j such that 1 ≤ i < j ≤ n, and there exists an integer x such that a_i ⋅ a_j = x^k.
Input
The first line contains two integers n and k (2 ≤ n ≤ 10^5, 2 ≤ k ≤ 100).
The second line contains n integers a_1, …, a_n (1 ≤ a_i ≤ 10^5).
Output
Print a single integer — the number of suitable pairs.
Example
Input
6 3
1 3 9 8 24 1
Output
5
Note
In the sample case, the suitable pairs are:
* a_1 ⋅ a_4 = 8 = 2^3;
* a_1 ⋅ a_6 = 1 = 1^3;
* a_2 ⋅ a_3 = 27 = 3^3;
* a_3 ⋅ a_5 = 216 = 6^3;
* a_4 ⋅ a_6 = 8 = 2^3. | ```python
from collections import defaultdict
import sys as _sys
def main():
n, k = _read_ints()
a = tuple(_read_ints())
result = find_good_pairs_n(a, k)
print(result)
def _read_line():
result = _sys.stdin.readline()
assert result[-1] == "\n"
return result[:-1]
def _read_ints():
return map(int, _read_line().split())
def find_good_pairs_n(sequence, k):
sequence = tuple(sequence)
factors_seq = tuple(map(_find_prime_factors, sequence))
factors_seq = map(
lambda factors: map(lambda kv: (kv[0], kv[1] % k), factors.items()),
factors_seq
)
factors_seq = map(
lambda factors: filter(lambda kv: kv[1] > 0, factors),
factors_seq
)
factors_seq = map(sorted, factors_seq)
factors_seq = tuple(map(tuple, factors_seq))
counter = defaultdict(int)
for factors in factors_seq:
counter[factors] += 1
result = 0
for factors in factors_seq:
necessary_factors = tuple((factor, k - amount) for factor, amount in factors)
result += counter[necessary_factors]
if factors == necessary_factors:
result -= 1
assert result % 2 == 0
result //= 2
return result
def _find_prime_factors(x):
result = dict()
if x % 2 == 0:
factor_2_n = 0
while x & 1 == 0:
x >>= 1
factor_2_n += 1
result[2] = factor_2_n
factor = 3
while x != 1 and factor * factor <= x:
if x % factor == 0:
factor_n = 0
while x % factor == 0:
x //= factor
factor_n += 1
result[factor] = factor_n
factor += 2
if x != 1:
result[x] = 1
return result
if __name__ == '__main__':
main()
``` |
1249_F. Maximum Weight Subset | You are given a tree, which consists of n vertices. Recall that a tree is a connected undirected graph without cycles.
<image> Example of a tree.
Vertices are numbered from 1 to n. All vertices have weights, the weight of the vertex v is a_v.
Recall that the distance between two vertices in the tree is the number of edges on a simple path between them.
Your task is to find the subset of vertices with the maximum total weight (the weight of the subset is the sum of weights of all vertices in it) such that there is no pair of vertices with the distance k or less between them in this subset.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 200) — the number of vertices in the tree and the distance restriction, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5), where a_i is the weight of the vertex i.
The next n - 1 lines contain edges of the tree. Edge i is denoted by two integers u_i and v_i — the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i).
It is guaranteed that the given edges form a tree.
Output
Print one integer — the maximum total weight of the subset in which all pairs of vertices have distance more than k.
Examples
Input
5 1
1 2 3 4 5
1 2
2 3
3 4
3 5
Output
11
Input
7 2
2 1 2 1 2 1 1
6 4
1 5
3 1
2 3
7 5
7 4
Output
4 | ```python
n, k = map(int, input().split())
a = list(map(int, input().split()))
g = {}
def dfs(v, p=-1):
c = [dfs(child, v) for child in g.get(v, set()) - {p}]
c.sort(key=len, reverse=True)
r = []
i = 0
while c:
if i >= len(c[-1]):
c.pop()
else:
o = max(i, k - i - 1)
s = q = 0
for x in c:
if len(x) <= o:
q = max(q, x[i])
else:
s += x[o]
q = max(q, x[i] - x[o])
r.append(q + s)
i += 1
r.append(0)
for i in range(len(r) - 1, 0, -1):
r[i - 1] = max(r[i - 1], r[i])
while len(r) > 1 and r[-2] == 0:
r.pop()
o = (r[k] if k < len(r) else 0) + a[v]
r.insert(0, max(o, r[0]))
return r
for _ in range(1, n):
u, v = map(lambda x: int(x) - 1, input().split())
g.setdefault(u, set()).add(v)
g.setdefault(v, set()).add(u)
print(dfs(0)[0])
``` |
1268_C. K Integers | You are given a permutation p_1, p_2, …, p_n.
In one move you can swap two adjacent values.
You want to perform a minimum number of moves, such that in the end there will exist a subsegment 1,2,…, k, in other words in the end there should be an integer i, 1 ≤ i ≤ n-k+1 such that p_i = 1, p_{i+1} = 2, …, p_{i+k-1}=k.
Let f(k) be the minimum number of moves that you need to make a subsegment with values 1,2,…,k appear in the permutation.
You need to find f(1), f(2), …, f(n).
Input
The first line of input contains one integer n (1 ≤ n ≤ 200 000): the number of elements in the permutation.
The next line of input contains n integers p_1, p_2, …, p_n: given permutation (1 ≤ p_i ≤ n).
Output
Print n integers, the minimum number of moves that you need to make a subsegment with values 1,2,…,k appear in the permutation, for k=1, 2, …, n.
Examples
Input
5
5 4 3 2 1
Output
0 1 3 6 10
Input
3
1 2 3
Output
0 0 0 | ```python
import sys
input = sys.stdin.buffer.readline
# all operations are log(n)
class bit:
def __init__(self, n):
self.n = n+1
self.mx_p = 0
while 1 << self.mx_p < self.n:
self.mx_p += 1
self.a = [0]*(self.n)
self.tot = 0
def add(self, idx, val):
self.tot += val
idx += 1
while idx < self.n:
self.a[idx] += val
idx += idx & -idx
def sum_prefix(self, idx):
tot = 0
idx += 1
while idx > 0:
tot += self.a[idx]
idx -= idx & -idx
return tot
def sum(self, l, r):
return self.sum_prefix(r) - self.sum_prefix(l-1)
# lowest idx such that sum_prefix(idx) = val else -1 if idx doesn't exist
# idx is the idx in the underlying array (idx-1)
def lower(self, val):
if val > self.tot:
return -1
tot = 0
idx = 0
for i in range(self.mx_p, -1, -1):
if idx + (1<<i) < self.n and tot + self.a[idx + (1 << i)] < val:
tot += self.a[idx + (1 << i)]
idx += 1 << i
return idx
n = int(input())
p = list(map(int,input().split()))
p = sorted([[p[i],i] for i in range(n)])
ones = bit(n+1) # 1 at positions
ones_idx = bit(n+1) # indices at positions
inversions = 0
for k in range(1,n+1):
val, i = p[k-1]
ones.add(i,1)
ones_idx.add(i,i)
inversions += ones.sum(i+1,n)
num1l = (k+1)//2
num1r = k - num1l
idxl = ones.lower((k+1)//2)
idxr = idxl + 1
num0l = idxl+1 - num1l
num0r = n - idxr - num1r
suml = ones_idx.sum_prefix(idxl)
sumr = ones_idx.tot - suml
movel = idxl*(idxl+1)//2 - suml - (num0l - 1)*(num0l)//2
mover = (n-1-idxr)*(n-1-idxr+1)//2 - (num1r*(n-1) - sumr) - (num0r-1)*(num0r)//2
print(inversions + movel + mover)
``` |
1333_C. Eugene and an array | Eugene likes working with arrays. And today he needs your help in solving one challenging task.
An array c is a subarray of an array b if c can be obtained from b by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Let's call a nonempty array good if for every nonempty subarray of this array, sum of the elements of this subarray is nonzero. For example, array [-1, 2, -3] is good, as all arrays [-1], [-1, 2], [-1, 2, -3], [2], [2, -3], [-3] have nonzero sums of elements. However, array [-1, 2, -1, -3] isn't good, as his subarray [-1, 2, -1] has sum of elements equal to 0.
Help Eugene to calculate the number of nonempty good subarrays of a given array a.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 2 × 10^5) — the length of array a.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of a.
Output
Output a single integer — the number of good subarrays of a.
Examples
Input
3
1 2 -3
Output
5
Input
3
41 -41 41
Output
3
Note
In the first sample, the following subarrays are good: [1], [1, 2], [2], [2, -3], [-3]. However, the subarray [1, 2, -3] isn't good, as its subarray [1, 2, -3] has sum of elements equal to 0.
In the second sample, three subarrays of size 1 are the only good subarrays. At the same time, the subarray [41, -41, 41] isn't good, as its subarray [41, -41] has sum of elements equal to 0. | ```python
import sys
import heapq
def input():
return sys.stdin.readline().strip()
def iinput():
return int(input())
def rinput():
return map(int, input().split())
def rlinput():
return list(map(int, input().split()))
def YES(flag):
if flag:
return "YES"
return "NO"
def main():
#n = int(sys.stdin.readline().strip())
n = iinput()
q = rlinput()
cl, p, res, con = dict(), [q[0] for i in range(n + 5)], 0, 0
cl[0] = 1
for i in range(1, n):
p[i] = p[i - 1] + q[i]
for i in range(n):
if p[i] in cl:
con = max(con, cl[p[i]])
cl[p[i]] = i + 2
res += (i - con) * (q[i] != 0)
print(res + n - q.count(0))
for i in range(1):
main()
``` |
1353_F. Decreasing Heights | You are playing one famous sandbox game with the three-dimensional world. The map of the world can be represented as a matrix of size n × m, where the height of the cell (i, j) is a_{i, j}.
You are in the cell (1, 1) right now and want to get in the cell (n, m). You can move only down (from the cell (i, j) to the cell (i + 1, j)) or right (from the cell (i, j) to the cell (i, j + 1)). There is an additional restriction: if the height of the current cell is x then you can move only to the cell with height x+1.
Before the first move you can perform several operations. During one operation, you can decrease the height of any cell by one. I.e. you choose some cell (i, j) and assign (set) a_{i, j} := a_{i, j} - 1. Note that you can make heights less than or equal to zero. Also note that you can decrease the height of the cell (1, 1).
Your task is to find the minimum number of operations you have to perform to obtain at least one suitable path from the cell (1, 1) to the cell (n, m). It is guaranteed that the answer exists.
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, m ≤ 100) — the number of rows and the number of columns in the map of the world. The next n lines contain m integers each, where the j-th integer in the i-th line is a_{i, j} (1 ≤ a_{i, j} ≤ 10^{15}) — the height of the cell (i, j).
It is guaranteed that the sum of n (as well as the sum of m) over all test cases does not exceed 100 (∑ n ≤ 100; ∑ m ≤ 100).
Output
For each test case, print the answer — the minimum number of operations you have to perform to obtain at least one suitable path from the cell (1, 1) to the cell (n, m). It is guaranteed that the answer exists.
Example
Input
5
3 4
1 2 3 4
5 6 7 8
9 10 11 12
5 5
2 5 4 8 3
9 10 11 5 1
12 8 4 2 5
2 2 5 4 1
6 8 2 4 2
2 2
100 10
10 1
1 2
123456789876543 987654321234567
1 1
42
Output
9
49
111
864197531358023
0 | ```python
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n,m=map(int,input().split())
a=[ [int(x) for x in input().split()] for _ in range(n)]
if m>n:
b=[ [a[j][i] for j in range(n)] for i in range(m)]
a=b
n,m=m,n
# print(a,n,m)
for i in range(n):
for j in range(m):
a[i][j]-=i+j
# print(a)
# print(d)
from collections import defaultdict
pvr=[defaultdict(lambda: 1<<67) for _ in range(m)]
# print(a)
for i in range(n):
cur=[defaultdict(lambda: 1<<67) for _ in range(m)]
for j in range(m):
if i==0:
cur[0][a[0][0]]=0
if i:
for k,v in pvr[j].items():
if k<=a[i][j]:
cur[j][k]=min(cur[j][k],v+a[i][j]-k)
else:
cur[j][a[i][j]]=min(cur[j][a[i][j]],v+(k-a[i][j])*(i+j))
if j:
for k,v in cur[j-1].items():
if k<=a[i][j]:
cur[j][k]=min(cur[j][k],v+a[i][j]-k)
else:
cur[j][a[i][j]]=min(cur[j][a[i][j]],v+(k-a[i][j])*(i+j))
# print(i,j,cur[j])
pvr=cur
ans=1<<63
for k,v in pvr[-1].items():
# print("kv",k,v)
ans=min(ans,v)
print(ans)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
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")
# endregion
if __name__ == "__main__":
main()
``` |
1373_E. Sum of Digits | Let f(x) be the sum of digits of a decimal number x.
Find the smallest non-negative integer x such that f(x) + f(x + 1) + ... + f(x + k) = n.
Input
The first line contains one integer t (1 ≤ t ≤ 150) — the number of test cases.
Each test case consists of one line containing two integers n and k (1 ≤ n ≤ 150, 0 ≤ k ≤ 9).
Output
For each test case, print one integer without leading zeroes. If there is no such x that f(x) + f(x + 1) + ... + f(x + k) = n, print -1; otherwise, print the minimum x meeting that constraint.
Example
Input
7
1 0
1 1
42 7
13 7
99 1
99 0
99 2
Output
1
0
4
-1
599998
99999999999
7997 | ```python
def generate_prefix(su):
pre = ""
if su >= 8:
pre += '8'
su -= 8
if len(pre) > 0:
nu = 9
else:
nu = 8
while su > 0:
while su >= nu:
su -= nu
pre += str(nu)
nu -= 1
pre = pre[::-1]
return pre
def get_number(su, nines, d, k):
last_digit_sum = 0
with_zeros = 0
with_nines = 0
for i in range(k + 1):
if d + i < 10:
last_digit_sum += d + i
with_nines += 1
else:
last_digit_sum += (d + i) % 10
with_zeros += 1
# assume prefix of to be prefix
# k * prefix + with_zeros[for carry] + (nines * 9) * with_nines + 000000 * with_zeros + last_digit_sum = su
# this is the sum of values in prefix.
# we generate the smallest prefix with 9 not in the end.
su -= with_zeros \
+ last_digit_sum \
+ nines * 9 * with_nines
if su < 0 or su % (k + 1) != 0:
return ""
su //= k + 1
prefix = generate_prefix(su)
if prefix == '0':
prefix = ''
ret = (prefix + '9' * nines + str(d))
return ret
for _ in range(int(input())):
su, k = map(int, input().split())
fans = 1e20
for d in range(10):
for nines in range(0, 64):
this_ans = get_number(su, nines, d, k)
if this_ans == "":
continue
else:
if int(this_ans) < int(fans):
fans = this_ans
if fans == 1e20:
print(-1)
else:
print(fans)
``` |
1420_A. Cubes Sorting | For god's sake, you're boxes with legs! It is literally your only purpose! Walking onto buttons! How can you not do the one thing you were designed for?
Oh, that's funny, is it? Oh it's funny? Because we've been at this for twelve hours and you haven't solved it either, so I don't know why you're laughing. You've got one hour! Solve it!
Wheatley decided to try to make a test chamber. He made a nice test chamber, but there was only one detail absent — cubes.
For completing the chamber Wheatley needs n cubes. i-th cube has a volume a_i.
Wheatley has to place cubes in such a way that they would be sorted in a non-decreasing order by their volume. Formally, for each i>1, a_{i-1} ≤ a_i must hold.
To achieve his goal, Wheatley can exchange two neighbouring cubes. It means that for any i>1 you can exchange cubes on positions i-1 and i.
But there is a problem: Wheatley is very impatient. If Wheatley needs more than (n ⋅ (n-1))/(2)-1 exchange operations, he won't do this boring work.
Wheatly wants to know: can cubes be sorted under this conditions?
Input
Each test contains multiple test cases.
The first line contains one positive integer t (1 ≤ t ≤ 1000), denoting the number of test cases. Description of the test cases follows.
The first line of each test case contains one positive integer n (2 ≤ n ≤ 5 ⋅ 10^4) — number of cubes.
The second line contains n positive integers a_i (1 ≤ a_i ≤ 10^9) — volumes of cubes.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print a word in a single line: "YES" (without quotation marks) if the cubes can be sorted and "NO" (without quotation marks) otherwise.
Example
Input
3
5
5 3 2 1 4
6
2 2 2 2 2 2
2
2 1
Output
YES
YES
NO
Note
In the first test case it is possible to sort all the cubes in 7 exchanges.
In the second test case the cubes are already sorted.
In the third test case we can make 0 exchanges, but the cubes are not sorted yet, so the answer is "NO". | ```python
import sys
import bisect
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().rstrip().split())
inl = lambda: list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
t = ini()
for _ in range(t):
n = ini()
a = inl()
if len(set(a)) == n and a == sorted(a, reverse=True):
print("NO")
else:
print("YES")
``` |
1463_E. Plan of Lectures | Ivan is a programming teacher. During the academic year, he plans to give n lectures on n different topics. Each topic should be used in exactly one lecture. Ivan wants to choose which topic will he explain during the 1-st, 2-nd, ..., n-th lecture — formally, he wants to choose some permutation of integers from 1 to n (let's call this permutation q). q_i is the index of the topic Ivan will explain during the i-th lecture.
For each topic (except exactly one), there exists a prerequisite topic (for the topic i, the prerequisite topic is p_i). Ivan cannot give a lecture on a topic before giving a lecture on its prerequisite topic. There exists at least one valid ordering of topics according to these prerequisite constraints.
Ordering the topics correctly can help students understand the lectures better. Ivan has k special pairs of topics (x_i, y_i) such that he knows that the students will understand the y_i-th topic better if the lecture on it is conducted right after the lecture on the x_i-th topic. Ivan wants to satisfy the constraints on every such pair, that is, for every i ∈ [1, k], there should exist some j ∈ [1, n - 1] such that q_j = x_i and q_{j + 1} = y_i.
Now Ivan wants to know if there exists an ordering of topics that satisfies all these constraints, and if at least one exists, find any of them.
Input
The first line contains two integers n and k (2 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ k ≤ n - 1) — the number of topics and the number of special pairs of topics, respectively.
The second line contains n integers p_1, p_2, ..., p_n (0 ≤ p_i ≤ n), where p_i is the prerequisite topic for the topic i (or p_i = 0 if the i-th topic has no prerequisite topics). Exactly one of these integers is 0. At least one ordering of topics such that for every i the p_i-th topic is placed before the i-th topic exists.
Then k lines follow, the i-th line contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n; x_i ≠ y_i) — the topics from the i-th special pair. All values of x_i are pairwise distinct; similarly, all valus of y_i are pairwise distinct.
Output
If there is no ordering of topics meeting all the constraints, print 0.
Otherwise, print n pairwise distinct integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — the ordering of topics meeting all of the constraints. If there are multiple answers, print any of them.
Examples
Input
5 2
2 3 0 5 3
1 5
5 4
Output
3 2 1 5 4
Input
5 2
2 3 0 5 3
1 5
5 1
Output
0
Input
5 1
2 3 0 5 3
4 5
Output
0
Input
5 4
2 3 0 5 3
2 1
3 5
5 2
1 4
Output
3 5 2 1 4 | ```python
class Node:
def __init__(self, value):
self.value = value
self.next = None
self.prev = None
def __repr__(self):
if not self:
return "{}()".format(self.__class__.__name__)
return "{}({})".format(self.__class__.__name__, self.value)
class LL:
def __init__(self, iterable=None):
self.sentinel = Node(None)
self.sentinel.next = self.sentinel
self.sentinel.prev = self.sentinel
self.__len = 0
if iterable is not None:
self += iterable
def get_node(self, index):
node = sentinel = self.sentinel
i = 0
while i <= index:
node = node.next
if node == sentinel:
break
i += 1
if node == sentinel:
node = None
return node
def __getitem__(self, index):
node = self.get_node(index)
return node.value
def __len__(self):
return self.__len
def __setitem__(self, index, value):
node = self.get_node(index)
node.value = value
def __delitem__(self, index):
node = self.get_node(index)
if node:
node.prev.next = node.next
if node.next:
node.next.prev = node.prev
node.prev = None
node.next = None
node.value = None
self.__len -= 1
def __repr__(self):
return str(self.to_list())
def to_list(self):
l = []
c = self.sentinel.next
while c != self.sentinel:
l.append(c.value)
c = c.next
return l
def append(self, value):
sentinel = self.sentinel
node = Node(value)
self.insert_between(node, sentinel.prev, sentinel)
def appendleft(self, value):
sentinel = self.sentinel
node = Node(value)
self.insert_between(node, sentinel, sentinel.next)
def insert(self, index, value):
sentinel = self.sentinel
new_node = Node(value)
len_ = len(self)
if len_ == 0:
self.insert_between(new_node, sentinel, sentinel)
elif index >= 0 and index < len_:
node = self.get_node(index)
self.insert_between(new_node, node.prev, node)
elif index == len_:
self.insert_between(new_node, sentinel.prev, sentinel)
else:
raise IndexError
self.__len += 1
def insert_between(self, node, left_node, right_node):
if node and left_node and right_node:
node.prev = left_node
node.next = right_node
left_node.next = node
right_node.prev = node
else:
raise IndexError
def merge_left(self, other):
sentinel = self.sentinel
sentinel.next.prev = other.sentinel.prev
other.sentinel.prev.next = sentinel.next
sentinel.next = other.sentinel.next
sentinel.next.prev = sentinel
def merge_right(self, other):
sentinel = self.sentinel
sentinel.prev.next = other.sentinel.next
other.sentinel.next.prev = sentinel.prev
sentinel.prev = other.sentinel.prev
sentinel.prev.next = sentinel
import sys,io,os
#Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
Z=sys.stdin.readline
Y=lambda:map(int,Z().split())
X=lambda:print(0)or quit()
from collections import deque
def path(R):
H=deque()
H.append(R)
while P[R]>=0:
R=P[R]
H.append(R)
if len(H)>2:
P[H.popleft()]=H[-1]
return R
N,k=Y()
p=[*Y()]
K=[-1]*N
P=[-1]*(N//2)
S=[1]*(N//2)
ch=[]
R=0
for _ in range(k):
a,b=Y()
a-=1
b-=1
if K[a]>=0:
if K[b]>=0:
va,vb=path(K[a]),path(K[b])
if va!=vb:
sa,sb=S[va],S[vb]
if sa>sb:
P[vb]=va
ch[va].merge_right(ch[vb])
ch[vb]=0
else:
P[va]=vb
ch[vb].merge_left(ch[va])
ch[va]=0
if sa==sb:
S[vb]+=1
else:X()#
else:
va=path(K[a])
K[b]=va
ch[va].append(b)
else:
if K[b]>=0:
vb=path(K[b])
K[a]=vb
ch[vb].appendleft(a)
else:
K[a]=R
K[b]=R
R+=1
l=LL()
l.append(a)
l.append(b)
ch.append(l)
f=[[]for i in range(N)]
x=[-1]*N
h=[0]*N
u=set()
for z in ch:
if z!=0:
c=z.sentinel.next
i=0
while c!=z.sentinel:
x[c.value]=i
i+=1
c=c.next
for i in range(N):
a,b=p[i]-1,i
va,vb=a,b
if a<0:
z=b
continue
if K[a]>=0:
va=ch[path(K[a])][0]
if K[b]>=0:
vb=ch[path(K[b])][0]
if va==vb:
if x[a]>x[b]:X()#
else:
if(va,vb)not in u:
f[va].append(vb)
h[vb]+=1
u.add((va,vb))
q=[z]
o=[]
u=set()
while q:
v=q.pop()
if v in u:X()#
u.add(v)
if x[v]>=0:
o+=ch[path(K[v])].to_list()
else:
o.append(v)
for i in f[v]:
h[i]-=1
if h[i]<1:
q.append(i)
if len(o)<N:X()#
print(' '.join(map(lambda i:str(i+1),o)))
'''
import itertools,random,math
for i in range(1000):
N=8
p=[0]*N
s=list(range(N))
z=random.randint(0,N-1)
s.remove(z)
t=N-1
q=[z]
while t:
vq=q.pop()
v=t+1-math.ceil(random.randint(1,t*t)**.5)
for i in range(v):
x=random.choice(s)
s.remove(x)
q.append(x)
p[x]=vq+1
t-=v
a=list(range(N))
b=list(range(N))
edges=[]
k=random.randint(1,N-1)
rs=0
while len(edges)<1 or rs<k:
va=random.choice(a)
a.remove(va)
vb=random.choice(b)
b.remove(vb)
if va!=vb:
edges.append((va+1,vb+1))
rs+=1
inp=(N,len(edges),p,edges)
res=sol(*inp)
if res==0:
for x in itertools.permutations(list(range(N))):
works=True
for a,b in edges:
if x.index(b-1)-x.index(a-1)!=1:
works=False
break
if works:
for i in range(N):
if p[i] and x.index(p[i]-1)>x.index(i):
works=False
break
if works:
print(inp,x)
break
else:
works=True
for a,b in edges:
if res.index(b-1)-res.index(a-1)!=1:
works=False
break
for i in range(N):
if p[i] and res.index(p[i]-1)>res.index(i):
works=False
break
if not works:
print(inp,res)
break
'''
``` |
148_E. Porcelain | During her tantrums the princess usually smashes some collectable porcelain. Every furious shriek is accompanied with one item smashed.
The collection of porcelain is arranged neatly on n shelves. Within each shelf the items are placed in one row, so that one can access only the outermost items — the leftmost or the rightmost item, not the ones in the middle of the shelf. Once an item is taken, the next item on that side of the shelf can be accessed (see example). Once an item is taken, it can't be returned to the shelves.
You are given the values of all items. Your task is to find the maximal damage the princess' tantrum of m shrieks can inflict on the collection of porcelain.
Input
The first line of input data contains two integers n (1 ≤ n ≤ 100) and m (1 ≤ m ≤ 10000). The next n lines contain the values of the items on the shelves: the first number gives the number of items on this shelf (an integer between 1 and 100, inclusive), followed by the values of the items (integers between 1 and 100, inclusive), in the order in which they appear on the shelf (the first number corresponds to the leftmost item, the last one — to the rightmost one). The total number of items is guaranteed to be at least m.
Output
Output the maximal total value of a tantrum of m shrieks.
Examples
Input
2 3
3 3 7 2
3 4 1 5
Output
15
Input
1 3
4 4 3 1 2
Output
9
Note
In the first case there are two shelves, each with three items. To maximize the total value of the items chosen, one can take two items from the left side of the first shelf and one item from the right side of the second shelf.
In the second case there is only one shelf, so all three items are taken from it — two from the left side and one from the right side. | ```python
#!/usr/bin/env python3
import os
import sys
from io import BytesIO, IOBase
class FastO:
def __init__(self, fd=1):
stream = BytesIO()
self.flush = lambda: os.write(fd, stream.getvalue()) and not stream.truncate(0) and stream.seek(0)
self.write = lambda b: stream.write(b.encode())
class ostream:
def __lshift__(self, a):
sys.stdout.write(str(a))
return self
sys.stdout, cout = FastO(), ostream()
numbers, num, sign = [], 0, 1
for char in os.read(0, os.fstat(0).st_size):
if char >= 48:
num = num * 10 + char - 48
elif char == 45:
sign = -1
elif char != 13:
numbers.append(sign*num)
num, sign = 0, 1
if char >= 48:
numbers.append(sign*num)
getnum = numbers[::-1].pop
def main():
n, m = getnum(), getnum()
_dp = [[] for _ in range(n)]
for i in range(n):
ni = getnum()
ai = [getnum() for _ in range(ni)]
cumsum = [0] * (ni + 1)
for j in range(ni):
cumsum[j + 1] = cumsum[j] + ai[j]
_dpi = [0] * (ni + 1)
for j in range(ni + 1):
for k in range(j, ni + 1):
_dpi[ni + j - k] = max(_dpi[ni + j - k], cumsum[j] + cumsum[-1] - cumsum[k])
_dp[i] = _dpi
dp = [0] * (m + 1)
for i in range(n):
_dpi = _dp[i]
for j in reversed(range(m + 1)):
dpj = dp[j]
for k in range(min(len(_dp[i]), j + 1)):
dpj = max(dpj, _dpi[k] + dp[j - k])
dp[j] = dpj
cout << dp[m]
if __name__ == '__main__':
main()
``` |
1512_C. A-B Palindrome | You are given a string s consisting of the characters '0', '1', and '?'. You need to replace all the characters with '?' in the string s by '0' or '1' so that the string becomes a palindrome and has exactly a characters '0' and exactly b characters '1'. Note that each of the characters '?' is replaced independently from the others.
A string t of length n is called a palindrome if the equality t[i] = t[n-i+1] is true for all i (1 ≤ i ≤ n).
For example, if s="01?????0", a=4 and b=4, then you can replace the characters '?' in the following ways:
* "01011010";
* "01100110".
For the given string s and the numbers a and b, replace all the characters with '?' in the string s by '0' or '1' so that the string becomes a palindrome and has exactly a characters '0' and exactly b characters '1'.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains two integers a and b (0 ≤ a, b ≤ 2 ⋅ 10^5, a + b ≥ 1).
The second line of each test case contains the string s of length a+b, consisting of the characters '0', '1', and '?'.
It is guaranteed that the sum of the string lengths of s over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output:
* "-1", if you can't replace all the characters '?' in the string s by '0' or '1' so that the string becomes a palindrome and that it contains exactly a characters '0' and exactly b characters '1';
* the string that is obtained as a result of the replacement, otherwise.
If there are several suitable ways to replace characters, you can output any.
Example
Input
9
4 4
01?????0
3 3
??????
1 0
?
2 2
0101
2 2
01?0
0 1
0
0 3
1?1
2 2
?00?
4 3
??010?0
Output
01011010
-1
0
-1
0110
-1
111
1001
0101010 | ```python
import sys
input = sys.stdin.readline
for _ in range(int(input())):
a,b=map(int,input().split())
s=list(input().rstrip())
l=len(s);question=s.count('?')
f=0
for i in range(0,l//2):
left=s[i];right=s[l-1-i]
if left==right:
if left=='0':a-=2
elif left=='1':b-=2
elif left=='?':
question -= 1
if right=='0':a-=2;s[i]='0'
else: b-=2;s[i]='1'
elif right=='?':
question -= 1
if left=='0':a-=2;s[l-1-i]='0'
else: b-=2;s[l-1-i]='1'
else:print(-1);f=1;break
if f==0:
if l%2==1:
if s[l//2]=='0':a-=1;
elif s[l//2]=='1':b-=1;
else:
if a%2==1:a-=1;s[l//2]='0';question-=1;
elif b%2==1:b-=1;s[l//2]='1';question-=1;
else:print(-1);continue
if a<0 or b<0 or a%2==1 or b%2==1 or a+b!=question:print(-1);continue
for i in range(0, l // 2):
if s[i]=='?':
if a>0:s[i]=s[l-1-i]='0';a-=2
else:s[i]=s[l-1-i]='1';b-=2
for x in s:print(x,end="")
print()
``` |
208_C. Police Station | The Berland road network consists of n cities and of m bidirectional roads. The cities are numbered from 1 to n, where the main capital city has number n, and the culture capital — number 1. The road network is set up so that it is possible to reach any city from any other one by the roads. Moving on each road in any direction takes the same time.
All residents of Berland are very lazy people, and so when they want to get from city v to city u, they always choose one of the shortest paths (no matter which one).
The Berland government wants to make this country's road network safer. For that, it is going to put a police station in one city. The police station has a rather strange property: when a citizen of Berland is driving along the road with a police station at one end of it, the citizen drives more carefully, so all such roads are considered safe. The roads, both ends of which differ from the city with the police station, are dangerous.
Now the government wonders where to put the police station so that the average number of safe roads for all the shortest paths from the cultural capital to the main capital would take the maximum value.
Input
The first input line contains two integers n and m (2 ≤ n ≤ 100, <image>) — the number of cities and the number of roads in Berland, correspondingly. Next m lines contain pairs of integers vi, ui (1 ≤ vi, ui ≤ n, vi ≠ ui) — the numbers of cities that are connected by the i-th road. The numbers on a line are separated by a space.
It is guaranteed that each pair of cities is connected with no more than one road and that it is possible to get from any city to any other one along Berland roads.
Output
Print the maximum possible value of the average number of safe roads among all shortest paths from the culture capital to the main one. The answer will be considered valid if its absolute or relative inaccuracy does not exceed 10 - 6.
Examples
Input
4 4
1 2
2 4
1 3
3 4
Output
1.000000000000
Input
11 14
1 2
1 3
2 4
3 4
4 5
4 6
5 11
6 11
1 8
8 9
9 7
11 7
1 10
10 4
Output
1.714285714286
Note
In the first sample you can put a police station in one of the capitals, then each path will have exactly one safe road. If we place the station not in the capital, then the average number of safe roads will also make <image>.
In the second sample we can obtain the maximum sought value if we put the station in city 4, then 6 paths will have 2 safe roads each, and one path will have 0 safe roads, so the answer will equal <image>. | ```python
#build the graph with n cities and m roads
#figure out all of the shortest paths from city 1 to city n
#best=number of shortest paths (if we have police station at 1 or n)
s=list(map(int,input().split()))
n=s[0]
m=s[1]
roads=[]
Adj=[]
for i in range(0,n+1):
roads.append([])
Adj.append([False]*(n+1))
for i in range(0,m):
s=list(map(int,input().split()))
roads[s[0]].append(s[1])
roads[s[1]].append(s[0])
Adj[s[0]][s[1]]=True
Adj[s[1]][s[0]]=True
#we gotta count how many shortest paths from 1 to n
#first bfs to find the length of the shortest path
#in our bfs, all the nodes now have "levels" from 1
Dist=[200]*(n+1)
Q=[1]
Dist[1]=0
while len(Q)>0:
curr=Q.pop(0)
for nex in roads[curr]:
if Dist[nex]==200: #not Visited
Dist[nex]=Dist[curr]+1
Q.append(nex)
Levels=[]
for l in range(0,100):
Levels.append([])
for p in range(1,n+1):
if Dist[p]==l:
Levels[l].append(p)
#given a point p, paths[a][p]=sigma(paths[a][v]) where v is all of the points
# on a level lower than p, connected to p
fromOne=[0]*(n+1)
def fo(b):
"""how many shortest paths from 1 to b"""
if fromOne[b]>0:
return fromOne[b]
if b==1:
return 1
ans=0
for p in Levels[Dist[b]-1]:
if Adj[p][b]:
ans+=fo(p)
fromOne[b]=ans
return ans
toN=[0]*(n+1)
def tN(b):
"""how many shortest paths from 1 to b"""
if toN[b]>0:
return toN[b]
if b==n:
return 1
ans=0
for p in Levels[Dist[b]+1]:
if Adj[p][b]:
ans+=tN(p)
toN[b]=ans
return ans
#OHHH we count how many shortest paths include policeStation
best=fo(n)
for policeStation in range(2,n):
safe=fo(policeStation)*tN(policeStation)*2
best=max(best,safe)
print(round(best/fo(n),10))
``` |
331_C1. The Great Julya Calendar | 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 | ```python
def maxx(n):
l=[]
while(n>0):
l.append(n%10)
n = int(n/10)
return max(l)
n =int(input())
j=0
while(n>0):
n = n- maxx(n)
j+=1
print(j)
``` |
353_C. Find Maximum | Valera has array a, consisting of n integers a0, a1, ..., an - 1, and function f(x), taking an integer from 0 to 2n - 1 as its single argument. Value f(x) is calculated by formula <image>, where value bit(i) equals one if the binary representation of number x contains a 1 on the i-th position, and zero otherwise.
For example, if n = 4 and x = 11 (11 = 20 + 21 + 23), then f(x) = a0 + a1 + a3.
Help Valera find the maximum of function f(x) among all x, for which an inequality holds: 0 ≤ x ≤ m.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of array elements. The next line contains n space-separated integers a0, a1, ..., an - 1 (0 ≤ ai ≤ 104) — elements of array a.
The third line contains a sequence of digits zero and one without spaces s0s1... sn - 1 — the binary representation of number m. Number m equals <image>.
Output
Print a single integer — the maximum value of function f(x) for all <image>.
Examples
Input
2
3 8
10
Output
3
Input
5
17 0 10 2 1
11010
Output
27
Note
In the first test case m = 20 = 1, f(0) = 0, f(1) = a0 = 3.
In the second sample m = 20 + 21 + 23 = 11, the maximum value of function equals f(5) = a0 + a2 = 17 + 10 = 27. | ```python
n = int(input())
a = list(map(int, input().split()))
s = input()
ans = 0
sm = 0
for i in range(n):
if s[i] == '1':
ans = max(ans + a[i], sm)
sm += a[i]
print(ans)
``` |
377_D. Developing Game | Pavel is going to make a game of his dream. However, he knows that he can't make it on his own so he founded a development company and hired n workers of staff. Now he wants to pick n workers from the staff who will be directly responsible for developing a game.
Each worker has a certain skill level vi. Besides, each worker doesn't want to work with the one whose skill is very different. In other words, the i-th worker won't work with those whose skill is less than li, and with those whose skill is more than ri.
Pavel understands that the game of his dream isn't too hard to develop, so the worker with any skill will be equally useful. That's why he wants to pick a team of the maximum possible size. Help him pick such team.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of workers Pavel hired.
Each of the following n lines contains three space-separated integers li, vi, ri (1 ≤ li ≤ vi ≤ ri ≤ 3·105) — the minimum skill value of the workers that the i-th worker can work with, the i-th worker's skill and the maximum skill value of the workers that the i-th worker can work with.
Output
In the first line print a single integer m — the number of workers Pavel must pick for developing the game.
In the next line print m space-separated integers — the numbers of the workers in any order.
If there are multiple optimal solutions, print any of them.
Examples
Input
4
2 8 9
1 4 7
3 6 8
5 8 10
Output
3
1 3 4
Input
6
3 5 16
1 6 11
4 8 12
7 9 16
2 10 14
8 13 15
Output
4
1 2 3 5 | ```python
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
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')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
# 2020/12/17
class LazySegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the lazy segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self._lazy = [0] * (2 * _size)
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __len__(self):
return self._len
def _push(self, idx):
"""push query on idx to its children"""
# Let the children know of the queries
q, self._lazy[idx] = self._lazy[idx], 0
self._lazy[2 * idx] += q
self._lazy[2 * idx + 1] += q
self.data[2 * idx] += q
self.data[2 * idx + 1] += q
def _update(self, idx):
"""updates the node idx to know of all queries applied to it via its ancestors"""
for i in reversed(range(1, idx.bit_length())):
self._push(idx >> i)
def _build(self, idx):
"""make the changes to idx be known to its ancestors"""
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1]) + self._lazy[idx]
idx >>= 1
def add(self, start, stop, value):
"""lazily add value to [start, stop)"""
start = start_copy = start + self._size
stop = stop_copy = stop + self._size
while start < stop:
if start & 1:
self._lazy[start] += value
self.data[start] += value
start += 1
if stop & 1:
stop -= 1
self._lazy[stop] += value
self.data[stop] += value
start >>= 1
stop >>= 1
# Tell all nodes above of the updated area of the updates
self._build(start_copy)
self._build(stop_copy - 1)
def query(self, start, stop, default=None):
"""func of data[start, stop)"""
start += self._size
stop += self._size
# Apply all the lazily stored queries
self._update(start)
self._update(stop - 1)
res = self._default if default is None else default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "LazySegmentTree({})".format(list(map(lambda i: self.query(i, i + 1), range(self._len))))
class SweepLine:
def __init__(self, data=None, inclusive=True):
"""
:param data: [((1, 2), (3, 4)), (left_bottom, right_top), ...]
:param inclusive: include the right bound
"""
if data:
# [((1, 2), (3, 4), 0), ...]
self.data = [(*pair, i) for i, pair in enumerate(data)]
else:
self.data = []
self.discrete_dict = self.restore = None
self.INCLUSIVE = inclusive
def add_rectangle(self, rectangle):
self.data.append((*rectangle, len(self.data)))
def _discrete(self):
st = set()
operations = []
for p1, p2, i in self.data:
st |= {*p1, *p2}
# we want add operation go first, so *= -1
# we calculate the line intersect
operations.append((p1[1], -1, p1[0], p2[0], i)) # add
operations.append((p2[1], 1, p1[0], p2[0], i)) # subtract
self.restore = sorted(st)
self.discrete_dict = dict(zip(self.restore, range(len(st))))
self.operations = sorted(operations)
# print(*self.operations, sep='\n')
def max_intersect(self, get_points=False):
"""
:return intersect, i (ith rectangle)
:return intersect, i, x
"""
if not self.restore:
self._discrete()
d = self.discrete_dict
tree = LazySegmentTree([0] * len(self.restore))
result = 0, None
for y, v, left, right, i in self.operations:
# print(f"left={left}, right={right}")
left, right, v = d[left], d[right], -v
# print(f"dis -> left={left}, right={right}")
tree.add(left, right + self.INCLUSIVE, v)
if v == 1:
intersect = tree.query(left, right + self.INCLUSIVE)
if intersect > result[0]:
result = intersect, i
tree = LazySegmentTree([0] * len(self.restore))
if get_points:
for y, v, left, right, i in self.operations:
left, right, v = d[left], d[right], -v
tree.add(left, right + self.INCLUSIVE, v)
if i == result[1]:
for lf in range(left, right + self.INCLUSIVE):
if tree.query(lf, lf + 1) == result[0]:
return result[0], i, self.restore[lf]
return result
# ############################## main
def main():
n = itg()
data = []
for _ in range(n):
lf, md, rg = mpint()
data.append(((lf, md), (md, rg)))
sweep = SweepLine(data)
ans1, idx, left = sweep.max_intersect(True)
right = data[idx][0][1]
print(ans1)
# print(idx)
# print(f"intersect = {ans1}")
# print(f"left = {left}, right = {right}")
ans2 = []
for i, pair in enumerate(data):
lf, md, rg = pair[0][0], pair[0][1], pair[1][1]
if lf <= left <= md <= right <= rg:
ans2.append(i + 1)
if len(ans2) != ans1:
print(AssertionError, len(ans2))
else:
print(*ans2)
DEBUG = 0
URL = 'https://codeforces.com/contest/377/problem/D'
if __name__ == '__main__':
# 0: normal, 1: runner, 2: interactive, 3: debug
if DEBUG == 1:
import requests
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
else:
if DEBUG != 3:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
if DEBUG:
_print = print
def print(*args, **kwargs):
_print(*args, **kwargs)
sys.stdout.flush()
main()
# Please check!
``` |
39_A. C*++ Calculations | C*++ language is quite similar to C++. The similarity manifests itself in the fact that the programs written in C*++ sometimes behave unpredictably and lead to absolutely unexpected effects. For example, let's imagine an arithmetic expression in C*++ that looks like this (expression is the main term):
* expression ::= summand | expression + summand | expression - summand
* summand ::= increment | coefficient*increment
* increment ::= a++ | ++a
* coefficient ::= 0|1|2|...|1000
For example, "5*a++-3*++a+a++" is a valid expression in C*++.
Thus, we have a sum consisting of several summands divided by signs "+" or "-". Every summand is an expression "a++" or "++a" multiplied by some integer coefficient. If the coefficient is omitted, it is suggested being equal to 1.
The calculation of such sum in C*++ goes the following way. First all the summands are calculated one after another, then they are summed by the usual arithmetic rules. If the summand contains "a++", then during the calculation first the value of the "a" variable is multiplied by the coefficient, then value of "a" is increased by 1. If the summand contains "++a", then the actions on it are performed in the reverse order: first "a" is increased by 1, then — multiplied by the coefficient.
The summands may be calculated in any order, that's why sometimes the result of the calculation is completely unpredictable! Your task is to find its largest possible value.
Input
The first input line contains an integer a ( - 1000 ≤ a ≤ 1000) — the initial value of the variable "a". The next line contains an expression in C*++ language of the described type. The number of the summands in the expression does not exceed 1000. It is guaranteed that the line describing the expression contains no spaces and tabulation.
Output
Output a single number — the maximal possible value of the expression.
Examples
Input
1
5*a++-3*++a+a++
Output
11
Input
3
a+++++a
Output
8
Note
Consider the second example. Initially a = 3. Suppose that at first the first summand is calculated, and then the second one is. The first summand gets equal to 3, and the value of a is increased by 1. At the calculation of the second summand a is increased once more (gets equal to 5). The value of the second summand is 5, and together they give 8. If we calculate the second summand first and the first summand later, then the both summands equals to 4, and the result is 8, too. | ```python
import re
n = int(input())
v = input()
f1, f2 = v.count('a++'), v.count('++a')
s = []
i = 0
while i < len(v) - 2:
if v[i] + v[i + 1] + v[i + 2] == '++a':
s.append('b')
i += 3
elif v[i] + v[i + 1] + v[i + 2] == 'a++':
s.append('a')
i += 3
else:
if i == len(v) - 2:
s.extend(v[i:])
i = len(v)
else:
s.append(v[i])
i += 1
a, m = [], []
z = 1
t = ''
for i in s:
if i in ['-', '+']:
if z:
a.append(t)
else:
m.append(t)
t = ''
z = 0 if i == '-' else 1
else:
t += i
if t != '':
if z:
a.append(t)
else:
m.append(t)
for i in range(len(a)):
t = a[i].split('*')
r = 1
k1 = k2 = 0
for j in t:
if not j.isalpha():
r *= int(j)
elif j == 'a':
k1 += 1
else:
k2 += 1
a[i] = (r, k1, k2)
for i in range(len(m)):
t = m[i].split('*')
r = 1
k1 = k2 = 0
for j in t:
if j.isnumeric():
r *= int(j)
elif j == 'a':
k1 += 1
else:
k2 += 1
m[i] = (r, k1, k2)
a.sort(key=lambda x: x[0])
m.sort(key=lambda x: -x[0])
ans = 0
t = n
for i in m:
if i[1] + i[2] == 0:
ans += i[0]
continue
z = i[0]
for j in range(i[1]):
z *= t
t += 1
for j in range(i[2]):
t += 1
z *= t
ans += z
res = 0
for i in a:
if i[1] + i[2] == 0:
res += i[0]
continue
z = i[0]
for j in range(i[1]):
z *= t
t += 1
for j in range(i[2]):
t += 1
z *= t
res += z
print(res - ans)
``` |
424_B. Megacity | The administration of the Tomsk Region firmly believes that it's time to become a megacity (that is, get population of one million). Instead of improving the demographic situation, they decided to achieve its goal by expanding the boundaries of the city.
The city of Tomsk can be represented as point on the plane with coordinates (0; 0). The city is surrounded with n other locations, the i-th one has coordinates (xi, yi) with the population of ki people. You can widen the city boundaries to a circle of radius r. In such case all locations inside the circle and on its border are included into the city.
Your goal is to write a program that will determine the minimum radius r, to which is necessary to expand the boundaries of Tomsk, so that it becomes a megacity.
Input
The first line of the input contains two integers n and s (1 ≤ n ≤ 103; 1 ≤ s < 106) — the number of locatons around Tomsk city and the population of the city. Then n lines follow. The i-th line contains three integers — the xi and yi coordinate values of the i-th location and the number ki of people in it (1 ≤ ki < 106). Each coordinate is an integer and doesn't exceed 104 in its absolute value.
It is guaranteed that no two locations are at the same point and no location is at point (0; 0).
Output
In the output, print "-1" (without the quotes), if Tomsk won't be able to become a megacity. Otherwise, in the first line print a single real number — the minimum radius of the circle that the city needs to expand to in order to become a megacity.
The answer is considered correct if the absolute or relative error don't exceed 10 - 6.
Examples
Input
4 999998
1 1 1
2 2 1
3 3 1
2 -2 1
Output
2.8284271
Input
4 999998
1 1 2
2 2 1
3 3 1
2 -2 1
Output
1.4142136
Input
2 1
1 1 999997
2 2 1
Output
-1 | ```python
import math
#t=int(input())
#lst = list(map(int, input().strip().split(' ')))
n,s = map(int, input().strip().split(' '))
l=[]
for i in range(n):
x,y,k = map(int, input().strip().split(' '))
l1=[]
l1=[math.sqrt(x*x + y*y),k]
l.append(l1)
l.sort(key = lambda l: l[0])
#print(l)
t=-1
f=0
for i in range(n):
t=l[i][0]
s+=l[i][1]
if s>=1000000:
f=1
print(t)
break
if f==0:
print(-1)
``` |
448_E. Divisors | Bizon the Champion isn't just friendly, he also is a rigorous coder.
Let's define function f(a), where a is a sequence of integers. Function f(a) returns the following sequence: first all divisors of a1 go in the increasing order, then all divisors of a2 go in the increasing order, and so on till the last element of sequence a. For example, f([2, 9, 1]) = [1, 2, 1, 3, 9, 1].
Let's determine the sequence Xi, for integer i (i ≥ 0): X0 = [X] ([X] is a sequence consisting of a single number X), Xi = f(Xi - 1) (i > 0). For example, at X = 6 we get X0 = [6], X1 = [1, 2, 3, 6], X2 = [1, 1, 2, 1, 3, 1, 2, 3, 6].
Given the numbers X and k, find the sequence Xk. As the answer can be rather large, find only the first 105 elements of this sequence.
Input
A single line contains two space-separated integers — X (1 ≤ X ≤ 1012) and k (0 ≤ k ≤ 1018).
Output
Print the elements of the sequence Xk in a single line, separated by a space. If the number of elements exceeds 105, then print only the first 105 elements.
Examples
Input
6 1
Output
1 2 3 6
Input
4 2
Output
1 1 2 1 2 4
Input
10 3
Output
1 1 1 2 1 1 5 1 1 2 1 5 1 2 5 10 | ```python
import sys
solSaved = {}
solSavedPropios = {}
def DivisorsN(n):
key = solSaved.get(str(n))
if key == None :
divisors = []
divisors2 = []
for i in range(1,int(n ** (1/2)) + 1):
if n % i == 0 :
if abs(i - (n/i)) < 10 ** (-7) : divisors.append(int(i))
else :
divisors.append(int(i))
temp = []
temp.append(int(n/i))
divisors2 = temp + divisors2
divisors = divisors + divisors2
solSaved[str(n)] = divisors.copy()
return divisors
return key
def TodosLosDivisores(arrayN) :
sol = []
if len(arrayN) > 10 ** 5 :
newArrayN = []
for k in range(len(arrayN)):
newArrayN.append(arrayN[k])
arrayN = newArrayN
for i in range(len(arrayN) - 1):
temp = DivisorsN(arrayN[i])
for t in range(len(temp)) : sol.append(temp[t])
#sol = sol + solSaved.get(str(arrayN[len(arrayN) - 1]))
temp = sol.copy()
temp2 = solSaved.get(str(arrayN[len(arrayN) - 1]))
sol.append(temp2)
for t in range(len(temp2)) : temp.append(temp2[t])
solSaved[str(temp2)] = temp
return sol
def DivisorsXk():
a, b = input().split()
x = int(a)
k = int(b)
if x == 1 : return 1
if k == 0 : return x
if k == 1 : return DivisorsN(x)
sol = []
sol.append(x)
solSaved[str(x)] = DivisorsN(x)
# index = 0
# for i in range(k):
# prev_index = len(sol)
# for j in range(index, len(sol)):
# divs = DivisorsN(sol[j])
# sol = sol + divs
# index = prev_index
i = 1
while i <= k :
# j = 0
# while j < len(sol):
# if type(sol[j]) == int : newSol.append(DivisorsN(sol[j]))
# else : newSol = newSol + DivisorAll(sol[j])
# j+=1
# sol = newSol
if type(sol[i - 1]) == int : sol.append(DivisorsN(sol[i - 1]))
else : sol.append(TodosLosDivisores(sol[i - 1]))
i += 1
temp = []
temp2 = sol[len(sol) - 1]
for t in range(len(temp2) - 1) : temp.append(temp2[t])
temp = temp + temp2[len(temp2) - 1]
return temp
def LosFuckingDivisoresDeUnArrayConLista(a) :
sol = []
if type(a) == int : return DivisorsN(a)
for i in range(len(a)) :
temp = []
key = solSaved.get(str(a[i]))
if key == None : temp = LosFuckingDivisoresDeUnArrayConLista(a[i])
else : temp = key
sol.append(temp)
solSaved[str(a)] = sol
return sol
def Divisors(x, k) :
if k == 0 : return x
if k > 10 ** 5 :
Ones = []
for i in range(10 ** 5) : Ones.append(1)
return Ones
key = solSaved.get(str((x,k)))
if key == None :
sol = []
if type(x) == int : return Divisors(DivisorsN(x), k - 1)
else :
sol = []
for i in range(len(x)) :
temp = []
temp.append(Divisors(x[i], k - 1))
sol = sol + temp
return sol
else : return key
def DivisorsPropios(n) :
key = solSavedPropios.get(str(n))
if key == None :
divisors = []
divisors2 = []
for i in range(2,int(n ** (1/2)) + 1):
if n % i == 0 :
if abs(i - (n/i)) < 10 ** (-7) : divisors.append(int(i))
else :
divisors.append(int(i))
temp = []
temp.append(int(n/i))
divisors2 = temp + divisors2 #divisors2.append(int(n / i))
divisors = divisors + divisors2
solSavedPropios[str(n)] = divisors.copy()
return divisors
return key
def UltimateDivisors(x, k) :
if x == 1 : return 1
if k == 0 : return x
if k == 1 : return DivisorsN(x)
if k >= 10 ** 5 :
a = []
for i in range(10 ** 5) : a.append(1)
return a
Unos = []
sol = []
sol.append(1)
temp = DivisorsPropios(x).copy()
for i in range(k - 1) : Unos.append(1)
if len(temp) == 0 : return [1] + Unos + [x]
temp.append(x)
for t in range(len(temp)) :
if len(sol) >= 10 ** 5 : return sol
temp3 = DivisorsPropios(temp[t]).copy()
if len(temp3) == 0 :
temp4 = UltimateDivisors(temp[t], k - 1)
if type(temp4) == int : sol = sol + [temp4]
else : sol = sol + temp4
else : sol = sol + NewUltimateDivisores(temp[t], k - 1)
return sol
def NewUltimateDivisores(x, k) :
temp = DivisorsPropios(x)
i = k - 1
sol = []
while i >= 1 :
if len(sol) >= 10**5 : return sol
sol = sol + [1]
for t in range(len(temp)) :
temp2 = UltimateDivisors(temp[t], i)
if type(temp2) == int : sol = sol + [temp2]
else : sol = sol + temp2
i -= 1
return sol + DivisorsN(x)
#print(UltimateDivisors(963761198400,65535))
#print(UltimateDivisors(549755813888,269))
a, b = input().split()
x = int(a)
k = int(b)
sol = UltimateDivisors(x,k)
if type(sol) == int : print(sol)
else :
if(len(sol) >= 10 ** 5):
for i in range(10 ** 5 - 1) :
sys.stdout.write(str(sol[i]) + ' ')
sys.stdout.write(str(sol[10**5 - 1]))
else :
for i in range(len(sol) - 1) :
sys.stdout.write(str(sol[i]) + ' ')
sys.stdout.write(str(sol[len(sol) - 1]))
``` |
46_F. Hercule Poirot Problem | Today you are to solve the problem even the famous Hercule Poirot can't cope with! That's why this crime has not yet been solved and this story was never included in Agatha Christie's detective story books.
You are not informed on what crime was committed, when and where the corpse was found and other details. We only know that the crime was committed in a house that has n rooms and m doors between the pairs of rooms. The house residents are very suspicious, that's why all the doors can be locked with keys and all the keys are different. According to the provided evidence on Thursday night all the doors in the house were locked, and it is known in what rooms were the residents, and what kind of keys had any one of them. The same is known for the Friday night, when all the doors were also locked. On Friday it was raining heavily, that's why nobody left the house and nobody entered it. During the day the house residents could
* open and close doors to the neighboring rooms using the keys at their disposal (every door can be opened and closed from each side);
* move freely from a room to a room if a corresponding door is open;
* give keys to one another, being in one room.
"Little grey matter" of Hercule Poirot are not capable of coping with such amount of information. Find out if the positions of people and keys on the Thursday night could result in the positions on Friday night, otherwise somebody among the witnesses is surely lying.
Input
The first line contains three preset integers n, m и k (1 ≤ n, m, k ≤ 1000) — the number of rooms, the number of doors and the number of house residents respectively. The next m lines contain pairs of room numbers which join the doors. The rooms are numbered with integers from 1 to n. There cannot be more that one door between the pair of rooms. No door connects a room with itself. The next k lines describe the residents' position on the first night. Every line contains a resident's name (a non-empty line consisting of no more than 10 Latin letters), then after a space follows the room number, then, after a space — the number of keys the resident has. Then follow written space-separated numbers of the doors that can be unlocked by these keys. The doors are numbered with integers from 1 to m in the order in which they are described in the input data. All the residents have different names, uppercase and lowercase letters considered to be different. Every m keys occurs exactly once in the description. Multiple people may be present in one room, some rooms may be empty. The next k lines describe the position of the residents on the second night in the very same format. It is guaranteed that in the second night's description the residents' names remain the same and every m keys occurs exactly once.
Output
Print "YES" (without quotes) if the second arrangement can result from the first one, otherwise, print "NO".
Examples
Input
2 1 2
1 2
Dmitry 1 1 1
Natalia 2 0
Natalia 1 1 1
Dmitry 2 0
Output
YES
Input
4 4 3
1 3
1 2
2 3
3 4
Artem 1 1 4
Dmitry 1 1 2
Edvard 4 2 1 3
Artem 2 0
Dmitry 1 0
Edvard 4 4 1 2 3 4
Output
NO | ```python
def solve(n,m,k,edge_list,house_members):
room_sets=[i for i in range(n)]
valid_move=[True for i in range(n)]
room_status=[ [1<<i,0,[]] for i in range(n)]
# room_status[i]->informacion de todo otro cuarto,persona y llave alcanzable para el cuarto i
# room_status[i][0]->los cuartos alcanzables por el cuarto i
# room_status[i][1]->las personas que pueden llegar al i
# room_status[i][2]->las llaves alcanzables por el cuarto i
for i in range(k):
room_status[house_members[i][1]][1]|=1<<i
for j in house_members[i][2]:
room_status[house_members[i][1]][2].append(j)
#print(room_status)
move=True
while move:
move=False
for i in range(n):
#print(valid_move)
if valid_move[i]:
move=move or expand(i,room_sets,valid_move,room_status,edge_list)
house_part=[]
for i in range(n):
if room_sets[i]==i:
house_part.append(i)
return adjust_answer(house_part,room_status,n,m,k)
def setoff(index,room_sets):
if room_sets[index]==index:
return index
else:
new_val=setoff(room_sets[index],room_sets)
room_sets[index]=new_val
return new_val
def expand(current_room,room_sets,valid_move,room_status,edge_list):
moving=room_status[current_room][2]
move=False
#print(current_room)
#print(edge_list)
for i in moving:
edge=edge_list[i]
#print(edge)
if setoff(edge[0],room_sets)==current_room:
move =move or merge(current_room,edge[1],room_sets,valid_move,room_status)
if setoff(edge[1],room_sets)==current_room:
move=move or merge(current_room,edge[0],room_sets,valid_move,room_status)
return move
def merge(x,y,room_sets,valid_move,room_status):
#print(x,y)
setx=setoff(x,room_sets)
sety=setoff(y,room_sets)
#print(setx,sety)
if setx==sety:
return False
else:
m=(len(room_status[setx][2]))
m1=len(room_status[sety][2])
if m >= m1:
head=setx
tail=sety
else:
head=sety
tail=setx
# print(head,tail)
valid_move[tail]=0
room_sets[tail]=head
keys=room_status[tail][2]
while len(keys)>0:
room_status[head][2].append(keys.pop())
room_status[head][1]|=room_status[tail][1]
room_status[head][0]|=room_status[tail][0]
return True
def adjust_answer(house_part,room_status,n,m,k):
size=len(house_part)
#print(house_part)
rooms=[0 for i in range(size)]
members=[0 for i in range(size)]
keys=[0 for i in range(size)]
for i in range(size):
keys_list=room_status[house_part[i]][2]
for j in keys_list:
keys[i]|=1<<j
rooms[i]=room_status[house_part[i]][0]
members[i]=room_status[house_part[i]][1]
#print(rooms)
#print(members)
#print(keys)
#rooms.sort()
#members.sort()
#keys.sort()
return [rooms,members,keys]
def compare_answer(answer_1,answer_2,n,m,k):
rooms1=answer_1[0]
members1=answer_1[1]
keys1=answer_1[2]
if len(rooms1)!=len(members1)!=len(keys1):
return False
rooms2=answer_2[0]
members2=answer_2[1]
keys2=answer_2[2]
if len(rooms2)!=len(members2)!=len(keys2):
return False
if len(rooms1)!=len(rooms2):
return False
for i in range(len(rooms1)):
if rooms1[i]!=rooms2[i] or keys1[i]!=keys2[i] or members1[i]!=members2[i]:
return False
return True
data=[int(i) for i in input().split()]
n,m,k=data[0],data[1],data[2]
house_members=[["",0,[]]for i in range(k)]
house_members_2=[["",0,[]]for i in range(k)]
pos_adjustment={}
edge_list=[]
for i in range(m):
doors_data=[int(i) for i in input().split()]
a,b=doors_data[0]-1,doors_data[1]-1
edge_list.append((a,b))
for i in range(k):
temp=input().split()
pos_adjustment[temp[0]]=i
house_members[i][0]=temp[0]
house_members[i][1]=int(temp[1])-1
for j in range(3,len(temp)):
val=int(temp[j])-1
house_members[i][2].append(val)
answer_1=solve(n,m,k,edge_list,house_members)
for i in range(k):
temp=input().split()
house_members_2[pos_adjustment[temp[0]]][0]=temp[0]
house_members_2[pos_adjustment[temp[0]]][1]=int(temp[1])-1
for j in range(3,len(temp)):
val=int(temp[j])-1
house_members_2[pos_adjustment[temp[0]]][2].append(val)
answer_2=solve(n,m,k,edge_list,house_members_2)
if compare_answer(answer_1,answer_2,n,m,k):
print("YES")
else :
print("NO")
``` |
493_B. Vasya and Wrestling | Vasya has become interested in wrestling. In wrestling wrestlers use techniques for which they are awarded points by judges. The wrestler who gets the most points wins.
When the numbers of points of both wrestlers are equal, the wrestler whose sequence of points is lexicographically greater, wins.
If the sequences of the awarded points coincide, the wrestler who performed the last technique wins. Your task is to determine which wrestler won.
Input
The first line contains number n — the number of techniques that the wrestlers have used (1 ≤ n ≤ 2·105).
The following n lines contain integer numbers ai (|ai| ≤ 109, ai ≠ 0). If ai is positive, that means that the first wrestler performed the technique that was awarded with ai points. And if ai is negative, that means that the second wrestler performed the technique that was awarded with ( - ai) points.
The techniques are given in chronological order.
Output
If the first wrestler wins, print string "first", otherwise print "second"
Examples
Input
5
1
2
-3
-4
3
Output
second
Input
3
-1
-2
3
Output
first
Input
2
4
-4
Output
second
Note
Sequence x = x1x2... x|x| is lexicographically larger than sequence y = y1y2... y|y|, if either |x| > |y| and x1 = y1, x2 = y2, ... , x|y| = y|y|, or there is such number r (r < |x|, r < |y|), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 > yr + 1.
We use notation |a| to denote length of sequence a. | ```python
n = int(input())
a = []
b = []
for i in range(n):
x = int(input())
if i == n-1:
num = x
if x > 0:
a.append(x)
else:
b.append(abs(x))
sma = sum(a)
smb = sum(b)
if sma > smb:
print("first")
elif sma < smb:
print("second")
else:
if a == b:
if x > 0:
print("first")
else:
print("second")
else:
for i in range(min(len(a), len(b))):
if a[i] > b[i]:
print("first")
break
elif a[i] < b[i]:
print("second")
break
``` |
518_A. Vitaly and Strings | Vitaly is a diligent student who never missed a lesson in his five years of studying in the university. He always does his homework on time and passes his exams in time.
During the last lesson the teacher has provided two strings s and t to Vitaly. The strings have the same length, they consist of lowercase English letters, string s is lexicographically smaller than string t. Vitaly wondered if there is such string that is lexicographically larger than string s and at the same is lexicographically smaller than string t. This string should also consist of lowercase English letters and have the length equal to the lengths of strings s and t.
Let's help Vitaly solve this easy problem!
Input
The first line contains string s (1 ≤ |s| ≤ 100), consisting of lowercase English letters. Here, |s| denotes the length of the string.
The second line contains string t (|t| = |s|), consisting of lowercase English letters.
It is guaranteed that the lengths of strings s and t are the same and string s is lexicographically less than string t.
Output
If the string that meets the given requirements doesn't exist, print a single string "No such string" (without the quotes).
If such string exists, print it. If there are multiple valid strings, you may print any of them.
Examples
Input
a
c
Output
b
Input
aaa
zzz
Output
kkk
Input
abcdefg
abcdefh
Output
No such string
Note
String s = s1s2... sn is said to be lexicographically smaller than t = t1t2... tn, if there exists such i, that s1 = t1, s2 = t2, ... si - 1 = ti - 1, si < ti. | ```python
def f(s): return f(s[:-1])+'a' if s[-1] == 'z'else s[:-1]+chr(ord(s[-1])+1)
s = f(input())
print(('No such string', s)[s < input()])
``` |
544_A. Set of Strings | You are given a string q. A sequence of k strings s1, s2, ..., sk is called beautiful, if the concatenation of these strings is string q (formally, s1 + s2 + ... + sk = q) and the first characters of these strings are distinct.
Find any beautiful sequence of strings or determine that the beautiful sequence doesn't exist.
Input
The first line contains a positive integer k (1 ≤ k ≤ 26) — the number of strings that should be in a beautiful sequence.
The second line contains string q, consisting of lowercase Latin letters. The length of the string is within range from 1 to 100, inclusive.
Output
If such sequence doesn't exist, then print in a single line "NO" (without the quotes). Otherwise, print in the first line "YES" (without the quotes) and in the next k lines print the beautiful sequence of strings s1, s2, ..., sk.
If there are multiple possible answers, print any of them.
Examples
Input
1
abca
Output
YES
abca
Input
2
aaacas
Output
YES
aaa
cas
Input
4
abc
Output
NO
Note
In the second sample there are two possible answers: {"aaaca", "s"} and {"aaa", "cas"}. | ```python
from sys import *
k=int(input())
s=input()
ee=set()
for i in s:
ee.add(i)
if k>len(ee):
print("NO")
exit(0)
print("YES")
i=1
cur=s[0]
num=k-1
ee.discard(s[0])
while i<len(s):
if s[i] in ee and num:
print(cur)
ee.discard(s[i])
num-=1
cur=s[i]
else:
cur+=s[i]
i+=1
print(cur)
``` |
570_C. Replacement | Daniel has a string s, consisting of lowercase English letters and period signs (characters '.'). Let's define the operation of replacement as the following sequence of steps: find a substring ".." (two consecutive periods) in string s, of all occurrences of the substring let's choose the first one, and replace this substring with string ".". In other words, during the replacement operation, the first two consecutive periods are replaced by one. If string s contains no two consecutive periods, then nothing happens.
Let's define f(s) as the minimum number of operations of replacement to perform, so that the string does not have any two consecutive periods left.
You need to process m queries, the i-th results in that the character at position xi (1 ≤ xi ≤ n) of string s is assigned value ci. After each operation you have to calculate and output the value of f(s).
Help Daniel to process all queries.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 300 000) the length of the string and the number of queries.
The second line contains string s, consisting of n lowercase English letters and period signs.
The following m lines contain the descriptions of queries. The i-th line contains integer xi and ci (1 ≤ xi ≤ n, ci — a lowercas English letter or a period sign), describing the query of assigning symbol ci to position xi.
Output
Print m numbers, one per line, the i-th of these numbers must be equal to the value of f(s) after performing the i-th assignment.
Examples
Input
10 3
.b..bz....
1 h
3 c
9 f
Output
4
3
1
Input
4 4
.cc.
2 .
3 .
2 a
1 a
Output
1
3
1
1
Note
Note to the first sample test (replaced periods are enclosed in square brackets).
The original string is ".b..bz....".
* after the first query f(hb..bz....) = 4 ("hb[..]bz...." → "hb.bz[..].." → "hb.bz[..]." → "hb.bz[..]" → "hb.bz.")
* after the second query f(hbс.bz....) = 3 ("hbс.bz[..].." → "hbс.bz[..]." → "hbс.bz[..]" → "hbс.bz.")
* after the third query f(hbс.bz..f.) = 1 ("hbс.bz[..]f." → "hbс.bz.f.")
Note to the second sample test.
The original string is ".cc.".
* after the first query: f(..c.) = 1 ("[..]c." → ".c.")
* after the second query: f(....) = 3 ("[..].." → "[..]." → "[..]" → ".")
* after the third query: f(.a..) = 1 (".a[..]" → ".a.")
* after the fourth query: f(aa..) = 1 ("aa[..]" → "aa.") | ```python
import sys
n,m = map(int,sys.stdin.readline().split())
arr = list(sys.stdin.readline())
count = cnt = 0
for i in arr:
if i=='.':
cnt += 1
elif cnt !=0:
count += cnt-1
cnt = 0
if cnt!=0:
count += cnt-1
i = m
while i:
x,c = sys.stdin.readline().split()
x = int(x)-1
if arr[x]=='.' and c!='.':
if x-1>=0 and x+1<n and (arr[x-1]=='.' and arr[x+1]=='.'):
count -= 2
elif x-1>=0 and x+1<n and (arr[x-1]=='.' or arr[x+1]=='.'):
count -= 1
elif x-1>=0:
if arr[x-1]=='.':
count -= 1
elif x+1<n:
if arr[x+1]=='.':
count -= 1
elif arr[x]!='.' and c=='.':
if x-1>=0 and x+1<n and (arr[x-1]=='.' and arr[x+1]=='.'):
count += 2
elif x-1>=0 and x+1<n and (arr[x-1]=='.' or arr[x+1]=='.'):
count += 1
elif x-1>=0:
if arr[x-1]=='.':
count += 1
elif x+1<n:
if arr[x+1]=='.':
count += 1
sys.stdout.write(str(count)+'\n')
arr[x] = c
i -= 1
``` |
592_A. PawnChess | Galois is one of the strongest chess players of Byteforces. He has even invented a new variant of chess, which he named «PawnChess».
This new game is played on a board consisting of 8 rows and 8 columns. At the beginning of every game some black and white pawns are placed on the board. The number of black pawns placed is not necessarily equal to the number of white pawns placed.
<image>
Lets enumerate rows and columns with integers from 1 to 8. Rows are numbered from top to bottom, while columns are numbered from left to right. Now we denote as (r, c) the cell located at the row r and at the column c.
There are always two players A and B playing the game. Player A plays with white pawns, while player B plays with black ones. The goal of player A is to put any of his pawns to the row 1, while player B tries to put any of his pawns to the row 8. As soon as any of the players completes his goal the game finishes immediately and the succeeded player is declared a winner.
Player A moves first and then they alternate turns. On his move player A must choose exactly one white pawn and move it one step upward and player B (at his turn) must choose exactly one black pawn and move it one step down. Any move is possible only if the targeted cell is empty. It's guaranteed that for any scenario of the game there will always be at least one move available for any of the players.
Moving upward means that the pawn located in (r, c) will go to the cell (r - 1, c), while moving down means the pawn located in (r, c) will go to the cell (r + 1, c). Again, the corresponding cell must be empty, i.e. not occupied by any other pawn of any color.
Given the initial disposition of the board, determine who wins the game if both players play optimally. Note that there will always be a winner due to the restriction that for any game scenario both players will have some moves available.
Input
The input consists of the board description given in eight lines, each line contains eight characters. Character 'B' is used to denote a black pawn, and character 'W' represents a white pawn. Empty cell is marked with '.'.
It's guaranteed that there will not be white pawns on the first row neither black pawns on the last row.
Output
Print 'A' if player A wins the game on the given board, and 'B' if player B will claim the victory. Again, it's guaranteed that there will always be a winner on the given board.
Examples
Input
........
........
.B....B.
....W...
........
..W.....
........
........
Output
A
Input
..B.....
..W.....
......B.
........
.....W..
......B.
........
........
Output
B
Note
In the first sample player A is able to complete his goal in 3 steps by always moving a pawn initially located at (4, 5). Player B needs at least 5 steps for any of his pawns to reach the row 8. Hence, player A will be the winner. | ```python
__author__ = 'Suvasish'
lst = []
a_row = 7
b_row = 0
b_lst = []
a_lst = []
for i in range(0, 8):
lst.append(list(input()))
# print(lst[i])
if 'W' in lst[i]:
a_lst.append(i)
if 'B' in lst[i]:
b_lst.append(i)
b_lst.reverse()
# print('AL', a_lst)
# print('BL', b_lst)
_break = False
for i in a_lst:
if _break:
break
for l in range(0, 8):
if _break:
break
# Checking for the position of 'W'
if lst[i][l] == 'W':
# check earlier columns if the position of 'W' is blocked or not.
for j in range(0, i):
# print('I:', i)
# print('J:', j, '---', 'JL_VAL:', lst[j][l])
if 'B' in lst[j] and lst[j][l] == 'B':
break
else:
if j == i-1:
a_row = i
_break = True
break
# print('A_ROW:', a_row)
_break = False
for k in b_lst:
# print('B_K: ', k)
if _break:
break
for m in range(0, 8):
if _break:
break
if lst[k][m] == 'B':
for n in range(k+1, 8):
# print('M: ', m)
if 'W' in lst[n] and lst[n][m] == 'W':
break
else:
if n == 7:
b_row = k
_break = True
break
# print('B_ROW:', b_row)
if (7-b_row) < a_row:
print('B')
else:
print('A')
``` |
613_D. Kingdom and its Cities | Meanwhile, the kingdom of K is getting ready for the marriage of the King's daughter. However, in order not to lose face in front of the relatives, the King should first finish reforms in his kingdom. As the King can not wait for his daughter's marriage, reforms must be finished as soon as possible.
The kingdom currently consists of n cities. Cities are connected by n - 1 bidirectional road, such that one can get from any city to any other city. As the King had to save a lot, there is only one path between any two cities.
What is the point of the reform? The key ministries of the state should be relocated to distinct cities (we call such cities important). However, due to the fact that there is a high risk of an attack by barbarians it must be done carefully. The King has made several plans, each of which is described by a set of important cities, and now wonders what is the best plan.
Barbarians can capture some of the cities that are not important (the important ones will have enough protection for sure), after that the captured city becomes impassable. In particular, an interesting feature of the plan is the minimum number of cities that the barbarians need to capture in order to make all the important cities isolated, that is, from all important cities it would be impossible to reach any other important city.
Help the King to calculate this characteristic for each of his plan.
Input
The first line of the input contains integer n (1 ≤ n ≤ 100 000) — the number of cities in the kingdom.
Each of the next n - 1 lines contains two distinct integers ui, vi (1 ≤ ui, vi ≤ n) — the indices of the cities connected by the i-th road. It is guaranteed that you can get from any city to any other one moving only along the existing roads.
The next line contains a single integer q (1 ≤ q ≤ 100 000) — the number of King's plans.
Each of the next q lines looks as follows: first goes number ki — the number of important cities in the King's plan, (1 ≤ ki ≤ n), then follow exactly ki space-separated pairwise distinct numbers from 1 to n — the numbers of important cities in this plan.
The sum of all ki's does't exceed 100 000.
Output
For each plan print a single integer — the minimum number of cities that the barbarians need to capture, or print - 1 if all the barbarians' attempts to isolate important cities will not be effective.
Examples
Input
4
1 3
2 3
4 3
4
2 1 2
3 2 3 4
3 1 2 4
4 1 2 3 4
Output
1
-1
1
-1
Input
7
1 2
2 3
3 4
1 5
5 6
5 7
1
4 2 4 6 7
Output
2
Note
In the first sample, in the first and the third King's plan barbarians can capture the city 3, and that will be enough. In the second and the fourth plans all their attempts will not be effective.
In the second sample the cities to capture are 3 and 5. | ```python
import sys
from collections import deque
def solve():
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
writelines = sys.stdout.writelines
N = int(readline())
G = [[] for i in range(N)]
for i in range(N-1):
u, v = map(int, readline().split())
G[u-1].append(v-1)
G[v-1].append(u-1)
# Euler tour technique
S = []
FS = [0]*N; LS = [0]*N
depth = [0]*N
stk = [-1, 0]
it = [0]*N
while len(stk) > 1:
v = stk[-1]
i = it[v]
if i == 0:
FS[v] = len(S)
depth[v] = len(stk)
if i < len(G[v]) and G[v][i] == stk[-2]:
it[v] += 1
i += 1
if i == len(G[v]):
LS[v] = len(S)
stk.pop()
else:
stk.append(G[v][i])
it[v] += 1
S.append(v)
L = len(S)
lg = [0]*(L+1)
# Sparse Table
for i in range(2, L+1):
lg[i] = lg[i >> 1] + 1
st = [[L]*(L - (1 << i) + 1) for i in range(lg[L]+1)]
st[0][:] = S
b = 1
for i in range(lg[L]):
st0 = st[i]
st1 = st[i+1]
for j in range(L - (b<<1) + 1):
st1[j] = (st0[j] if depth[st0[j]] <= depth[st0[j+b]] else st0[j+b])
b <<= 1
INF = 10**18
ans = []
Q = int(readline())
G0 = [[]]*N
P = [0]*N
deg = [0]*N
KS = [0]*N
A = [0]*N
B = [0]*N
for t in range(Q):
k, *vs = map(int, readline().split())
for i in range(k):
vs[i] -= 1
KS[vs[i]] = 1
vs.sort(key=FS.__getitem__)
for i in range(k-1):
x = FS[vs[i]]; y = FS[vs[i+1]]
l = lg[y - x + 1]
w = st[l][x] if depth[st[l][x]] <= depth[st[l][y - (1 << l) + 1]] else st[l][y - (1 << l) + 1]
vs.append(w)
vs.sort(key=FS.__getitem__)
stk = []
prv = -1
for v in vs:
if v == prv:
continue
while stk and LS[stk[-1]] < FS[v]:
stk.pop()
if stk:
G0[stk[-1]].append(v)
G0[v] = []
it[v] = 0
stk.append(v)
prv = v
que = deque()
prv = -1
P[vs[0]] = -1
for v in vs:
if v == prv:
continue
for w in G0[v]:
P[w] = v
deg[v] = len(G0[v])
if deg[v] == 0:
que.append(v)
prv = v
while que:
v = que.popleft()
if KS[v]:
a = 0
for w in G0[v]:
ra = A[w]; rb = B[w]
if depth[v]+1 < depth[w]:
a += min(ra, rb+1)
else:
a += ra
A[v] = INF
B[v] = a
else:
a = 0; b = c = INF
for w in G0[v]:
ra = A[w]; rb = B[w]
a, b, c = a + ra, min(a + rb, b + ra), min(b + rb, c + min(ra, rb))
A[v] = min(a, b+1, c+1)
B[v] = b
p = P[v]
if p != -1:
deg[p] -= 1
if deg[p] == 0:
que.append(p)
v = min(A[vs[0]], B[vs[0]])
if v >= INF:
ans.append("-1\n")
else:
ans.append("%d\n" % v)
for v in vs:
KS[v] = 0
writelines(ans)
solve()
``` |
633_D. Fibonacci-ish | Yash has recently learnt about the Fibonacci sequence and is very excited about it. He calls a sequence Fibonacci-ish if
1. the sequence consists of at least two elements
2. f0 and f1 are arbitrary
3. fn + 2 = fn + 1 + fn for all n ≥ 0.
You are given some sequence of integers a1, a2, ..., an. Your task is rearrange elements of this sequence in such a way that its longest possible prefix is Fibonacci-ish sequence.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 1000) — the length of the sequence ai.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 109).
Output
Print the length of the longest possible Fibonacci-ish prefix of the given sequence after rearrangement.
Examples
Input
3
1 2 -1
Output
3
Input
5
28 35 7 14 21
Output
4
Note
In the first sample, if we rearrange elements of the sequence as - 1, 2, 1, the whole sequence ai would be Fibonacci-ish.
In the second sample, the optimal way to rearrange elements is <image>, <image>, <image>, <image>, 28. | ```python
import random, math
from copy import deepcopy as dc
from bisect import bisect_left, bisect_right
from collections import Counter
# Function to call the actual solution
def solution(li):
ma = {}
for i in range(len(li)):
ma[li[i]] = ma.get(li[i], 0) + 1
# ma1 = dc(ma)
ans = 0
# li = list(set(li))
for i in range(len(li)):
for j in range(len(li)):
if i != j:
f0 = li[i]
f1 = li[j]
if f0 == 0 and f1 == 0:
ans = max(ans, ma[0])
continue
ma[f0] -= 1
ma[f1] -= 1
cur = 2
while True:
nxt = f0 + f1
if nxt in ma and ma[nxt] > 0:
f0 = f1 + 1 - 1
f1 = nxt + 1 - 1
ma[nxt] -= 1
cur += 1
else:
break
cur1 = 2
ma[f0] += 1
ma[f1] += 1
while cur1 < cur:
prev = f1 - f0
f1 = f0 + 1 - 1
f0 = prev + 1 - 1
ma[prev] += 1
cur1 += 1
ans = max(ans, cur)
return ans
# Function to take input
def input_test():
n = int(input())
li = list(map(int, input().strip().split(" ")))
out = solution(li)
print(out)
# Function to test my code
def test():
pass
input_test()
# test()
``` |
686_B. Little Robber Girl's Zoo | Little Robber Girl likes to scare animals in her zoo for fun. She decided to arrange the animals in a row in the order of non-decreasing height. However, the animals were so scared that they couldn't stay in the right places.
The robber girl was angry at first, but then she decided to arrange the animals herself. She repeatedly names numbers l and r such that r - l + 1 is even. After that animals that occupy positions between l and r inclusively are rearranged as follows: the animal at position l swaps places with the animal at position l + 1, the animal l + 2 swaps with the animal l + 3, ..., finally, the animal at position r - 1 swaps with the animal r.
Help the robber girl to arrange the animals in the order of non-decreasing height. You should name at most 20 000 segments, since otherwise the robber girl will become bored and will start scaring the animals again.
Input
The first line contains a single integer n (1 ≤ n ≤ 100) — number of animals in the robber girl's zoo.
The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the height of the animal occupying the i-th place.
Output
Print the sequence of operations that will rearrange the animals by non-decreasing height.
The output should contain several lines, i-th of the lines should contain two space-separated integers li and ri (1 ≤ li < ri ≤ n) — descriptions of segments the robber girl should name. The segments should be described in the order the operations are performed.
The number of operations should not exceed 20 000.
If the animals are arranged correctly from the start, you are allowed to output nothing.
Examples
Input
4
2 1 4 3
Output
1 4
Input
7
36 28 57 39 66 69 68
Output
1 4
6 7
Input
5
1 2 1 2 1
Output
2 5
3 4
1 4
1 4
Note
Note that you don't have to minimize the number of operations. Any solution that performs at most 20 000 operations is allowed. | ```python
n = int(input())
arr = list(map(int,input().split()))
check = 0
while check==0:
check = 1
i = 0
while i<n-1:
if arr[i]>arr[i+1]:
check = 0
print(i+1,i+2)
arr[i],arr[i+1] = arr[i+1],arr[i]
i += 1
``` |
709_A. Juicer | Kolya is going to make fresh orange juice. He has n oranges of sizes a1, a2, ..., an. Kolya will put them in the juicer in the fixed order, starting with orange of size a1, then orange of size a2 and so on. To be put in the juicer the orange must have size not exceeding b, so if Kolya sees an orange that is strictly greater he throws it away and continues with the next one.
The juicer has a special section to collect waste. It overflows if Kolya squeezes oranges of the total size strictly greater than d. When it happens Kolya empties the waste section (even if there are no more oranges) and continues to squeeze the juice. How many times will he have to empty the waste section?
Input
The first line of the input contains three integers n, b and d (1 ≤ n ≤ 100 000, 1 ≤ b ≤ d ≤ 1 000 000) — the number of oranges, the maximum size of the orange that fits in the juicer and the value d, which determines the condition when the waste section should be emptied.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1 000 000) — sizes of the oranges listed in the order Kolya is going to try to put them in the juicer.
Output
Print one integer — the number of times Kolya will have to empty the waste section.
Examples
Input
2 7 10
5 6
Output
1
Input
1 5 10
7
Output
0
Input
3 10 10
5 7 7
Output
1
Input
1 1 1
1
Output
0
Note
In the first sample, Kolya will squeeze the juice from two oranges and empty the waste section afterwards.
In the second sample, the orange won't fit in the juicer so Kolya will have no juice at all. | ```python
"""
IIIIIIIIII OOOOOOOOOOO IIIIIIIIII
II OO OO II
II OO OO II
II OO OO II
II OO OO II
II OO OO II
II OO OO II
IIIIIIIIII OOOOOOOOOOO IIIIIIIIII
"""
n, b, d = map(int, input().split())
m = list(map(int, input().split()))
a = 0
cnt = 0
for i in range(n):
if m[i] > b:
m[i] = 0
a += m[i]
if a > d:
a = 0
cnt += 1
print(cnt)
``` |
753_A. Santa Claus and Candies | Santa Claus has n candies, he dreams to give them as gifts to children.
What is the maximal number of children for whose he can give candies if Santa Claus want each kid should get distinct positive integer number of candies. Santa Class wants to give all n candies he has.
Input
The only line contains positive integer number n (1 ≤ n ≤ 1000) — number of candies Santa Claus has.
Output
Print to the first line integer number k — maximal number of kids which can get candies.
Print to the second line k distinct integer numbers: number of candies for each of k kid. The sum of k printed numbers should be exactly n.
If there are many solutions, print any of them.
Examples
Input
5
Output
2
2 3
Input
9
Output
3
3 5 1
Input
2
Output
1
2 | ```python
n=int(input())
i=1
a=[]
while(n>=i):
a.append(i)
n-=i
i+=1
a[-1]+=n
print(len(a))
print(*a)
``` |
774_G. Perfectionist Arkadiy | Arkadiy has lots square photos with size a × a. He wants to put some of them on a rectangular wall with size h × w.
The photos which Arkadiy will put on the wall must form a rectangular grid and the distances between neighboring vertically and horizontally photos and also the distances between outside rows and columns of photos to the nearest bound of the wall must be equal to x, where x is some non-negative real number. Look on the picture below for better understanding of the statement.
<image>
Arkadiy haven't chosen yet how many photos he would put on the wall, however, he want to put at least one photo. Your task is to determine the minimum value of x which can be obtained after putting photos, or report that there is no way to put positive number of photos and satisfy all the constraints. Suppose that Arkadiy has enough photos to make any valid arrangement according to the constraints.
Note that Arkadiy wants to put at least one photo on the wall. The photos should not overlap, should completely lie inside the wall bounds and should have sides parallel to the wall sides.
Input
The first line contains three integers a, h and w (1 ≤ a, h, w ≤ 109) — the size of photos and the height and the width of the wall.
Output
Print one non-negative real number — the minimum value of x which can be obtained after putting the photos on the wall. The absolute or the relative error of the answer must not exceed 10 - 6.
Print -1 if there is no way to put positive number of photos and satisfy the constraints.
Examples
Input
2 18 13
Output
0.5
Input
4 4 4
Output
0
Input
3 4 3
Output
-1
Note
In the first example Arkadiy can put 7 rows of photos with 5 photos in each row, so the minimum value of x equals to 0.5.
In the second example Arkadiy can put only 1 photo which will take the whole wall, so the minimum value of x equals to 0.
In the third example there is no way to put positive number of photos and satisfy the constraints described in the statement, so the answer is -1. | ```python
def gcd(x,y):
if (x%y==0): return y
return gcd(y,x%y)
a,h,w=input().split()
a=int(a)
h=int(h)
w=int(w)
g=gcd(h+a,w+a)
if (g<a or h<a or w<a):
print("-1")
else:
print(g/(g//a)-a)
``` |
81_B. Sequence Formatting | Polycarp is very careful. He even types numeric sequences carefully, unlike his classmates. If he sees a sequence without a space after the comma, with two spaces in a row, or when something else does not look neat, he rushes to correct it. For example, number sequence written like "1,2 ,3,..., 10" will be corrected to "1, 2, 3, ..., 10".
In this task you are given a string s, which is composed by a concatination of terms, each of which may be:
* a positive integer of an arbitrary length (leading zeroes are not allowed),
* a "comma" symbol (","),
* a "space" symbol (" "),
* "three dots" ("...", that is, exactly three points written one after another, also known as suspension points).
Polycarp wants to add and remove spaces in the string s to ensure the following:
* each comma is followed by exactly one space (if the comma is the last character in the string, this rule does not apply to it),
* each "three dots" term is preceded by exactly one space (if the dots are at the beginning of the string, this rule does not apply to the term),
* if two consecutive numbers were separated by spaces only (one or more), then exactly one of them should be left,
* there should not be other spaces.
Automate Polycarp's work and write a program that will process the given string s.
Input
The input data contains a single string s. Its length is from 1 to 255 characters. The string s does not begin and end with a space. Its content matches the description given above.
Output
Print the string s after it is processed. Your program's output should be exactly the same as the expected answer. It is permissible to end output line with a line-break character, and without it.
Examples
Input
1,2 ,3,..., 10
Output
1, 2, 3, ..., 10
Input
1,,,4...5......6
Output
1, , , 4 ...5 ... ...6
Input
...,1,2,3,...
Output
..., 1, 2, 3, ... | ```python
# вводим строку s
s, i, v = input() + ' ', 0, ' '
# перебираем строку
while i < len(s):
# если в строке запятая, поставить пробел после нее
if s[i] == ',':
v += ', '
# если в строке точки, заменить их на многоточия и пробел перед ними
elif s[i] == '.':
v += ('' if v[-1] == ' ' else ' ') + '...'
i += 2
# проверка строки на наличие цифр
elif s[i].isdigit():
j = i
# ставим пробел перед числом
while s[j].isdigit():
j += 1
v += (' ' if v[-1].isdigit() else '') + s[i:j]
i = j - 1
i += 1
print(v.strip())
``` |
845_E. Fire in the City | The capital of Berland looks like a rectangle of size n × m of the square blocks of same size.
Fire!
It is known that k + 1 blocks got caught on fire (k + 1 ≤ n·m). Those blocks are centers of ignition. Moreover positions of k of these centers are known and one of these stays unknown. All k + 1 positions are distinct.
The fire goes the following way: during the zero minute of fire only these k + 1 centers of ignition are burning. Every next minute the fire goes to all neighbouring blocks to the one which is burning. You can consider blocks to burn for so long that this time exceeds the time taken in the problem. The neighbouring blocks are those that touch the current block by a side or by a corner.
Berland Fire Deparment wants to estimate the minimal time it takes the fire to lighten up the whole city. Remember that the positions of k blocks (centers of ignition) are known and (k + 1)-th can be positioned in any other block.
Help Berland Fire Department to estimate the minimal time it takes the fire to lighten up the whole city.
Input
The first line contains three integers n, m and k (1 ≤ n, m ≤ 109, 1 ≤ k ≤ 500).
Each of the next k lines contain two integers xi and yi (1 ≤ xi ≤ n, 1 ≤ yi ≤ m) — coordinates of the i-th center of ignition. It is guaranteed that the locations of all centers of ignition are distinct.
Output
Print the minimal time it takes the fire to lighten up the whole city (in minutes).
Examples
Input
7 7 3
1 2
2 1
5 5
Output
3
Input
10 5 1
3 3
Output
2
Note
In the first example the last block can have coordinates (4, 4).
In the second example the last block can have coordinates (8, 3). | ```python
import sys
from collections import Counter
from operator import itemgetter
from heapq import heappop, heappush
n, m, k = map(int, input().split())
points = [list(map(int, line.split())) for line in sys.stdin]
pts_sorted_x = sorted(points)
pts_sorted_y = sorted(points, key=itemgetter(1, 0))
inf = 10**9+1
OK = (inf, inf)
def solve2(imos, t):
acc, cur = 0, 0
for k in sorted(imos.keys()):
if t < k:
break
if acc <= 0 and cur+1 < k or acc + imos[k] <= 0:
acc = 0
break
acc += imos[k]
return acc <= 0
def add_imos(imos, x, y):
imos[x] += y
if imos[x] == 0:
del imos[x]
def solve(t, px=-1, py=-1):
set_x = {1, n}
set_y = {1, m}
for x, y in points:
set_x.update((max(1, x-t), max(1, x-t-1), min(n, x+t), min(n, x+t+1)))
set_y.update((max(1, y-t), max(1, y-t-1), min(m, y+t), min(m, y+t+1)))
ans_x = ans_y = inf
pi, imos, hq = 0, Counter(), []
if px != -1:
imos[py] += 1
imos[py+t*2+1] -= 1
for cx in sorted(set_x):
while hq and hq[0][0] < cx:
add_imos(imos, hq[0][1], -1)
add_imos(imos, hq[0][2], +1)
heappop(hq)
while pi < k and pts_sorted_x[pi][0]-t <= cx <= pts_sorted_x[pi][0]+t:
x, y = pts_sorted_x[pi]
add_imos(imos, max(1, y-t), 1)
add_imos(imos, y+t+1, -1)
heappush(hq, (x+t, max(1, y-t), y+t+1))
pi += 1
if solve2(imos, m):
ans_x = cx
break
pi = 0
imos.clear()
hq.clear()
if px != -1:
imos[px] += 1
imos[px+t*2+1] -= 1
for cy in sorted(set_y):
while hq and hq[0][0] < cy:
add_imos(imos, hq[0][1], -1)
add_imos(imos, hq[0][2], +1)
heappop(hq)
while pi < k and pts_sorted_y[pi][1]-t <= cy <= pts_sorted_y[pi][1]+t:
x, y = pts_sorted_y[pi]
add_imos(imos, max(1, x-t), 1)
add_imos(imos, x+t+1, -1)
heappush(hq, (y+t, max(1, x-t), x+t+1))
pi += 1
if solve2(imos, n):
ans_y = cy
break
return ans_x, ans_y
ok, ng = 10**9+1, -1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
p = solve(mid)
if p == OK:
ok = mid
continue
if solve(mid, p[0], p[1]) == OK:
ok = mid
else:
ng = mid
print(ok)
``` |
892_B. Wrath | Hands that shed innocent blood!
There are n guilty people in a line, the i-th of them holds a claw with length Li. The bell rings and every person kills some of people in front of him. All people kill others at the same time. Namely, the i-th person kills the j-th person if and only if j < i and j ≥ i - Li.
You are given lengths of the claws. You need to find the total number of alive people after the bell rings.
Input
The first line contains one integer n (1 ≤ n ≤ 106) — the number of guilty people.
Second line contains n space-separated integers L1, L2, ..., Ln (0 ≤ Li ≤ 109), where Li is the length of the i-th person's claw.
Output
Print one integer — the total number of alive people after the bell rings.
Examples
Input
4
0 1 0 10
Output
1
Input
2
0 0
Output
2
Input
10
1 1 3 0 0 0 2 1 0 3
Output
3
Note
In first sample the last person kills everyone in front of him. | ```python
n=int(input())
l=[0]*n
r=[0]*n
len=list(map(int,input().split()))
for i in range(n):
a=max(0,i-len[i])
b=max(a,i)
#print(' '.join(map(str,[i,a,b])))
l[a]+=1
r[b]+=1
ans=0
t=0
for i in range(n):
t+=l[i]
t-=r[i]
#print('t='+str(t))
if t==0:
#print('i='+str(i))
ans+=1
print(ans)
``` |
914_B. Conan and Agasa play a Card Game | Edogawa Conan got tired of solving cases, and invited his friend, Professor Agasa, over. They decided to play a game of cards. Conan has n cards, and the i-th card has a number ai written on it.
They take turns playing, starting with Conan. In each turn, the player chooses a card and removes it. Also, he removes all cards having a number strictly lesser than the number on the chosen card. Formally, if the player chooses the i-th card, he removes that card and removes the j-th card for all j such that aj < ai.
A player loses if he cannot make a move on his turn, that is, he loses if there are no cards left. Predict the outcome of the game, assuming both players play optimally.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of cards Conan has.
The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number on the i-th card.
Output
If Conan wins, print "Conan" (without quotes), otherwise print "Agasa" (without quotes).
Examples
Input
3
4 5 7
Output
Conan
Input
2
1 1
Output
Agasa
Note
In the first example, Conan can just choose the card having number 7 on it and hence remove all the cards. After that, there are no cards left on Agasa's turn.
In the second example, no matter which card Conan chooses, there will be one one card left, which Agasa can choose. After that, there are no cards left when it becomes Conan's turn again. | ```python
n=int(input())
l=list(map(int,input().split()))
dic={}
status=True
i=0
l.sort()
while i<len(l):
counter=0
while True:
if i<len(l)-1 and l[i+1]==l[i]:
i+=1
counter+=1
else:
break
i+=1
counter+=1
if counter%2==1:
status=False
print("Conan")
break
if status:
print("Agasa")
``` |
962_B. Students in Railway Carriage | There are n consecutive seat places in a railway carriage. Each place is either empty or occupied by a passenger.
The university team for the Olympiad consists of a student-programmers and b student-athletes. Determine the largest number of students from all a+b students, which you can put in the railway carriage so that:
* no student-programmer is sitting next to the student-programmer;
* and no student-athlete is sitting next to the student-athlete.
In the other words, there should not be two consecutive (adjacent) places where two student-athletes or two student-programmers are sitting.
Consider that initially occupied seat places are occupied by jury members (who obviously are not students at all).
Input
The first line contain three integers n, a and b (1 ≤ n ≤ 2⋅10^{5}, 0 ≤ a, b ≤ 2⋅10^{5}, a + b > 0) — total number of seat places in the railway carriage, the number of student-programmers and the number of student-athletes.
The second line contains a string with length n, consisting of characters "." and "*". The dot means that the corresponding place is empty. The asterisk means that the corresponding place is occupied by the jury member.
Output
Print the largest number of students, which you can put in the railway carriage so that no student-programmer is sitting next to a student-programmer and no student-athlete is sitting next to a student-athlete.
Examples
Input
5 1 1
*...*
Output
2
Input
6 2 3
*...*.
Output
4
Input
11 3 10
.*....**.*.
Output
7
Input
3 2 3
***
Output
0
Note
In the first example you can put all student, for example, in the following way: *.AB*
In the second example you can put four students, for example, in the following way: *BAB*B
In the third example you can put seven students, for example, in the following way: B*ABAB**A*B
The letter A means a student-programmer, and the letter B — student-athlete. | ```python
n,a,b = map(int,input().split())
s=a+b
ans = 0
for t in map(len, input().split('*')):
if a > b: a, b = b, a
a -= min(a , (t//2))
b -= min(b , (t - (t//2)))
print(s-a-b)
``` |
p02606 AIsing Programming Contest 2020 - Number of Multiples | How many multiples of d are there among the integers between L and R (inclusive)?
Constraints
* All values in input are integers.
* 1 \leq L \leq R \leq 100
* 1 \leq d \leq 100
Input
Input is given from Standard Input in the following format:
L R d
Output
Print the number of multiples of d among the integers between L and R (inclusive).
Examples
Input
5 10 2
Output
3
Input
6 20 7
Output
2
Input
1 100 1
Output
100 | ```python
l, r, d = map(int, input().split())
ans = (r // d) - ((l - 1) // d)
print(ans)
``` |
p02737 AtCoder Grand Contest 043 - Giant Graph | Given are simple undirected graphs X, Y, Z, with N vertices each and M_1, M_2, M_3 edges, respectively. The vertices in X, Y, Z are respectively called x_1, x_2, \dots, x_N, y_1, y_2, \dots, y_N, z_1, z_2, \dots, z_N. The edges in X, Y, Z are respectively (x_{a_i}, x_{b_i}), (y_{c_i}, y_{d_i}), (z_{e_i}, z_{f_i}).
Based on X, Y, Z, we will build another undirected graph W with N^3 vertices. There are N^3 ways to choose a vertex from each of the graphs X, Y, Z. Each of these choices corresponds to the vertices in W one-to-one. Let (x_i, y_j, z_k) denote the vertex in W corresponding to the choice of x_i, y_j, z_k.
We will span edges in W as follows:
* For each edge (x_u, x_v) in X and each w, l, span an edge between (x_u, y_w, z_l) and (x_v, y_w, z_l).
* For each edge (y_u, y_v) in Y and each w, l, span an edge between (x_w, y_u, z_l) and (x_w, y_v, z_l).
* For each edge (z_u, z_v) in Z and each w, l, span an edge between (x_w, y_l, z_u) and (x_w, y_l, z_v).
Then, let the weight of the vertex (x_i, y_j, z_k) in W be 1,000,000,000,000,000,000^{(i +j + k)} = 10^{18(i + j + k)}. Find the maximum possible total weight of the vertices in an independent set in W, and print that total weight modulo 998,244,353.
Constraints
* 2 \leq N \leq 100,000
* 1 \leq M_1, M_2, M_3 \leq 100,000
* 1 \leq a_i, b_i, c_i, d_i, e_i, f_i \leq N
* X, Y, and Z are simple, that is, they have no self-loops and no multiple edges.
Input
Input is given from Standard Input in the following format:
N
M_1
a_1 b_1
a_2 b_2
\vdots
a_{M_1} b_{M_1}
M_2
c_1 d_1
c_2 d_2
\vdots
c_{M_2} d_{M_2}
M_3
e_1 f_1
e_2 f_2
\vdots
e_{M_3} f_{M_3}
Output
Print the maximum possible total weight of an independent set in W, modulo 998,244,353.
Examples
Input
2
1
1 2
1
1 2
1
1 2
Output
46494701
Input
3
3
1 3
1 2
3 2
2
2 1
2 3
1
2 1
Output
883188316
Input
100000
1
1 2
1
99999 100000
1
1 100000
Output
318525248 | ```python
from collections import defaultdict
import sys
input = lambda: sys.stdin.readline().rstrip()
M = 998244353 # < (1 << 30)
def mod_inv(a, M=M):
x1, y1, z1 = 1, 0, a
x2, y2, z2 = 0, 1, M
while abs(z1) != 1:
d, m = divmod(z2, z1)
x1, x2 = x2-d*x1, x1
y1, y2 = y2-d*y1, y1
z1, z2 = m, z1
return x1*z1%M
R_bits = 30
R = 1 << R_bits
R_dec = R - 1
R2 = pow(R, 2, M)
M_neg_inv = mod_inv(-M, R)
def MR(x):
b = (x * M_neg_inv) & R_dec
t = x + b * M
c = t >> R_bits
d = c - M
return d if 0 <= d else c
def Montgomery(x):
return MR(x*R2)
def mex(s):
for i in range(N+1):
if i not in s:
return i
def calc_grundy(edge):
grundy = [{} for i in range(3)]
sum_g = [defaultdict(int, {0:M_W_sum}) for i in range(3)]
M_W = M_W_last
for i in range(N, 0, -1):
for g, s, e in zip(grundy, sum_g, edge):
if i in e:
m = mex({g.get(j, 0) for j in e[i]})
if m:
g[i] = m
s[g[i]] += M_W
s[0] -= M_W
M_W = MR(M_W * M_B_inv)
return sum_g
def read_edge():
M = int(input())
e = defaultdict(list)
for i in range(M):
a, b = sorted(map(int, input().split()))
e[a].append(b)
return e
N = int(input())
B = pow(10, 18, M)
M_B_inv = Montgomery(mod_inv(B))
M_W_last = Montgomery(pow(B, N, M))
M_W_sum = MR((M_W_last - Montgomery(1)) * MR(Montgomery(B) * Montgomery(mod_inv(B-1))))
edge = [read_edge() for i in range(3)]
sum_g = calc_grundy(edge)
ans = 0
for gx, sx in sum_g[0].items():
for gy, sy in sum_g[1].items():
gz = gx^gy
sz = sum_g[2][gz]
if sz:
ans += MR(MR(sx*sy)*sz)
print(MR(ans)%M)
``` |
p02871 Hitachi Hokudai Labo & Hokkaido University Contest 2019-1 - Problem A | Requirements
* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.
Input Format
Input is provided in the following form:
|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}
* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.
In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:
N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}
* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.
Output Format
The Output expects T_{\text{max}} integers in the format specified below.
\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}
In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:
1) `stay`, if the car shall not move:
-1
2) `move w`, if the car shall be moved one step towards the neighboring vertex w
w
Note that in case of 2) w has to satisfy the following conditions:
* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.
* * *
Examples
Input
Output
Input
5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0
Output
2
-1
1
5 | ```python
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
def dijkstra(s):
d = [float("inf")]*n
pre = [None]*n
d[s] = 0
q = [(0,s)]
while q:
dx,x = heappop(q)
for y,w in v[x]:
nd = dx+w
if nd < d[y]:
d[y] = nd
pre[y] = x
heappush(q,(nd,y))
path = [[i] for i in range(n)]
for i in range(n):
while path[i][-1] != s:
path[i].append(pre[path[i][-1]])
path[i] = path[i][::-1][1:]
return d,path
n,m = LI()
v = [[] for i in range(n)]
for i in range(m):
a,b,d = LI()
a -= 1
b -= 1
v[a].append((b,d))
v[b].append((a,d))
d = [None]*n
path = [None]*n
for s in range(n):
d[s],path[s] = dijkstra(s)
t = I()
q = deque()
for i in range(t):
N = I()
if N == 0:
continue
a,y = LI()
y -= 1
q.append((i,y))
x = 0
dx = 0
dy = 0
query = deque()
dst = 0
go = []
f = 0
time = [None]*n
fl = [0]*n
for i in range(t):
while go and not fl[go[0]]:
go.pop(0)
while q and q[0][0] == i:
k,l = q.popleft()
query.append(l)
if time[l] == None:
time[l] = k
if not f:
if x == 0:
if not query:
print(-1)
else:
f = 1
while query:
dst = query.popleft()
go.append(dst)
fl[dst] = 1
go = list(set(go))
go.sort(key = lambda a:time[a]+d[x][a])
time = [None]*n
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
print(y+1)
dx = 1
dy = d[x][y]
if dx == dy:
fl[y] = 0
x = y
dx = 0
if x == dst:
if go:
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
f = 0
dst = 0
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
y = p.pop(0)
dy = d[x][y]
else:
print(y+1)
dx += 1
if dx == dy:
fl[y] = 0
x = y
dx = 0
if p:
y = p.pop(0)
dy = d[x][y]
else:
print(y+1)
dx += 1
if dx == dy:
fl[y] = 0
x = y
dx = 0
if x == dst:
if go:
dst = go.pop(0)
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
f = 0
dst = 0
p = [i for i in path[x][dst]]
y = p.pop(0)
dy = d[x][y]
else:
y = p.pop(0)
dy = d[x][y]
return
#Solve
if __name__ == "__main__":
solve()
``` |
p03006 diverta 2019 Programming Contest 2 - Picking Up | There are N balls in a two-dimensional plane. The i-th ball is at coordinates (x_i, y_i).
We will collect all of these balls, by choosing two integers p and q such that p \neq 0 or q \neq 0 and then repeating the following operation:
* Choose a ball remaining in the plane and collect it. Let (a, b) be the coordinates of this ball. If we collected a ball at coordinates (a - p, b - q) in the previous operation, the cost of this operation is 0. Otherwise, including when this is the first time to do this operation, the cost of this operation is 1.
Find the minimum total cost required to collect all the balls when we optimally choose p and q.
Constraints
* 1 \leq N \leq 50
* |x_i|, |y_i| \leq 10^9
* If i \neq j, x_i \neq x_j or y_i \neq y_j.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
:
x_N y_N
Output
Print the minimum total cost required to collect all the balls.
Examples
Input
2
1 1
2 2
Output
1
Input
3
1 4
4 6
7 8
Output
1
Input
4
1 1
1 2
2 1
2 2
Output
2 | ```python
from collections import defaultdict as ddict
d = ddict(int)
d[0] = 0
n = int(input())
l = [tuple(map(int, input().split())) for _ in range(n)]
l.sort()
for i in range(n-1):
for j in range(i+1,n):
curx = l[j][0] - l[i][0]
cury = l[j][1] - l[i][1]
d[(curx,cury)] += 1
print(n-max(d.values()))
``` |
p03146 AtCoder Beginner Contest 116 - Collatz Problem | A sequence a=\\{a_1,a_2,a_3,......\\} is determined as follows:
* The first term s is given as input.
* Let f(n) be the following function: f(n) = n/2 if n is even, and f(n) = 3n+1 if n is odd.
* a_i = s when i = 1, and a_i = f(a_{i-1}) when i > 1.
Find the minimum integer m that satisfies the following condition:
* There exists an integer n such that a_m = a_n (m > n).
Constraints
* 1 \leq s \leq 100
* All values in input are integers.
* It is guaranteed that all elements in a and the minimum m that satisfies the condition are at most 1000000.
Input
Input is given from Standard Input in the following format:
s
Output
Print the minimum integer m that satisfies the condition.
Examples
Input
8
Output
5
Input
7
Output
18
Input
54
Output
114 | ```python
s=int(input())
a=[]
ans=1
while True:
a.append(s)
if s%2==0:
s//=2
else:
s=s*3+1
ans+=1
if s in a:
print(ans)
break
``` |
p03290 AtCoder Beginner Contest 104 - All Green | A programming competition site AtCode provides algorithmic problems. Each problem is allocated a score based on its difficulty. Currently, for each integer i between 1 and D (inclusive), there are p_i problems with a score of 100i points. These p_1 + … + p_D problems are all of the problems available on AtCode.
A user of AtCode has a value called total score. The total score of a user is the sum of the following two elements:
* Base score: the sum of the scores of all problems solved by the user.
* Perfect bonuses: when a user solves all problems with a score of 100i points, he/she earns the perfect bonus of c_i points, aside from the base score (1 ≤ i ≤ D).
Takahashi, who is the new user of AtCode, has not solved any problem. His objective is to have a total score of G or more points. At least how many problems does he need to solve for this objective?
Constraints
* 1 ≤ D ≤ 10
* 1 ≤ p_i ≤ 100
* 100 ≤ c_i ≤ 10^6
* 100 ≤ G
* All values in input are integers.
* c_i and G are all multiples of 100.
* It is possible to have a total score of G or more points.
Input
Input is given from Standard Input in the following format:
D G
p_1 c_1
:
p_D c_D
Output
Print the minimum number of problems that needs to be solved in order to have a total score of G or more points. Note that this objective is always achievable (see Constraints).
Examples
Input
2 700
3 500
5 800
Output
3
Input
2 2000
3 500
5 800
Output
7
Input
2 400
3 500
5 800
Output
2
Input
5 25000
20 1000
40 1000
50 1000
30 1000
1 1000
Output
66 | ```python
D,G = map(int,input().split())
PC = [0]+[list(map(int,input().split()))for i in range(D)]
def f(p,c):
if p==0:
return 10**9
m=min(c//(p*100),PC[p][0])
s=100*p*m
if m==PC[p][0]:
s+=PC[p][1]
if s<c:
m+=f(p-1,c-s)
return min(m,f(p-1,c))
print(f(D,G))
``` |
p03606 AtCoder Beginner Contest 073 - Theater | Joisino is working as a receptionist at a theater.
The theater has 100000 seats, numbered from 1 to 100000.
According to her memo, N groups of audiences have come so far, and the i-th group occupies the consecutive seats from Seat l_i to Seat r_i (inclusive).
How many people are sitting at the theater now?
Constraints
* 1≤N≤1000
* 1≤l_i≤r_i≤100000
* No seat is occupied by more than one person.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
l_1 r_1
:
l_N r_N
Output
Print the number of people sitting at the theater.
Examples
Input
1
24 30
Output
7
Input
2
6 8
3 3
Output
4 | ```python
print(sum(1-eval(s.replace(' ','-'))for s in open(0).readlines()[1:]))
``` |
p03767 AtCoder Grand Contest 012 - AtCoder Group Contest | There are 3N participants in AtCoder Group Contest. The strength of the i-th participant is represented by an integer a_i. They will form N teams, each consisting of three participants. No participant may belong to multiple teams.
The strength of a team is defined as the second largest strength among its members. For example, a team of participants of strength 1, 5, 2 has a strength 2, and a team of three participants of strength 3, 2, 3 has a strength 3.
Find the maximum possible sum of the strengths of N teams.
Constraints
* 1 ≤ N ≤ 10^5
* 1 ≤ a_i ≤ 10^{9}
* a_i are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_{3N}
Output
Print the answer.
Examples
Input
2
5 2 8 5 1 5
Output
10
Input
10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000
Output
10000000000 | ```python
N = int(input())
A = list(map(int, input().split()))
A.sort()
print(sum(A[N:3 * N:2]))
``` |
p03935 square869120Contest #3 - Sum of Fibonacci Sequence | E869120 defined a sequence $a$ like this:
* $a_1=a_2=1$, $a_{k+2}=a_{k+1}+a_k \ (k \ge 1)$
He also defined sequences $d_1, d_2, d_3, \dots , d_n$, as the following recurrence relation :
* $d_{1, j} = a_j$
* $d_{i, j} = \sum_{k = 1}^j d_{i - 1, k} \ (i \ge 2)$
You are given integers $n$ and $m$. Please calculate the value of $d_{n, m}$.
Since the answer can be large number, print the answer modulo $998,244,353$.
Can you solve this problem???
Input
The input is given from standard input in the following format.
> $n \quad m$
Output
* Print $d_{n, m}$ modulo $998,244,353$.
Constraints
* $1 \le n \le 200,000$
* $1 \le m \le 10^{18}$
Subtasks
Subtask 1 [ $100$ points ]
* The testcase in this subtask satisfies $1 \le n, m \le 3,000$.
Subtask 2 [ $170$ points ]
* The testcase in this subtask satisfies $1 \le m \le 200,000$.
Subtask 3 [ $230$ points ]
* The testcase in this subtask satisfies $1 \le n \le 3$.
Subtask 4 [ $420$ points ]
* The testcase in this subtask satisfies $1 \le n \le 1000$.
Subtask 5 [ $480$ points ]
* There are no additional constraints.
Output
* Print $d_{n, m}$ modulo $998,244,353$.
Constraints
* $1 \le n \le 200,000$
* $1 \le m \le 10^{18}$
Subtasks
Subtask 1 [ $100$ points ]
* The testcase in this subtask satisfies $1 \le n, m \le 3,000$.
Subtask 2 [ $170$ points ]
* The testcase in this subtask satisfies $1 \le m \le 200,000$.
Subtask 3 [ $230$ points ]
* The testcase in this subtask satisfies $1 \le n \le 3$.
Subtask 4 [ $420$ points ]
* The testcase in this subtask satisfies $1 \le n \le 1000$.
Subtask 5 [ $480$ points ]
* There are no additional constraints.
Input
The input is given from standard input in the following format.
> $n \quad m$
Examples
Input
4 7
Output
176
Input
12 20
Output
174174144
Input
16 30
Output
102292850 | ```python
M=998244353
g=lambda a,b:[(a[0]*b[0]+a[1]*b[2])%M,(a[0]*b[1]+a[1]*b[3])%M,(a[2]*b[0]+a[3]*b[2])%M,(a[2]*b[1]+a[3]*b[3])%M]
def f(n):
e=[1,0,0,1];z=[1,1,1,0]
while n:
if n%2>0:e=g(e,z)
z=g(z,z);n//=2
return e[1]
n,m=map(int,input().split());I=[1,1];r=f(m+2*n-2);c=1
for i in range(2,n):I+=[(M-M//i)*I[M%i]%M]
for i in range(n-1):r=(r+c*(M-f(2*n-2-2*i)))%M;c=c*(m+i)*I[i+1]%M
print(r)
``` |
p00028 Mode Value | Your task is to write a program which reads a sequence of integers and prints mode values of the sequence. The mode value is the element which occurs most frequently.
Input
A sequence of integers ai (1 ≤ ai ≤ 100). The number of integers is less than or equals to 100.
Output
Print the mode values. If there are several mode values, print them in ascending order.
Example
Input
5
6
3
5
8
7
5
3
9
7
3
4
Output
3
5 | ```python
if __name__ == '__main__':
ans = dict()
while True:
try:
n = int(input())
if n not in ans:
ans[n] = 1
else:
ans[n] += 1
except EOFError:
break
a = max(ans.values())
A = []
for d in ans:
if ans[d] == a:
A.append(d)
B = sorted(A)
for i in B:
print(i)
``` |
p00159 The Best Body | There is BMI (Body Mass Index) as an index showing the degree of obesity. The BMI value is calculated using the following formula.
BMI = weight (kg) / (height (m)) 2
The closer the BMI value is to the standard value, the more "ideal body shape" is considered. Therefore, if the standard value of BMI is 22, create a program that inputs the information of the target person and outputs the information of the person closest to the "ideal body shape".
Assuming that the number of target persons is n, each target person is assigned a reception number p that is an integer value between 1 and n so that there is no duplication.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
p1 h1 w1
p2 h2 w2
::
pn hn wn
Number of subjects n (n ≤ 1000) on the first line, reception number pi (1 ≤ pi ≤ n) of the i-th subject on the following n lines, height hi in centimeters (1 ≤ hi ≤ 200), Given a kilogram of body weight wi (1 ≤ wi ≤ 200). All inputs are given as integers.
Output
For each data set, the reception number (integer) of the person closest to the "ideal body shape" is output on one line. If there are two or more people who are closest to the "ideal body shape", the one with the smaller reception number will be output.
Example
Input
6
1 165 66
2 178 60
3 180 72
4 160 65
5 185 62
6 182 62
3
3 160 65
2 180 70
1 170 75
0
Output
3
2 | ```python
# from sys import exit
while(True):
N = int(input())
if N == 0:
break
L = []
for i in range(N):
p, h, w = [int(n) for n in input().split()]
L.append((p, abs(22- w/((h/100)**2))))
# print(abs(22- w/((h/100)**2)))
L = sorted(L, key=lambda x: x[1])
print(L[0][0])
``` |
p00316 Investigation of Club Activities | Akira, the student council president of A High School, decided to investigate which club activities the A High School students belong to. A High School has N students numbered 1 to N and M types of club activities numbered 1 to M. There is no limit to the number of people in each club activity, and there can be 0 club activities. However, according to the school rules of A High School, students can only belong to one club activity. All students follow this school rule.
Akira asked student members to investigate and obtained records for line K, such as each line being one of the following:
* Student a and student b belong to the same club activities.
* Student c belongs to club activity x.
However, there may be a contradiction in this record that would cause someone to violate school rules. Akira decided to look at the first line in order and look for the first line that could be judged to be inconsistent.
Create a program that finds the number of the first line that can be determined to be inconsistent given a record of K lines.
Input
The input is given in the following format.
NMK
record1
record2
::
recordK
The first line gives the number of students N (1 ≤ N ≤ 100000), the number of club activity types M (1 ≤ M ≤ 100000), and the number of recorded lines K (1 ≤ K ≤ 200000). Each line of record, recordi, is given in the following K lines in one of the following formats:
1 a b
Or
2 c x
When the first digit is "1", it indicates that student a (1 ≤ a ≤ N) and student b (1 ≤ b ≤ N) belong to the same club activity. However, a ≠ b.
When the first digit is "2", it indicates that student c (1 ≤ c ≤ N) belongs to club activity x (1 ≤ x ≤ M).
Output
Output the number of the first line that can be determined to be inconsistent on one line. If not found, output 0 on one line.
Examples
Input
3 2 5
1 1 2
1 2 3
2 1 1
2 3 2
2 2 1
Output
4
Input
3 2 4
1 1 2
2 1 1
2 3 2
2 2 1
Output
0
Input
3 2 2
1 1 2
2 1 1
Output
0 | ```python
n, m, k = map(int, input().split())
*parent, = range(n+m)
def root(x):
if x == parent[x]:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
px = root(x); py = root(y)
if px < py:
parent[py] = px
else:
parent[px] = py
for i in range(k):
a, b, c = map(int, input().split())
b -= 1; c -= 1
if a == 1:
pb = root(m+b); pc = root(m+c)
if pb < m and pc < m and pb != pc:
print(i+1)
break
unite(pb, pc)
else:
pb = root(m+b)
if pb < m and pb != c:
print(i+1)
break
unite(c, pb)
else:
print(0)
``` |
p00486 Walking Santa | At the end of last year, Santa Claus forgot to give Christmas presents to the children in JOI village. Therefore, I decided to deliver the chocolate cake to the children as an apology. The day to deliver is approaching tomorrow, so it's time to come up with a move plan.
JOI village is divided into a grid shape by W roads extending straight in the north-south direction and H roads extending straight in the east-west direction. The W roads in the north-south direction are west. The numbers 1, 2, ..., W are numbered in order from the south, and the H roads in the east-west direction are numbered 1, 2, ..., H in order from the south. The intersection of the xth north-south road and the yth east-west road from the south is represented by (x, y). There are N houses in JOI village, and they are located at one of the intersections. Santa Claus can only move along the road. The time it takes to move between adjacent intersections is 1.
Every house in JOI village has children, so Santa Claus has to deliver one chocolate cake to every house in JOI village. It's a little to fly with a reindeer with an important chocolate cake. Being dangerous, Santa Claus and Reindeer landed at one of the intersections in JOI Village, where Santa Claus decided to walk to deliver the chocolate cake. Santa Claus would not carry more than one chocolate cake at the same time. In other words, Santa Claus returns to the intersection where he landed every time he delivered a chocolate cake to a house.
Santa Claus decided to choose a travel plan that would minimize the time it took to deliver the chocolate cake to all homes after landing in JOI Village. Note that the time it takes to return to the intersection after delivering the chocolate cake to the last house is not included in the time required. Also, I don't think about anything other than the time it takes to move.
input
Read the following input from standard input.
* On the first line, the integers W and H, which represent the number of roads in each direction, are written with blanks as delimiters.
* The second line contains the integer N, which represents the number of houses.
* The following N lines contain information on the location of the house. On the second line of i + (1 ≤ i ≤ N), the integers Xi and Yi are written separated by blanks, indicating that the i-th house is located at the intersection (Xi, Yi). These N intersections are all different.
output
Output the following data to standard output.
* The first line must contain one integer that represents the minimum required time.
* On the second line, when the intersection to be landed to minimize the required time is (x, y), the two integers x, y must be written in this order, separated by blanks. If there are multiple suitable intersections, the westernmost one (that is, the value of x is small), and if it is still not one, the one that is the southernmost (that is, the value of y is small). ) Choose an intersection.
Example
Input
5 4
3
1 1
3 4
5 3
Output
10
3 3 | ```python
from bisect import bisect_left as bl
INF = 10 ** 20
def main():
w, h = map(int, input().split())
n = int(input())
xlst = []
ylst = []
appx = xlst.append
appy = ylst.append
for i in range(n):
x, y = map(int,input().split())
appx(x)
appy(y)
sorted_xlst = sorted(xlst)
sorted_ylst = sorted(ylst)
accx = accy = 0
cum_sum_xlst = []
cum_sum_ylst = []
appx = cum_sum_xlst.append
appy = cum_sum_ylst.append
for i in range(n):
accx += sorted_xlst[i]
accy += sorted_ylst[i]
appx(accx)
appy(accy)
if n % 2:
clx = crx = sorted_xlst[n // 2]
cly = cry = sorted_ylst[n // 2]
else:
clx = sorted_xlst[n // 2 - 1]
crx = sorted_xlst[n // 2]
cly = sorted_ylst[n // 2 - 1]
cry = sorted_ylst[n // 2]
plx = bl(sorted_xlst, clx)
prx = bl(sorted_xlst, crx)
ply = bl(sorted_ylst, cly)
pry = bl(sorted_ylst, cry)
xllen = (accx - cum_sum_xlst[plx - 1] * 2 - clx * (n - plx * 2)) * 2 if plx != 0 else (accx - clx * n) * 2
xrlen = (accx - cum_sum_xlst[prx - 1] * 2 - crx * (n - prx * 2)) * 2 if prx != 0 else (accx - crx * n) * 2
yllen = (accy - cum_sum_ylst[ply - 1] * 2 - cly * (n - ply * 2)) * 2 if ply != 0 else (accy - cly * n) * 2
yrlen = (accy - cum_sum_ylst[pry - 1] * 2 - cry * (n - pry * 2)) * 2 if pry != 0 else (accy - cry * n) * 2
ans = ansx = ansy = INF
max_sumd = 0
for i in range(n):
xi = xlst[i]
yi = ylst[i]
if xi <= clx:
cx = crx
xlen = xrlen
else:
cx = clx
xlen = xllen
if yi <= cly:
cy = cry
ylen = yrlen
else:
cy = cly
ylen = yllen
dx = xi - cx
if dx < 0:
dx = -dx
dy = yi - cy
if dy < 0:
dy = -dy
if max_sumd > dx + dy:
continue
else:
max_sumd = dx + dy
tlen = xlen + ylen - max_sumd
if ans > tlen:
ans = tlen
ansx = cx
ansy = cy
elif ans == tlen:
if ansx > cx:
ansx = cx
ansy = cy
elif ansx == cx:
if ansy > cy:
ansy = cy
print(ans)
print(ansx, ansy)
main()
``` |
p00815 Map of Ninja House | An old document says that a Ninja House in Kanazawa City was in fact a defensive fortress, which was designed like a maze. Its rooms were connected by hidden doors in a complicated manner, so that any invader would become lost. Each room has at least two doors.
The Ninja House can be modeled by a graph, as shown in Figure l. A circle represents a room. Each line connecting two circles represents a door between two rooms.
<image> Figure l. Graph Model of Ninja House. | Figure 2. Ninja House exploration.
---|---
I decided to draw a map, since no map was available. Your mission is to help me draw a map from the record of my exploration.
I started exploring by entering a single entrance that was open to the outside. The path I walked is schematically shown in Figure 2, by a line with arrows. The rules for moving between rooms are described below.
After entering a room, I first open the rightmost door and move to the next room. However, if the next room has already been visited, I close the door without entering, and open the next rightmost door, and so on. When I have inspected all the doors of a room, I go back through the door I used to enter the room.
I have a counter with me to memorize the distance from the first room. The counter is incremented when I enter a new room, and decremented when I go back from a room. In Figure 2, each number in parentheses is the value of the counter when I have entered the room, i.e., the distance from the first room. In contrast, the numbers not in parentheses represent the order of my visit.
I take a record of my exploration. Every time I open a door, I record a single number, according to the following rules.
1. If the opposite side of the door is a new room, I record the number of doors in that room, which is a positive number.
2. If it is an already visited room, say R, I record ``the distance of R from the first room'' minus ``the distance of the current room from the first room'', which is a negative number.
In the example shown in Figure 2, as the first room has three doors connecting other rooms, I initially record ``3''. Then when I move to the second, third, and fourth rooms, which all have three doors, I append ``3 3 3'' to the record. When I skip the entry from the fourth room to the first room, the distance difference ``-3'' (minus three) will be appended, and so on. So, when I finish this exploration, its record is a sequence of numbers ``3 3 3 3 -3 3 2 -5 3 2 -5 -3''.
There are several dozens of Ninja Houses in the city. Given a sequence of numbers for each of these houses, you should produce a graph for each house.
Input
The first line of the input is a single integer n, indicating the number of records of Ninja Houses I have visited. You can assume that n is less than 100. Each of the following n records consists of numbers recorded on one exploration and a zero as a terminator. Each record consists of one or more lines whose lengths are less than 1000 characters. Each number is delimited by a space or a newline. You can assume that the number of rooms for each Ninja House is less than 100, and the number of doors in each room is less than 40.
Output
For each Ninja House of m rooms, the output should consist of m lines. The j-th line of each such m lines should look as follows:
i r1 r2 ... rki
where r1, ... , rki should be rooms adjoining room i, and ki should be the number of doors in room i. Numbers should be separated by exactly one space character. The rooms should be numbered from 1 in visited order. r1, r2, ... , rki should be in ascending order. Note that the room i may be connected to another room through more than one door. In this case, that room number should appear in r1, ... , rki as many times as it is connected by different doors.
Example
Input
2
3 3 3 3 -3 3 2 -5 3 2 -5 -3 0
3 5 4 -2 4 -3 -2 -2 -1 0
Output
1 2 4 6
2 1 3 8
3 2 4 7
4 1 3 5
5 4 6 7
6 1 5
7 3 5 8
8 2 7
1 2 3 4
2 1 3 3 4 4
3 1 2 2 4
4 1 2 2 3 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f():
a = LI()
while a[-1] != 0:
a += LI()
r = [[]]
c = 0
nk = [a[0]]
d = {}
d[0] = 0
for n in a[1:]:
if n == 0:
break
while nk[d[c]] < 1:
c -= 1
if n < 0:
dc = d[c]
dn = d[c+n]
r[dn].append(dc)
r[dc].append(dn)
nk[dn] -= 1
nk[dc] -= 1
else:
nk.append(n-1)
dc = d[c]
ni = len(nk) - 1
r[dc].append(ni)
r.append([dc])
nk[dc] -= 1
c += 1
d[c] = ni
rr = []
for i in range(len(nk)):
rr.append('{} {}'.format(i+1, ' '.join(map(lambda x: str(x+1), sorted(r[i])))))
return '\n'.join(rr)
while 1:
n = I()
if n == 0:
break
rr = [f() for _ in range(n)]
break
return '\n'.join(map(str, rr))
print(main())
``` |
p00946 Rearranging a Sequence | Example
Input
5 3
4
2
5
Output
5
2
4
1
3 | ```python
n, m = map(int, input().split())
E = [int(input()) for i in range(m)]
s = set()
E.reverse()
F = []
for e in E:
if e in s:
continue
s.add(e)
F.append(e)
for i in range(1, n+1):
if i in s:
continue
F.append(i)
*_,=map(print,F)
``` |
p01213 Repeated Subsequences | You are a treasure hunter traveling around the world. Finally, you’ve got an ancient text indicating the place where the treasure was hidden. The ancient text looks like a meaningless string of characters at first glance. Actually, the secret place is embedded as the longest repeated subsequence of the text.
Well, then, what is the longest repeated subsequence of a string? First, you split the given string S into two parts F and R. Then, you take the longest common subsequence L of F and R (longest string L that is a subsequence of both F and R). Since there are many possible ways to split S into two parts, there are many possible L's. The longest repeated subsequence is the longest one among them. For example, the longest repeated subsequence of “ABCABCABAB” is “ABAB”, which is obtained when you split “ABCABCABAB” into “ABCABC” and “ABAB”.
Now your task is clear. Please find the longest repeated subsequence and get the hidden treasure!
Input
The input consists of multiple data sets. Each data set comes with a single line that contains one string of up to 300 capital letters. It is guaranteed that there is at least one repeated subsequence in each string.
The end of input is indicated by a line that contains “#END”. This line should not be processed.
Output
For each data set, print the longest repeated subsequence on a line. If there are multiple longest subsequence, print any one of them.
Examples
Input
ABCABCABAB
ZZZZZZZZZZZZ
#END
Output
ABAB
ZZZZZZ
Input
ABCABCABAB
ZZZZZZZZZZZZ
END
Output
ABAB
ZZZZZZ | ```python
def lcs(x, y, pre_lcs, pre_lcs_len):
pm = dict((zip('ABCDEFGHIJKLMNOPQRSTUVWXYZ', [0] * 26)))
for c in pm:
for i, xc in enumerate(x):
if c == xc:
pm[c] |= (1 << i)
V = (1 << len(x)) - 1
rec = []
for yc in y:
V = ((V + (V & pm[yc])) | (V & ~pm[yc]))
rec.append(bin(V)[-len(x):])
lcs_len = bin(V)[-len(x):].count('0')
if lcs_len > pre_lcs_len:
rx = x[::-1]
lcs = ''
idx = 0
for v, yc in zip(rec[::-1], reversed(y)):
idx = v.find('0', idx)
if yc == rx[idx]:
lcs += yc
if len(lcs) == lcs_len:
return (lcs[::-1], lcs_len)
idx += 1
else:
return (pre_lcs, pre_lcs_len)
from sys import stdin
def solve():
file_input = stdin
ans_out = []
for s in file_input:
s = s.rstrip()
if s[0] == '#':
break
s_len = len(s)
sep = s_len // 2
ans, ans_len = lcs(s[:sep], s[sep:], '', 0)
while sep > ans_len:
ans, ans_len = lcs(s[:-sep], s[-sep:], ans, ans_len)
sep -= 1
ans, ans_len = lcs(s[:sep], s[sep:], ans, ans_len)
ans_out.append(ans)
print(*ans_out, sep='\n')
solve()
``` |
p01349 Ennichi | A rabbit who came to the fair found that the prize for a game at a store was a carrot cake. The rules for this game are as follows.
There is a grid-like field of vertical h squares x horizontal w squares, and each block has at most one block. Each block is a color represented by one of the uppercase letters ('A'-'Z'). When n or more blocks of the same color are lined up in a straight line vertically or horizontally, those blocks disappear.
Participants can select two adjacent cells next to each other and switch their states to each other. When blocks are exchanged, disappeared, or dropped and there are no blocks in the cell below the cell with the block, this block At this time, it disappears when n or more blocks of the same color are lined up again. However, the disappearance of the blocks does not occur while the falling blocks exist, and occurs at the same time when all the blocks have finished falling.
If you eliminate all the blocks on the field with one operation, this game will be successful and you will get a free gift cake. Rabbit wants to get the cake with one entry fee, can not do it If you don't want to participate. From the state of the field at the beginning of the game, answer if the rabbit should participate in this game.
Input
The first line of input is given h, w, n separated by spaces.
2 ≤ h, w, n ≤ 30
In the following h lines, the state of the field is given in order from the top. Uppercase letters represent blocks, and'.' Represents an empty space. The state of the given field is n or more consecutive blocks of the same color in the vertical or horizontal direction. No, no blocks are in a falling state. There is one or more blocks.
Output
Output "YES" if the rabbit should participate in this game, otherwise output "NO" on one line.
Examples
Input
4 6 3
......
...Y..
...Y..
RRYRYY
Output
YES
Input
4 6 3
......
...Y..
...Y..
RRYRY.
Output
NO | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
h,w,n = LI()
a = [S() for _ in range(h)]
def f(i,j):
if a[i][j] == a[i][j+1]:
return False
b = [[c for c in s] for s in a]
b[i][j],b[i][j+1] = b[i][j+1],b[i][j]
ff = True
while ff:
ff = False
for i in range(h-2,-1,-1):
for j in range(w):
if b[i][j] == '.':
continue
for k in range(i,h-1):
if b[k+1][j] == '.':
b[k+1][j],b[k][j] = b[k][j],b[k+1][j]
else:
break
t = [[None]*w for _ in range(h)]
for i in range(h):
for j in range(w):
if b[i][j] == '.':
continue
tf = True
for k in range(1,n):
if i+k >= h or b[i+k][j] != b[i][j]:
tf = False
break
if tf:
for k in range(n):
t[i+k][j] = 1
tf = True
for k in range(1,n):
if j+k >= w or b[i][j+k] != b[i][j]:
tf = False
break
if tf:
for k in range(n):
t[i][j+k] = 1
for i in range(h):
for j in range(w):
if t[i][j] is None:
continue
b[i][j] = '.'
ff = True
for i in range(h):
for j in range(w):
if b[i][j] != '.':
return False
return True
r = 'NO'
for i in range(h):
for j in range(w-1):
if f(i,j):
r = 'YES'
break
rr.append(r)
break
return '\n'.join(map(str, rr))
print(main())
``` |
p01531 Flick Input | A: Flick input
A college student who loves 2D, commonly known as 2D, replaced his long-used Galapagos mobile phone with a smartphone. 2D, who operated the smartphone for the first time, noticed that the character input method was a little different from that of old mobile phones. On smartphones, a method called flick input was adopted by taking advantage of the fact that the screen can be touch-flicked (flick means "the operation of sliding and flipping a finger on the screen"). Flick input is a character input method as shown below.
In flick input, as shown in Fig. A (a), input is performed using 10 buttons 0-9 (# and * are omitted this time). Each button is assigned one row-row row as shown in the figure.
<image>
---
Figure A: Smartphone button details
One button can be operated by the method shown in Fig. A (b). In other words
* If you just "touch" a button, the character "Adan" corresponding to that button will be output.
* Press the button "flick to the left" to output "Idan"
* When you press the button "flick upward", "Udan" is output.
* Press the button "flick to the right" to output "Edan"
* Press the button "flick down" to output "step"
That's what it means. Figure A (c) shows how to input flicks for all buttons. Note that you flick button 0 upwards to output "n".
Your job is to find the string that will be output as a result of a flick input operation, given a string that indicates that operation.
Input
A character string representing a flick input operation is given on one line (2 to 1000 characters). This character string consists of the numbers '0'-'9', which represent the buttons to be operated, and the five types of characters,'T',' L',' U',' R', and'D', which represent the flick direction. It consists of a combination.
The characters that represent the flick direction have the following meanings.
*'T': Just touch
*'L': Flick left
*'U': Flick up
*'R': Flick right
*'D': Flick down
For example, "2D" represents the operation of "flicking the button of 2 downward", so "ko" can be output.
In the given character string, one number and one character indicating the flick direction appear alternately. Also, it always starts with one number and ends with one letter indicating the flick direction. Furthermore, in Fig. A (c), flicking is not performed toward a place without characters (there is no input such as "8L").
Output
Output the character string representing the result of the flick input operation in Roman characters.
For romaji consonants,
* Or line:'k'
* Sayuki:'s'
* Ta line:'t'
* Line:'n'
* Is the line:'h'
* Ma line:'m'
* Ya line:'y'
* Line:'r'
* Wa line:'w'
to use. Romaji, which represents one hiragana character, should be output as a set of the consonants and vowels ('a','i','u','e','o') represented above. "shi" and "fu" are wrong because they violate this condition. However, the character "A line" should output only one vowel character, and "n" should output "n" twice in a row as "nn".
Output a line break at the end of the character string.
Sample Input 1
5R2D
Sample Output 1
neko
Sample Input 2
8U9U6U0T
Sample Output 2
yuruhuwa
Sample Input 3
9L4U7R1L2D0U4R3U4D
Sample Output 3
ritumeikonntesuto
Example
Input
5R2D
Output
neko | ```python
flicks = {
"T": "a",
"L": "i",
"U": "u",
"R": "e",
"D": "o"
}
buttons = {
"1": "",
"2": "k",
"3": "s",
"4": "t",
"5": "n",
"6": "h",
"7": "m",
"8": "y",
"9": "r",
"0": "w"
}
def get_word(button, flick):
if button == "0" and flick == "U":
return "nn"
return buttons[button] + flicks[flick]
cmds = input()
result = ""
for i in range(0, len(cmds), 2):
result += get_word(cmds[i], cmds[i+1])
print(result)
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.