name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
p02925 AtCoder Beginner Contest 139 - League | N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | ```python
n=int(input());l=[list(map(int,input().split()))for i in[0]*n];a=[0]*n;d=1;k=n*(n-1)
while sum(a)<k and d<9999:
L=[0]*n;y=0;d+=1
for i in range(n):
if a[i]<n-1:
x=l[i][a[i]]-1
if l[x][a[x]]-1==i and L[x]+L[i]<1:
a[i]+=1;a[x]+=1;L[i]=L[x]=y=1
d*=y;print([k//2,d-1][d<9999])
``` |
p03060 AtCoder Beginner Contest 125 - Resale | There are N gems. The value of the i-th gem is V_i.
You will choose some of these gems, possibly all or none, and get them.
However, you need to pay a cost of C_i to get the i-th gem.
Let X be the sum of the values of the gems obtained, and Y be the sum of the costs paid.
Find the maximum possible value of X-Y.
Constraints
* All values in input are integers.
* 1 \leq N \leq 20
* 1 \leq C_i, V_i \leq 50
Input
Input is given from Standard Input in the following format:
N
V_1 V_2 ... V_N
C_1 C_2 ... C_N
Output
Print the maximum possible value of X-Y.
Examples
Input
3
10 2 5
6 3 4
Output
5
Input
4
13 21 6 19
11 30 6 15
Output
6
Input
1
1
50
Output
0 | ```python
n = int(input())
Vi = map(int, input().split())
Ci = map(int, input().split())
print(sum([max(0, v-c) for (v, c) in zip(Vi, Ci)]))
``` |
p03351 AtCoder Beginner Contest 097 - Colorful Transceivers | Three people, A, B and C, are trying to communicate using transceivers. They are standing along a number line, and the coordinates of A, B and C are a, b and c (in meters), respectively. Two people can directly communicate when the distance between them is at most d meters. Determine if A and C can communicate, either directly or indirectly. Here, A and C can indirectly communicate when A and B can directly communicate and also B and C can directly communicate.
Constraints
* 1 ≤ a,b,c ≤ 100
* 1 ≤ d ≤ 100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
a b c d
Output
If A and C can communicate, print `Yes`; if they cannot, print `No`.
Examples
Input
4 7 9 3
Output
Yes
Input
100 10 1 2
Output
No
Input
10 10 10 1
Output
Yes
Input
1 100 2 10
Output
Yes | ```python
a,b,c,d = list(map(int,input().split()))
print('Yes' if (abs(a-b)<=d and abs(b-c)<=d) or abs(a-c)<=d else 'No')
``` |
p03511 Code Festival Team Relay (Parallel) - Coinage | You are given two strings s and t consisting of lowercase English letters and an integer L.
We will consider generating a string of length L by concatenating one or more copies of s and t. Here, it is allowed to use the same string more than once.
For example, when s = `at`, t = `code` and L = 6, the strings `atatat`, `atcode` and `codeat` can be generated.
Among the strings that can be generated in this way, find the lexicographically smallest one. In the cases given as input, it is always possible to generate a string of length L.
Constraints
* 1 ≤ L ≤ 2 × 10^5
* 1 ≤ |s|, |t| ≤ L
* s and t consist of lowercase English letters.
* It is possible to generate a string of length L in the way described in Problem Statement.
Input
Input is given from Standard Input in the following format:
N
x_1 s_1
x_2 s_2
:
x_N s_N
Output
Print the lexicographically smallest string among the ones that can be generated in the way described in Problem Statement.
Examples
Input
6
at
code
Output
atatat
Input
8
coding
festival
Output
festival
Input
8
same
same
Output
samesame
Input
10
coin
age
Output
ageagecoin | ```python
L = int(input())
s = input()
t = input()
if not s+t <= t+s:
s, t = t, s
ls = len(s); lt = len(t)
for i in range(L // ls, -1, -1):
if (L - ls*i) % lt == 0:
ans = s * i + t * ((L - ls*i) // lt)
break
print(ans)
``` |
p03672 AtCoder Beginner Contest 066 - ss | We will call a string that can be obtained by concatenating two equal strings an even string. For example, `xyzxyz` and `aaaaaa` are even, while `ababab` and `xyzxy` are not.
You are given an even string S consisting of lowercase English letters. Find the length of the longest even string that can be obtained by deleting one or more characters from the end of S. It is guaranteed that such a non-empty string exists for a given input.
Constraints
* 2 \leq |S| \leq 200
* S is an even string consisting of lowercase English letters.
* There exists a non-empty even string that can be obtained by deleting one or more characters from the end of S.
Input
Input is given from Standard Input in the following format:
S
Output
Print the length of the longest even string that can be obtained.
Examples
Input
abaababaab
Output
6
Input
xxxx
Output
2
Input
abcabcabcabc
Output
6
Input
akasakaakasakasakaakas
Output
14 | ```python
n = input()
num = len(n)-2
for i in range(num,0,-2):
f = int(i/2)
if n[:f]==n[f:i]:
print(i)
break
``` |
p03827 AtCoder Beginner Contest 052 - Increment Decrement | You have an integer variable x. Initially, x=0.
Some person gave you a string S of length N, and using the string you performed the following operation N times. In the i-th operation, you incremented the value of x by 1 if S_i=`I`, and decremented the value of x by 1 if S_i=`D`.
Find the maximum value taken by x during the operations (including before the first operation, and after the last operation).
Constraints
* 1≤N≤100
* |S|=N
* No characters except `I` and `D` occur in S.
Input
The input is given from Standard Input in the following format:
N
S
Output
Print the maximum value taken by x during the operations.
Examples
Input
5
IIDID
Output
2
Input
7
DDIDDII
Output
0 | ```python
x = 0
_n = input()
s = input()
maxX = x
for c in s:
x = x + (1 if c == "I" else -1)
maxX = max(maxX, x)
print(maxX)
``` |
p03994 CODE FESTIVAL 2016 qual A - Next Letter | Mr. Takahashi has a string s consisting of lowercase English letters. He repeats the following operation on s exactly K times.
* Choose an arbitrary letter on s and change that letter to the next alphabet. Note that the next letter of `z` is `a`.
For example, if you perform an operation for the second letter on `aaz`, `aaz` becomes `abz`. If you then perform an operation for the third letter on `abz`, `abz` becomes `aba`.
Mr. Takahashi wants to have the lexicographically smallest string after performing exactly K operations on s. Find the such string.
Constraints
* 1≤|s|≤10^5
* All letters in s are lowercase English letters.
* 1≤K≤10^9
Input
The input is given from Standard Input in the following format:
s
K
Output
Print the lexicographically smallest string after performing exactly K operations on s.
Examples
Input
xyz
4
Output
aya
Input
a
25
Output
z
Input
codefestival
100
Output
aaaafeaaivap | ```python
def dist(c):
return (ord('z') - ord(c) + 1) % 26
s = list(input())
k = int(input())
i = 0
while 0 < k and i < len(s):
d = dist(s[i])
if d <= k:
k -= d
s[i] = 'a'
i += 1
s[-1] = chr((ord(s[-1]) + (k % 26)))
print(''.join(s))
``` |
p00082 Flying Jenny | <image>
You know the merry-go-round in the amusement park. Vehicles such as horses and carriages are fixed on a large disk, and it is a standard playset that the vehicle swings up and down at the same time as the disk rotates. A merry-go-round in an amusement park has two four-seater carriages, two two-seater cars, four one-seater horses, and a total of eight vehicles in the order shown in Figure 1. .. Customers at the amusement park are waiting somewhere between platforms 0 and 7 shown in Fig. 1.
<image>
The merry-go-round in this amusement park always stops where the vehicle fits snugly into the landing. And the customers waiting in each of 0 to 7 are supposed to get on the vehicle that stopped in front of them. You cannot hurry to another platform and board from there. In order for customers to enjoy themselves efficiently, we must adjust the stop position of the merry-go-round to minimize the number of passengers who cannot ride.
Create a program that reads the number of passengers waiting at platform 0-7 and outputs which vehicle should stop at which position to reduce the number of passengers who cannot get on.
input
The input consists of multiple datasets. Each dataset is given in the following format:
p0 p1 p2 p3 p4 p5 p6 p7
Integers p0, p1, ..., p7 (0 ≤ pi ≤ 10,000) are given on one line, separated by blanks, to represent the number of passengers waiting at platform 0, 1, ..., 7.
output
Let's assume that the carriage of a merry-go-round vehicle is represented by 4, the car is represented by 2, and the horse is represented by 1. The vehicles that stop at platform 0, 1, ..., 7 are c0, c1, ..., c7, respectively. Prints c0, c1, ..., c7 on a single line, separated by blanks, for each dataset.
If there are multiple ways to minimize the number of passengers who cannot ride, c0c1c2c3c4c5c6c7 shall be regarded as an 8-digit integer V, and the method to minimize V shall be selected.
The number of datasets does not exceed 100.
Example
Input
2 3 1 4 0 1 0 1
4 2 3 2 2 2 1 1
Output
1 4 1 4 1 2 1 2
4 1 4 1 2 1 2 1 | ```python
from copy import copy
p = []
while(1):
try:
p = [int(i) for i in input().split()]
min_ = 10**10
point = 0
arrmin = []
arr = [4,1,4,1,2,1,2,1]
for _ in range(8):
temp = copy(arr[0])
repl = copy(arr[1:8])
arr[0:7] = repl
arr[7] = temp
point = sum([j-i if i < j else 0 for i,j in zip(arr,p)])
if point == min_:
arrmin.append(copy(arr))
min_ = point
elif point < min_:
arrmin = [copy(arr)]
min_ = point
arrmin = ["".join([str(i) for i in j]) for j in arrmin]
amin = min([int(i) for i in arrmin])
out = list(str(amin))
print(" ".join(out))
except EOFError:
break
``` |
p00214 Autumnal Illumination | In Square Town, where many people who love squares live, a festival is held to color the town with illuminations that combine square lightning boards. This electric board emits light when electricity is applied, and the plate in contact with the light emitting plate also emits light. Therefore, no matter how many electric boards you use, if all of them are in contact with each other, you only need one power supply.
The festival executive committee will solicit designs that combine squares from the townspeople and create a large number of illuminations. For each illumination, the number of power supplies required varies depending on the arrangement of the squares that make up the design, so it takes a lot of time and effort to figure out the number of power supplies required. So you decided to look at the arrangement of the rectangles and write a program to help the executive committee calculate the number of power supplies needed.
<image>
Create a program that inputs the number of illuminations and the information of the rectangles that make up each illumination, and outputs the number of power supplies required for each illumination. Think of the overlapping and touching rectangles as a group, and count the number of power supplies as one for each group.
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
M1
xa1 ya1 xb1 yb1 xc1 yc1 xd1 yd1
xa2 ya2 xb2 yb2 xc2 yc2 xd2 yd2
::
xaM1 yaM1 xbM1 ybM1 xcM1 ycM1 xdM1 ydM1
M2
::
::
MN
::
::
The number of illuminations N (1 ≤ N ≤ 100) is given on the first line. Then, information on N illuminations is given. As the i-th illumination information, the number of rectangles Mi (1 ≤ Mi ≤ 100) that make up the illumination is given in one line. The following Mi line is given the jth quadrangle vertex xaj, yaj, xbj, ybj, xcj, ycj, xdj, ydj (integer between -1000 and 1000).
The coordinates of the vertices of the rectangle entered are entered in a clockwise order. However, all the input data rectangles are convex rectangles.
The number of datasets does not exceed 10.
Output
Outputs the number of power supplies required for each illumination for each input dataset. Follow the order in which each illumination was input for the number of power supplies to be output.
Example
Input
3
1
0 0 0 1 1 1 1 0
2
0 0 0 1 1 1 1 0
100 100 100 200 200 200 200 100
2
0 0 0 100 100 100 100 0
10 10 10 20 20 20 20 10
2
1
30 40 40 50 40 20 20 10
1
30 40 40 50 40 20 20 10
0
Output
1
2
1
1
1 | ```python
def dot3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy)
def cross3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def dist2(A, B):
ax, ay = A; bx, by = B
return (ax - bx) ** 2 + (ay - by) ** 2
def is_intersection(P0, P1, Q0, Q1):
C0 = cross3(P0, P1, Q0)
C1 = cross3(P0, P1, Q1)
D0 = cross3(Q0, Q1, P0)
D1 = cross3(Q0, Q1, P1)
if C0 == C1 == 0:
E0 = dot3(P0, P1, Q0)
E1 = dot3(P0, P1, Q1)
if not E0 < E1:
E0, E1 = E1, E0
return E0 <= dist2(P0, P1) and 0 <= E1
return C0 * C1 <= 0 and D0 * D1 <= 0
def contains(P, Q):
v = []
for q in Q:
for i in range(4):
v.append(cross3(P[i-1], P[i], q))
if all(e <= 0 for e in v) or all(e >= 0 for e in v):
return 1
return 0
def check(Pi, Pj):
if contains(Pi, Pj) or contains(Pj, Pi):
return 1
for i in range(4):
for j in range(4):
if is_intersection(Pi[i-1], Pi[i], Pj[j-1], Pj[j]):
return 1
return 0
def solve():
M = readline(1)[0]
*p, = range(M)
def root(x):
if x == p[x]:
return x
p[x] = y = root(p[x])
return y
def unite(x, y):
px = root(x); py = root(y)
if px < py:
p[py] = px
else:
p[px] = py
P = []
for i in range(M):
xa, ya, xb, yb, xc, yc, xd, yd = readline(8)
P.append(((xa, ya), (xb, yb), (xc, yc), (xd, yd)))
for i in range(M):
for j in range(i+1, M):
if check(P[i], P[j]):
unite(i, j)
res = 0
for i in range(M):
if i == root(i):
res += 1
return res
*r, = map(int, open(0).read().split())
it = iter(r)
def readline(v):
r = []
for i in range(v):
r.append(next(it))
return r
while 1:
N = readline(1)[0]
if N == 0:
break
for i in range(N):
print(solve())
``` |
p00591 Advanced Algorithm Class | In the advanced algorithm class, n2 students sit in n rows and n columns. One day, a professor who teaches this subject comes into the class, asks the shortest student in each row to lift up his left hand, and the tallest student in each column to lift up his right hand. What is the height of the student whose both hands are up ? The student will become a target for professor’s questions.
Given the size of the class, and the height of the students in the class, you have to print the height of the student who has both his hands up in the class.
Input
The input will consist of several cases. the first line of each case will be n(0 < n < 100), the number of rows and columns in the class. It will then be followed by a n-by-n matrix, each row of the matrix appearing on a single line. Note that the elements of the matrix may not be necessarily distinct. The input will be terminated by the case n = 0.
Output
For each input case, you have to print the height of the student in the class whose both hands are up. If there is no such student, then print 0 for that case.
Example
Input
3
1 2 3
4 5 6
7 8 9
3
1 2 3
7 8 9
4 5 6
0
Output
7
7 | ```python
import sys
while True:
n = int(sys.stdin.readline().rstrip())
if n == 0:
break;
students = []
for i in range(n):
students.append(list(map(int, sys.stdin.readline().rstrip().split(' '))))
s_list=[[min(row)==s for s in row] for row in students]
t_list=[[max(col)==s for s in col] for col in zip(*students)]
ret = [0]
for i,data in enumerate(zip(s_list, zip(*t_list))):
for j,d in enumerate(zip(*data)):
if all(d):
ret.append(students[i][j])
print(max(ret))
``` |
p00728 ICPC Score Totalizer Software | <image>
The International Clown and Pierrot Competition (ICPC), is one of the most distinguished and also the most popular events on earth in the show business.
One of the unique features of this contest is the great number of judges that sometimes counts up to one hundred. The number of judges may differ from one contestant to another, because judges with any relationship whatsoever with a specific contestant are temporarily excluded for scoring his/her performance.
Basically, scores given to a contestant's performance by the judges are averaged to decide his/her score. To avoid letting judges with eccentric viewpoints too much influence the score, the highest and the lowest scores are set aside in this calculation. If the same highest score is marked by two or more judges, only one of them is ignored. The same is with the lowest score. The average, which may contain fractions, are truncated down to obtain final score as an integer.
You are asked to write a program that computes the scores of performances, given the scores of all the judges, to speed up the event to be suited for a TV program.
Input
The input consists of a number of datasets, each corresponding to a contestant's performance. There are no more than 20 datasets in the input.
A dataset begins with a line with an integer n, the number of judges participated in scoring the performance (3 ≤ n ≤ 100). Each of the n lines following it has an integral score s (0 ≤ s ≤ 1000) marked by a judge. No other characters except for digits to express these numbers are in the input. Judges' names are kept secret.
The end of the input is indicated by a line with a single zero in it.
Output
For each dataset, a line containing a single decimal integer indicating the score for the corresponding performance should be output. No other characters should be on the output line.
Example
Input
3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0
Output
342
7
300
326 | ```python
while 1:
n = int(input())
if n == 0:
break
s = [int(input()) for i in range(n)]
s.sort()
x = sum(s) - (s[0] + s[-1])
print(x // (n - 2))
``` |
p00999 Rental DVD Shop NEO | Problem
I started a part-time job at the rental DVD shop "NEO". First of all, I decided to study the fee system of this store.
There are three types of rental DVDs, old, semi-new, and new, and the rental fee for one DVD is a yen, b yen, and c yen, respectively. The set rental shown below can be applied multiple times at the time of accounting.
* Select a few DVDs for which set rental has not yet been applied.
* If the number of selected DVDs is d or more, the total price of the selected DVDs exceeds (the number of selected DVDs) * e yen, rent them for (the number of selected DVDs) * e yen. You can.
* If the number of selected DVDs is less than d, and the total price of the selected DVDs exceeds d * e yen, you can rent them for d * e yen.
* If the above does not apply, the selected DVD will be rented at the regular rate.
Here I noticed a problem. The set rental is not applied automatically when you go to the cash register, but is applied manually. This may result in the application of suboptimal set rentals (which can be cheaper). This can lead to complaints. I hate complaints, so I decided to create a program that calculates the price when the set rental is optimally applied.
Constraints
The input satisfies the following conditions.
* All values contained in the input are integers
* 0 <a <b <e <c ≤ 1000
* 0 <d ≤ 100000
* 0 ≤ na, nb, nc ≤ 100000
* 0 <na + nb + nc
* No more than 100 datasets
Input
The input consists of multiple datasets. Each dataset is represented below. The first line is given five integers a, b, c, d, e separated by spaces. The number of rentals is given on the second line. The three integers na, nb, nc are given separated by spaces. Represents the number of old, semi-new, and new DVDs, respectively. The end of the input consists of 5 zeros.
a b c d e
na nb nc
Output
For each dataset, output the charge when the set rental is optimally applied on one line.
Example
Input
70 100 340 4 200
1 1 4
70 100 340 4 200
0 1 3
70 100 340 4 200
1 1 2
0 0 0 0 0
Output
970
800
800 | ```python
# AOJ 1509 Rental DVD Shop NEO
# Python3 2018.7.13 bal4u
while True:
a, b, c, d, e = map(int, input().split())
if a == 0: break
na, nb, nc = map(int, input().split())
if nc >= d: ans = e*nc + b*nb + a*na
else:
ans = c*nc + b*nb + a*na
k = d-nc;
if k <= nb: nb -= k; k = 0
else: k -= nb; nb = 0
if k <= na: na -= k
else: na = 0
ans = min(ans, e*d + b*nb + a*na)
print(ans)
``` |
p01131 Keitai Message | Alice wants to send an email to Miku on her mobile phone.
The only buttons that can be used for input on mobile phones are number buttons. Therefore, in order to input characters, the number buttons are pressed several times to input characters. The following characters are assigned to the number buttons of the mobile phone, and the confirmation button is assigned to button 0. With this mobile phone, you are supposed to press the confirm button after you finish entering one character.
* 1:.,!? (Space)
* 2: a b c
* 3: d e f
* 4: g h i
* 5: j k l
* 6: m n o
* 7: p q r s
* 8: t u v
* 9: w x y z
* 0: Confirm button
For example, if you press button 2, button 2, or button 0, the letter changes from'a'to'b', and the confirm button is pressed here, so the letter b is output. If you enter the same number in succession, the changing characters will loop. That is, if you press button 2 five times and then button 0, the letters change from'a'→' b'→'c' →'a' →'b', and the confirm button is pressed here. 'b' is output.
You can press the confirm button when no button is pressed, but in that case no characters are output.
Your job is to recreate the message Alice created from a row of buttons pressed by Alice.
Input
The first line gives the number of test cases. Each test case is then given a string of digits up to 1024 in length in one row.
Output
Print the string of Alice's message line by line for each test case. However, you can assume that the output is one or more and less than 76 characters.
Example
Input
5
20
220
222220
44033055505550666011011111090666077705550301110
000555555550000330000444000080000200004440000
Output
a
b
b
hello, world!
keitai | ```python
keylist = [
[],
['.', ',', '!', '?', ' '],
['a', 'b', 'c'],
['d', 'e', 'f'],
['g', 'h', 'i'],
['j', 'k', 'l'],
['m', 'n', 'o'],
['p', 'q', 'r', 's'],
['t', 'u', 'v'],
['w', 'x', 'y', 'z']
]
for i in range(int(input())):
output = ''
for item in input().split('0'):
if item == '':
continue
output += keylist[int(item[0])][len(item) % len(keylist[int(item[0])]) - 1]
print(output)
``` |
p01270 Restrictive Filesystem | You are a programmer on the development team for new recording media. This recording medium can be randomly accessed for reading and erasing data. On the other hand, when writing data, access is always performed in order from the beginning, and only the first free space found can be written.
You have begun to build a file system for this recording medium. In this file system, data is written in order from the first free area due to the limitation of the recording medium. If another data exists in the middle of writing, the remaining data is written from the free area behind it.
Data is written in units called sectors. Sectors are assigned numbers starting from 0, which indicate their physical location on the storage medium. The sector numbers are assigned as 0, 1, 2, 3, ... In order from the beginning to the back of the storage medium.
There are three commands in the file system: write, delete, and sector reference.
Your job is to reproduce the behavior of this file system and then write a program that outputs which files are located in the target sector when the reference command is executed. In the initial state, nothing is written on the recording medium.
For example, let's look at the first example of Sample Input. The first instruction writes a file with an identifier of 0 and a size of 2. In the initial state, nothing is written to the recording medium, that is, all sectors are free areas, so writing is performed to the first two sectors, that is, the 0th sector and the 1st sector. Therefore, the storage medium after writing is as follows.
0 0 Sky Sky Sky Sky Sky Sky ...
The second instruction writes a file with the identifier 1 to the second and third sectors. The state of the storage medium after this is as follows.
0 0 1 1 Sky Sky Sky Sky ...
The third instruction deletes the file with the identifier 0. The state of the storage medium is as follows.
Sky Sky 1 1 Sky Sky Sky Sky ...
The fourth instruction writes the file with the identifier 2 to the 0th, 1st, 4th, and 5th sectors.
2 2 1 1 2 2 Sky Sky ...
The last instruction refers to the third sector. Now that you have a file with the identifier 1 in the third sector, your program should output 1.
Input
The input consists of multiple datasets. Each dataset is given in the following format.
> N
> Command1
> Command2
> ...
> CommandN
N is the number of commands executed (1 ≤ N ≤ 10,000), and Commandi is the i-th command to be executed.
Each command consists of a command name and one or two arguments. The command name consists of only one letter and can be either "W", "D", or "R". There is a space between the command and the argument, and between the argument and the argument.
"W" represents a write command. Two arguments I (0 ≤ I ≤ 109) and S (1 ≤ S ≤ 109) are given. Each shows the identifier of the file to write and the number of sectors required to store the file.
"D" represents the delete command. One argument I (0 ≤ I ≤ 109) is given. Indicates the identifier of the file to be deleted.
"R" represents the reference command. One argument P (0 ≤ P ≤ 109) is given. Indicates the number of the sector to be referenced.
It can be assumed that sectors with numbers higher than 109 do not need to be accessed. Also, it is guaranteed that a file with the same file identifier will not be written multiple times.
The end of the input is indicated by one line containing one 0.
Output
For each dataset, output the identifier of the file referenced by that command on a single line each time a referenced command appears. If no file has been written to the referenced sector, output -1 instead of the file identifier.
Put a blank line after each dataset.
Sample Input
6
W 0 2
W 1 2
D 0
W 2 4
R 3
R 1
1
R 1000000000
0
Output for the Sample Input
1
2
-1
Example
Input
6
W 0 2
W 1 2
D 0
W 2 4
R 3
R 1
1
R 1000000000
0
Output
1
2
-1 | ```python
from bisect import bisect_right
while True:
N = int(input())
if N==0:
break
mem = [] # (l, r, id)
for _ in range(N):
command = input().split()
if command[0]=="W":
Id, S = map(int, command[1:])
subS = S
idx_mem = 0
idx = 0
while idx_mem < len(mem):
l, r, _ = mem[idx_mem]
if idx != l:
space = l - idx
assert space > 0, (mem, l, idx)
if subS <= space:
mem.insert(idx_mem, [idx, idx+subS, Id])
subS = 0
break
else:
mem.insert(idx_mem, [idx, idx+space, Id])
subS -= space
idx_mem += 1
idx = r
idx_mem += 1
else:
mem.append([idx, idx+subS, Id])
elif command[0]=="D":
Id = int(command[1])
for idx_mem in range(len(mem)-1, -1, -1):
if mem[idx_mem][2] == Id:
del mem[idx_mem]
else:
P = int(command[1])
idx_mem = bisect_right(mem, [P, 100000000000000, -1]) - 1
#print(mem, idx_mem)
if idx_mem==-1:
print(-1)
else:
l, r, id_ = mem[idx_mem]
if P < r:
print(id_)
else:
print(-1)
print()
``` |
p01886 Share the Ruins Preservation | Example
Input
8
-10 0
-10 5
-5 5
-5 0
10 0
10 -5
5 -5
5 0
Output
50 | ```python
from collections import defaultdict
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def cross3(p0, p1, p2):
return (p1[0] - p0[0]) * (p2[1] - p0[1]) - (p1[1] - p0[1]) * (p2[0] - p0[0])
def solve():
N = int(readline())
mp = defaultdict(list)
for i in range(N):
x, y = map(int, readline().split())
mp[x].append(y)
*S, = mp.items()
S.sort()
def calc(S, k):
P = []; Q = []
r = 0; R = [0]
for x, ys in S:
ys.sort(reverse=k)
for y in ys:
p = (x, y)
while len(P) >= 2 and cross3(P[-2], P[-1], p) <= 0:
r += abs(cross3(P[-2], P[-1], p))
P.pop()
P.append(p)
while len(Q) >= 2 and cross3(Q[-2], Q[-1], p) >= 0:
r += abs(cross3(Q[-2], Q[-1], p))
Q.pop()
Q.append(p)
R.append(r)
return R
R0 = calc(S, 0)
S.reverse()
R1 = calc(S, 1)
L = len(S)
ans = 10**20
for i in range(L+1):
ans = min(ans, R0[i] + R1[-1-i])
write("%d\n" % ((ans+1) // 2))
solve()
``` |
p02023 Ravage | I: Ravage
Santa Claus was caught in the illuminations of the city and broke it.
There are N light bulbs in the illumination, and the $ i $ th light bulb only comes on when the voltage is above $ A_i $ and below $ B_i $.
The voltage should be the same everywhere in the illumination.
Find out how many light bulbs can be lit at the same time by adjusting the voltage.
input
The integer $ N $ is given on the first line.
Of the following $ N $ lines, $ A_i and B_i $ are given on the $ i $ line, separated by blanks.
output
Output the maximum number of light bulbs that can be illuminated at the same time.
Constraint
* $ N $ is an integer greater than or equal to $ 1 $ and less than or equal to $ 100 \ 000 $
* $ A_1, A_2, A_3, \ dots, A_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* $ B_1, B_2, B_3, \ dots, B_N $ are integers greater than or equal to $ 1 $ and less than or equal to $ 1 \ 000 \ 000 \ 000 $
* Satisfy $ A_i \ leq B_i $ for all light bulbs $ i $
Input example 1
Four
14
3 6
2 7
5 8
Output example 1
3
When the voltage is $ 5 $ or $ 3.14 $, there are $ 3 $ bulbs.
Input example 2
2
1 2
twenty three
Output example 2
2
Example
Input
4
1 4
3 6
2 7
5 8
Output
3 | ```python
n=int(input())
l=[]
for _ in [0]*n:
a,b=map(int,input().split())
l.extend([(a,1),(b+1,-1)])
l.sort()
c = 0
a = 0
for _,v in l:
c+=v
a=max(a,c)
print(a)
``` |
p02306 Incircle of a Triangle | Write a program which prints the central coordinate ($cx$,$cy$) and the radius $r$ of a incircle of a triangle which is constructed by three points ($x_1$, $y_1$), ($x_2$, $y_2$) and ($x_3$, $y_3$) on the plane surface.
Constraints
* $-10000 \leq x_i, y_i \leq 10000$
* The three points are not on the same straight line
Input
The input is given in the following format
$x_1$ $y_1$
$x_2$ $y_2$
$x_3$ $y_3$
All the input are integers.
Output
Print $cx$, $cy$ and $r$ separated by a single space in a line. The output values should be in a decimal fraction with an error less than 0.000001.
Examples
Input
1 -2
3 2
-2 0
Output
0.53907943898209422325 -0.26437392711448356856 1.18845545916395465278
Input
0 3
4 0
0 0
Output
1.00000000000000000000 1.00000000000000000000 1.00000000000000000000 | ```python
import math
x1, y1 = map(int, input().split())
x2, y2 = map(int, input().split())
x3, y3 = map(int, input().split())
#3辺の長さ
a = math.sqrt(((x1-x2)**2)+((y1-y2)**2))
b = math.sqrt(((x3-x2)**2)+((y3-y2)**2))
c = math.sqrt(((x1-x3)**2)+((y1-y3)**2))
s = (a+b+c)/2
r = math.sqrt(s*(s-a)*(s-b)*(s-c))/s #ヘロンの公式
xa, ya = x1+(x2-x1)*c/(b+c), y1+(y2-y1)*c/(b+c) #二等分線とaの交点
xb, yb = x2+(x3-x2)*a/(a+c), y2+(y3-y2)*a/(a+c)
if (xa-x3) != 0 and (xb-x1) != 0:
a1, b1 = (ya-y3)/(xa-x3), -((ya-y3)/(xa-x3))*x3+y3 #二等分線の方程式
a2, b2 = (yb-y1)/(xb-x1), -((yb-y1)/(xb-x1))*x1+y1
cx = (b2-b1)/(a1-a2)
cy = a1 * cx + b1
if xa-x3 == 0:
cx = x3
a2, b2 = (yb-y1)/(xb-x1), -((yb-y1)/(xb-x1))*x1+y1
cy = a2 * cx + b2
if xb-x1 == 0:
cx = x1
a1, b1 = (ya-y3)/(xa-x3), -((ya-y3)/(xa-x3))*x3+y3
cy = a1 * cx + b1
print(cx, cy, r)
``` |
p02453 Lower Bound | For a given sequence $A = \\{a_0, a_1, ..., a_{n-1}\\}$ which is sorted by ascending order, find the lower bound for a specific value $k$ given as a query.
* lower bound: the place pointing to the first element greater than or equal to a specific value, or $n$ if there is no such element.
Constraints
* $1 \leq n \leq 100,000$
* $1 \leq q \leq 200,000$
* $0 \leq a_0 \leq a_1 \leq ... \leq a_{n-1} \leq 1,000,000,000$
* $0 \leq k_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ,..., \; a_{n-1}$
$q$
$k_1$
$k_2$
:
$k_q$
The number of elements $n$ and each element $a_i$ are given in the first line and the second line respectively. In the third line, the number of queries $q$ is given and the following $q$ lines, $q$ integers $k_i$ are given as queries.
Output
For each query, print the position $i$ ($i = 0, 1, ..., n$) of the lower bound in a line.
Example
Input
4
1 2 2 4
3
2
3
5
Output
1
3
4 | ```python
import sys
from bisect import bisect_left
n = int(input())
a = tuple(map(int,sys.stdin.readline().split()))
q = int(input())
l = len(a)
for k in sys.stdin:
k = int(k.strip())
if k > a[-1]:print(l)
else:
print(bisect_left(a,k))
``` |
1009_E. Intercity Travelling | Leha is planning his journey from Moscow to Saratov. He hates trains, so he has decided to get from one city to another by car.
The path from Moscow to Saratov can be represented as a straight line (well, it's not that straight in reality, but in this problem we will consider it to be straight), and the distance between Moscow and Saratov is n km. Let's say that Moscow is situated at the point with coordinate 0 km, and Saratov — at coordinate n km.
Driving for a long time may be really difficult. Formally, if Leha has already covered i kilometers since he stopped to have a rest, he considers the difficulty of covering (i + 1)-th kilometer as a_{i + 1}. It is guaranteed that for every i ∈ [1, n - 1] a_i ≤ a_{i + 1}. The difficulty of the journey is denoted as the sum of difficulties of each kilometer in the journey.
Fortunately, there may be some rest sites between Moscow and Saratov. Every integer point from 1 to n - 1 may contain a rest site. When Leha enters a rest site, he may have a rest, and the next kilometer will have difficulty a_1, the kilometer after it — difficulty a_2, and so on.
For example, if n = 5 and there is a rest site in coordinate 2, the difficulty of journey will be 2a_1 + 2a_2 + a_3: the first kilometer will have difficulty a_1, the second one — a_2, then Leha will have a rest, and the third kilometer will have difficulty a_1, the fourth — a_2, and the last one — a_3. Another example: if n = 7 and there are rest sites in coordinates 1 and 5, the difficulty of Leha's journey is 3a_1 + 2a_2 + a_3 + a_4.
Leha doesn't know which integer points contain rest sites. So he has to consider every possible situation. Obviously, there are 2^{n - 1} different distributions of rest sites (two distributions are different if there exists some point x such that it contains a rest site in exactly one of these distributions). Leha considers all these distributions to be equiprobable. He wants to calculate p — the expected value of difficulty of his journey.
Obviously, p ⋅ 2^{n - 1} is an integer number. You have to calculate it modulo 998244353.
Input
The first line contains one number n (1 ≤ n ≤ 10^6) — the distance from Moscow to Saratov.
The second line contains n integer numbers a_1, a_2, ..., a_n (1 ≤ a_1 ≤ a_2 ≤ ... ≤ a_n ≤ 10^6), where a_i is the difficulty of i-th kilometer after Leha has rested.
Output
Print one number — p ⋅ 2^{n - 1}, taken modulo 998244353.
Examples
Input
2
1 2
Output
5
Input
4
1 3 3 7
Output
60 | ```python
from sys import stdin, stdout
def main():
p = 998244353 # Constante brindada por el problema
n = int(stdin.readline())
a = list(readline())
answer = a[-1]
pow_ = 1 # Potencia de 2
for i in range(n - 1, 0, -1): # Se analizan todas las dificultades
answer = (answer + a[i - 1] * (2 + n - i) * pow_ % p) % p # Se calcula la expresion
pow_ = pow_ * 2 % p # Se aumenta la potencia de 2
return answer
def readline(): # Metodo para leer una linea completa, dividirla en elementos y convertirlos en numeros enteros
return map(int, stdin.readline().strip().split())
if __name__ == '__main__':
stdout.write(str(main()) + '\n')
``` |
1032_B. Personalized Cup | At many competitions that have a word «cup» in its official name the winner is presented with an actual cup. This time the organizers of one unusual programming competition have decided to please the winner even more and to add a nameplate to the cup with the handle of the winner.
The nameplate is to be rectangular and the text on it will be printed as a table of several rows and columns. Having some measurements done, the organizers have found out that the number a of rows cannot be greater than 5 while the number b of columns cannot exceed 20. Every cell of the table will contain either an asterisk («*») or a letter of user's handle.
Furthermore, the organizers want the rows of the table to be uniform, which means that the number of asterisks used in different rows should differ by at most one (i.e. you can't have two asterisks in the first row and none in the second). The main goal, however, is to obtain the winner's handle precisely when reading the table from top to bottom and from left to right in every row (skipping asterisks).
The organizers want for the nameplate to have as few rows as possible and among all valid tables with the minimum number of rows they want to choose the one that has the minimum number of columns.
The winner is not yet determined so your task is to write a program that, given a certain handle, generates the necessary table.
Input
The only line contains one string s (1 ≤ |s| ≤ 100), comprised of uppercase and lowercase Latin letters, — the handle of the winner.
Output
In the first line output the minimum number a of rows in the table and the minimum number b of columns in an optimal table with rows.
The following a lines should contain b characters each — any valid table.
Examples
Input
tourist
Output
1 7
tourist
Input
MyNameIsLifeIAmForeverByYourSideMyNameIsLife
Output
3 15
MyNameIsLifeIAm
ForeverByYourSi
deMyNameIsL*ife | ```python
def print2d(a):
for i in range(len(a)):
print(''.join(list(map(str, a[i]))))
st = input()
for i in range(1, 5 + 1):
vst = len(st) // i
ost = len(st) % i
if vst + min(ost, 1) > 20:
continue
a = [0] * i
ind = 0
f = 0
for j in range(len(a)):
a[j] = []
for j in range(len(a)):
for k in range(vst):
a[j].append(st[ind])
ind += 1
if ost > 0:
ost -= 1
a[j].append(st[ind])
ind += 1
f = 1
elif f != 0:
a[j].append('*')
if a[-1][-1] == '*' or a[-1][-1] == st[-1]:
print(len(a), len(a[0]))
print2d(a)
exit()
``` |
1077_A. Frog Jumping | A frog is currently at the point 0 on a coordinate axis Ox. It jumps by the following algorithm: the first jump is a units to the right, the second jump is b units to the left, the third jump is a units to the right, the fourth jump is b units to the left, and so on.
Formally:
* if the frog has jumped an even number of times (before the current jump), it jumps from its current position x to position x+a;
* otherwise it jumps from its current position x to position x-b.
Your task is to calculate the position of the frog after k jumps.
But... One more thing. You are watching t different frogs so you have to answer t independent queries.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
Each of the next t lines contain queries (one query per line).
The query is described as three space-separated integers a, b, k (1 ≤ a, b, k ≤ 10^9) — the lengths of two types of jumps and the number of jumps, respectively.
Output
Print t integers. The i-th integer should be the answer for the i-th query.
Example
Input
6
5 2 3
100 1 4
1 10 5
1000000000 1 6
1 1 1000000000
1 1 999999999
Output
8
198
-17
2999999997
0
1
Note
In the first query frog jumps 5 to the right, 2 to the left and 5 to the right so the answer is 5 - 2 + 5 = 8.
In the second query frog jumps 100 to the right, 1 to the left, 100 to the right and 1 to the left so the answer is 100 - 1 + 100 - 1 = 198.
In the third query the answer is 1 - 10 + 1 - 10 + 1 = -17.
In the fourth query the answer is 10^9 - 1 + 10^9 - 1 + 10^9 - 1 = 2999999997.
In the fifth query all frog's jumps are neutralized by each other so the answer is 0.
The sixth query is the same as the fifth but without the last jump so the answer is 1. | ```python
t=int(input())
while(t):
l=[]
l=[int(x) for x in input().split()]
a=l[0]
b=l[1]
k=l[2]
p=int(k/2)
if k%2==0:
y=(p*a)-(p*b)
else:
y=(p*a)-(p*b)+a
print(y)
t=t-1
``` |
1119_A. Ilya and a Colorful Walk | Ilya lives in a beautiful city of Chordalsk.
There are n houses on the street Ilya lives, they are numerated from 1 to n from left to right; the distance between every two neighboring houses is equal to 1 unit. The neighboring houses are 1 and 2, 2 and 3, ..., n-1 and n. The houses n and 1 are not neighboring.
The houses are colored in colors c_1, c_2, …, c_n so that the i-th house is colored in the color c_i. Everyone knows that Chordalsk is not boring, so there are at least two houses colored in different colors.
Ilya wants to select two houses i and j so that 1 ≤ i < j ≤ n, and they have different colors: c_i ≠ c_j. He will then walk from the house i to the house j the distance of (j-i) units.
Ilya loves long walks, so he wants to choose the houses so that the distance between them is the maximum possible.
Help Ilya, find this maximum possible distance.
Input
The first line contains a single integer n (3 ≤ n ≤ 300 000) — the number of cities on the street.
The second line contains n integers c_1, c_2, …, c_n (1 ≤ c_i ≤ n) — the colors of the houses.
It is guaranteed that there is at least one pair of indices i and j so that 1 ≤ i < j ≤ n and c_i ≠ c_j.
Output
Print a single integer — the maximum possible distance Ilya can walk.
Examples
Input
5
1 2 3 2 3
Output
4
Input
3
1 2 1
Output
1
Input
7
1 1 3 1 1 1 1
Output
4
Note
In the first example the optimal way is to walk from the first house to the last one, where Ilya can walk the distance of 5-1 = 4 units.
In the second example the optimal way is to either walk from the first house to the second or from the second to the third. Both these ways have the distance of 1 unit.
In the third example the optimal way is to walk from the third house to the last one, where Ilya can walk the distance of 7-3 = 4 units. | ```python
import math
from decimal import Decimal
import heapq
def na():
n = int(input())
b = [int(x) for x in input().split()]
return n,b
def nab():
n = int(input())
b = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
return n,b,c
def dv():
n, m = map(int, input().split())
return n,m
def dva():
n, m = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
return n,m,b
def eratosthenes(n):
sieve = list(range(n + 1))
for i in sieve:
if i > 1:
for j in range(i + i, len(sieve), i):
sieve[j] = 0
return sorted(set(sieve))
def nm():
n = int(input())
b = [int(x) for x in input().split()]
m = int(input())
c = [int(x) for x in input().split()]
return n,b,m,c
def dvs():
n = int(input())
m = int(input())
return n, m
n,a =na()
d1 =0
d2 =0
for i in range(n):
if a[i] != a[0]:
d1 = i
for i in range(n -1, -1, -1):
if a[i] != a[n - 1]:
d2 = n - i - 1
print(max(d1, d2))
``` |
1145_E. Fourier Doodles | In this problem you have to solve a simple classification task: given an image, determine whether it depicts a Fourier doodle.
You are given a set of 50 images with ids 1 through 50. You are also given a text file labels.txt containing the labels for images with ids 1 through 20, which comprise the learning data set.
You have to output the classification results for images with ids 21 through 50 in the same format.
Input
[Download the images and the training labels](http://tc-alchemy.progopedia.com/fourier-doodles.zip)
Each line of the file labels.txt contains a single integer 0 or 1. Line i (1-based) contains the label of the image {i}.png. Label 1 means that the image depicts a Fourier doodle, label 0 - that it does not.
Output
Output 30 lines, one line per image 21 through 50. Line i (1-based) should contain the classification result for the image {i + 20}.png. | ```python
for id in range(21, 51):
print(((min(id, 25) + id) % (2 + id % 3)) > 0 and 1 or 0)
``` |
1166_D. Cute Sequences | Given a positive integer m, we say that a sequence x_1, x_2, ..., x_n of positive integers is m-cute if for every index i such that 2 ≤ i ≤ n it holds that x_i = x_{i - 1} + x_{i - 2} + ... + x_1 + r_i for some positive integer r_i satisfying 1 ≤ r_i ≤ m.
You will be given q queries consisting of three positive integers a, b and m. For each query you must determine whether or not there exists an m-cute sequence whose first term is a and whose last term is b. If such a sequence exists, you must additionally find an example of it.
Input
The first line contains an integer number q (1 ≤ q ≤ 10^3) — the number of queries.
Each of the following q lines contains three integers a, b, and m (1 ≤ a, b, m ≤ 10^{14}, a ≤ b), describing a single query.
Output
For each query, if no m-cute sequence whose first term is a and whose last term is b exists, print -1.
Otherwise print an integer k (1 ≤ k ≤ 50), followed by k integers x_1, x_2, ..., x_k (1 ≤ x_i ≤ 10^{14}). These integers must satisfy x_1 = a, x_k = b, and that the sequence x_1, x_2, ..., x_k is m-cute.
It can be shown that under the problem constraints, for each query either no m-cute sequence exists, or there exists one with at most 50 terms.
If there are multiple possible sequences, you may print any of them.
Example
Input
2
5 26 2
3 9 1
Output
4 5 6 13 26
-1
Note
Consider the sample. In the first query, the sequence 5, 6, 13, 26 is valid since 6 = 5 + \bf{\color{blue} 1}, 13 = 6 + 5 + {\bf\color{blue} 2} and 26 = 13 + 6 + 5 + {\bf\color{blue} 2} have the bold values all between 1 and 2, so the sequence is 2-cute. Other valid sequences, such as 5, 7, 13, 26 are also accepted.
In the second query, the only possible 1-cute sequence starting at 3 is 3, 4, 8, 16, ..., which does not contain 9. | ```python
for _ in range(int(input())):
a,b,m=map(int,input().split())
if a==b:
print(1,a)
continue
for k in range(2,51):
pw=1<<(k-2)
mn=pw*(a+1)
mx=pw*(a+m)
if mn<=b<=mx:
r=[0]*(k+1)
add=b-mn
r[1]=a
for i in range(2,k):
r[i]=min(m-1,add//(1<<(k-i-1)))
add-=r[i]*(1<<(k-i-1))
r[i]+=1
r[k]=add+1
x=[0]*(k+1)
s=0
for i in range(1,k+1):
x[i]=s+r[i]
s+=x[i]
print(k,*(x[1:]),sep=' ')
break
else:
print(-1)
``` |
1185_B. Email from Polycarp | Methodius received an email from his friend Polycarp. However, Polycarp's keyboard is broken, so pressing a key on it once may cause the corresponding symbol to appear more than once (if you press a key on a regular keyboard, it prints exactly one symbol).
For example, as a result of typing the word "hello", the following words could be printed: "hello", "hhhhello", "hheeeellllooo", but the following could not be printed: "hell", "helo", "hhllllooo".
Note, that when you press a key, the corresponding symbol must appear (possibly, more than once). The keyboard is broken in a random manner, it means that pressing the same key you can get the different number of letters in the result.
For each word in the letter, Methodius has guessed what word Polycarp actually wanted to write, but he is not sure about it, so he asks you to help him.
You are given a list of pairs of words. For each pair, determine if the second word could be printed by typing the first one on Polycarp's keyboard.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 10^5) — the number of pairs to check. Further input contains n descriptions of pairs.
The first line of each description contains a single non-empty word s consisting of lowercase Latin letters. The second line of the description contains a single non-empty word t consisting of lowercase Latin letters. The lengths of both strings are not greater than 10^6.
It is guaranteed that the total length of all words s in the input is not greater than 10^6. Also, it is guaranteed that the total length of all words t in the input is not greater than 10^6.
Output
Output n lines. In the i-th line for the i-th pair of words s and t print YES if the word t could be printed by typing the word s. Otherwise, print NO.
Examples
Input
4
hello
hello
hello
helloo
hello
hlllloo
hello
helo
Output
YES
YES
NO
NO
Input
5
aa
bb
codeforces
codeforce
polycarp
poolycarpp
aaaa
aaaab
abcdefghijklmnopqrstuvwxyz
zabcdefghijklmnopqrstuvwxyz
Output
NO
NO
YES
NO
NO | ```python
def f():
a=input()
i=0
p=a[i]
l=[]
while(i<len(a)):
temp=1
t=[p]
i+=1
while(i<len(a)):
if a[i]!=p:
p=a[i]
break
p=a[i]
t.append(p)
i+=1
if i==len(a):
temp=0
break
l.append(t)
if temp==0:
break
a=input()
i=0
p=a[i]
l1=[]
while(i<len(a)):
temp=1
t=[p]
i+=1
while(i<len(a)):
if a[i]!=p:
p=a[i]
break
p=a[i]
t.append(p)
i+=1
if i==len(a):
temp=0
break
l1.append(t)
if temp==0:
break
if len(l)!=len(l1):
return 0
for i in range(0,len(l)):
if l[i][0]!=l1[i][0] or len(l[i])>len(l1[i]):
return 0
return 1
for i in range(int(input())):
if f():
print ("YES")
else:
print("NO")
``` |
1203_F1. Complete the Projects (easy version) | The only difference between easy and hard versions is that you should complete all the projects in easy version but this is not necessary in hard version.
Polycarp is a very famous freelancer. His current rating is r units.
Some very rich customers asked him to complete some projects for their companies. To complete the i-th project, Polycarp needs to have at least a_i units of rating; after he completes this project, his rating will change by b_i (his rating will increase or decrease by b_i) (b_i can be positive or negative). Polycarp's rating should not fall below zero because then people won't trust such a low rated freelancer.
Is it possible to complete all the projects? Formally, write a program to check if such an order of the projects exists, that Polycarp has enough rating before starting each project, and he has non-negative rating after completing each project.
In other words, you have to check that there exists such an order of projects in which Polycarp will complete them, so he has enough rating before starting each project, and has non-negative rating after completing each project.
Input
The first line of the input contains two integers n and r (1 ≤ n ≤ 100, 1 ≤ r ≤ 30000) — the number of projects and the initial rating of Polycarp, respectively.
The next n lines contain projects, one per line. The i-th project is represented as a pair of integers a_i and b_i (1 ≤ a_i ≤ 30000, -300 ≤ b_i ≤ 300) — the rating required to complete the i-th project and the rating change after the project completion.
Output
Print "YES" or "NO".
Examples
Input
3 4
4 6
10 -2
8 -1
Output
YES
Input
3 5
4 -5
4 -2
1 3
Output
YES
Input
4 4
5 2
5 -3
2 1
4 -2
Output
YES
Input
3 10
10 0
10 -10
30 0
Output
NO
Note
In the first example, the possible order is: 1, 2, 3.
In the second example, the possible order is: 2, 3, 1.
In the third example, the possible order is: 3, 1, 4, 2. | ```python
n,r = map(int,(input().split()))
plus=[]
minn=[]
for i in range (0,n):
temp = list(map(int,input().split()))
if temp[1] <=0:
temp.append(temp[0]+temp[1])
minn.append(temp)
else:
plus.append(temp)
plus.sort()
minn.sort(reverse=True,key = lambda x: x[2])
flag = True
for i in plus:
if i[0] <= r:
r+= i[1]
#print(r)
else:
flag=False
break
#print("GANTI")
if flag:
for i in minn:
if i[0] <= r:
r +=i[1]
#print(r)
else:
flag=False
break
if flag and r>=0:
print("YES")
else:
print("NO")
``` |
1220_D. Alex and Julian | Boy Dima gave Julian a birthday present — set B consisting of positive integers. However, he didn't know, that Julian hates sets, but enjoys bipartite graphs more than anything else!
Julian was almost upset, but her friend Alex said, that he can build an undirected graph using this set in such a way: let all integer numbers be vertices, then connect any two i and j with an edge if |i - j| belongs to B.
Unfortunately, Julian doesn't like the graph, that was built using B. Alex decided to rectify the situation, so he wants to erase some numbers from B, so that graph built using the new set is bipartite. The difficulty of this task is that the graph, Alex has to work with, has an infinite number of vertices and edges! It is impossible to solve this task alone, so Alex asks you for help. Write a program that erases a subset of minimum size from B so that graph constructed on the new set is bipartite.
Recall, that graph is bipartite if all its vertices can be divided into two disjoint sets such that every edge connects a vertex from different sets.
Input
First line contains an integer n ~ (1 ⩽ n ⩽ 200 000) — size of B
Second line contains n integers b_1, b_2, …, b_n ~ (1 ⩽ b_i ⩽ 10^{18}) — numbers of B, all b_i are unique
Output
In the first line print single integer k – the number of erased elements. In the second line print k integers — values of erased elements.
If there are multiple answers, print any of them.
Examples
Input
3
1 2 3
Output
1
2
Input
2
2 6
Output
0 | ```python
import sys
input=sys.stdin.readline
import copy
from math import *
n=int(input())
a=[int(x) for x in input().split()]
d=[0 for i in range(70)]
for i in range(n):
d[int(log(a[i]&(-a[i]),2))]+=1
print(n-max(d))
r=d.index(max(d))
for i in range(n):
if int(log(a[i]&(-a[i]),2))!=r:
print(a[i],end=" ")
``` |
1245_F. Daniel and Spring Cleaning | While doing some spring cleaning, Daniel found an old calculator that he loves so much. However, it seems like it is broken. When he tries to compute 1 + 3 using the calculator, he gets 2 instead of 4. But when he tries computing 1 + 4, he gets the correct answer, 5. Puzzled by this mystery, he opened up his calculator and found the answer to the riddle: the full adders became half adders!
So, when he tries to compute the sum a + b using the calculator, he instead gets the xorsum a ⊕ b (read the definition by the link: <https://en.wikipedia.org/wiki/Exclusive_or>).
As he saw earlier, the calculator sometimes gives the correct answer. And so, he wonders, given integers l and r, how many pairs of integers (a, b) satisfy the following conditions: $$$a + b = a ⊕ b l ≤ a ≤ r l ≤ b ≤ r$$$
However, Daniel the Barman is going to the bar and will return in two hours. He tells you to solve the problem before he returns, or else you will have to enjoy being blocked.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of testcases.
Then, t lines follow, each containing two space-separated integers l and r (0 ≤ l ≤ r ≤ 10^9).
Output
Print t integers, the i-th integer should be the answer to the i-th testcase.
Example
Input
3
1 4
323 323
1 1000000
Output
8
0
3439863766
Note
a ⊕ b denotes the bitwise XOR of a and b.
For the first testcase, the pairs are: (1, 2), (1, 4), (2, 1), (2, 4), (3, 4), (4, 1), (4, 2), and (4, 3). | ```python
def g( a , b ):
cur = 1
res = 0
ze = 0
while cur <= b:
if b & cur:
b ^= cur
if a & b == 0:
res += ( 1 << ze )
if a & cur == 0:
ze = ze + 1
cur <<= 1
return res
def f( a , b ):
res = 0
if a == b:
return 0
if a == 0:
return 2 * b - 1 + f( 1 , b )
if a & 1:
res = res + 2 * ( g( a , b ) - g( a , a ) )
a = a + 1
if b & 1:
res = res + 2 * ( g( b - 1 , b ) - g( b - 1 , a ) )
return 3 * f( a >> 1 , b >> 1 ) + res
t = int(input())
while t > 0:
t = t - 1
l , r = map(int , input().split())
print( f( l , r + 1 ) )
``` |
1265_D. Beautiful Sequence | An integer sequence is called beautiful if the difference between any two consecutive numbers is equal to 1. More formally, a sequence s_1, s_2, …, s_{n} is beautiful if |s_i - s_{i+1}| = 1 for all 1 ≤ i ≤ n - 1.
Trans has a numbers 0, b numbers 1, c numbers 2 and d numbers 3. He wants to construct a beautiful sequence using all of these a + b + c + d numbers.
However, it turns out to be a non-trivial task, and Trans was not able to do it. Could you please help Trans?
Input
The only input line contains four non-negative integers a, b, c and d (0 < a+b+c+d ≤ 10^5).
Output
If it is impossible to construct a beautiful sequence satisfying the above constraints, print "NO" (without quotes) in one line.
Otherwise, print "YES" (without quotes) in the first line. Then in the second line print a + b + c + d integers, separated by spaces — a beautiful sequence. There should be a numbers equal to 0, b numbers equal to 1, c numbers equal to 2 and d numbers equal to 3.
If there are multiple answers, you can print any of them.
Examples
Input
2 2 2 1
Output
YES
0 1 0 1 2 3 2
Input
1 2 3 4
Output
NO
Input
2 2 2 3
Output
NO
Note
In the first test, it is easy to see, that the sequence is beautiful because the difference between any two consecutive numbers is equal to 1. Also, there are exactly two numbers, equal to 0, 1, 2 and exactly one number, equal to 3.
It can be proved, that it is impossible to construct beautiful sequences in the second and third tests. | ```python
_count = list(map(int, input().split()))
num = '0 1 2 3'.split()
for pos in range(4):
count = _count[:]
ans = []
for i in range(sum(count)):
ans.append(num[pos])
count[pos] -= 1
if pos == 1:
if count[0] > 0:
pos = 0
else:
pos = 2
elif pos == 2:
if count[3] > 0:
pos = 3
else:
pos = 1
elif pos == 0:
pos = 1
elif pos == 3:
pos = 2
if max(count) == min(count) == 0:
print('YES')
print(*ans)
exit()
else:
print('NO')
``` |
1370_C. Number Game | Ashishgup and FastestFinger play a game.
They start with a number n and play in turns. In each turn, a player can make any one of the following moves:
* Divide n by any of its odd divisors greater than 1.
* Subtract 1 from n if n is greater than 1.
Divisors of a number include the number itself.
The player who is unable to make a move loses the game.
Ashishgup moves first. Determine the winner of the game if both of them play optimally.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
The only line of each test case contains a single integer — n (1 ≤ n ≤ 10^9).
Output
For each test case, print "Ashishgup" if he wins, and "FastestFinger" otherwise (without quotes).
Example
Input
7
1
2
3
4
5
6
12
Output
FastestFinger
Ashishgup
Ashishgup
FastestFinger
Ashishgup
FastestFinger
Ashishgup
Note
In the first test case, n = 1, Ashishgup cannot make a move. He loses.
In the second test case, n = 2, Ashishgup subtracts 1 on the first move. Now n = 1, FastestFinger cannot make a move, so he loses.
In the third test case, n = 3, Ashishgup divides by 3 on the first move. Now n = 1, FastestFinger cannot make a move, so he loses.
In the last test case, n = 12, Ashishgup divides it by 3. Now n = 4, FastestFinger is forced to subtract 1, and Ashishgup gets 3, so he wins by dividing it by 3. | ```python
import math
def isPrime(n) :
# Corner cases
if (n <= 1) :
return False
if (n <= 3) :
return True
# This is checked so that we can skip
# middle five numbers in below loop
if (n % 2 == 0 or n % 3 == 0) :
return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
for _ in range(int(input())):
n=int(input())
#f==1 for ashish
f=1
if(n==1):
f=0
elif(n==2):
f=1
elif(n%2!=0):
f=1
else:
f=0
x=n//2
if(isPrime(x)):
f=0
elif(x&(x-1)==0):
f=0
else:
f=1
if(f==1):
print("Ashishgup")
else:
print("FastestFinger")
``` |
1392_H. ZS Shuffles Cards | zscoder has a deck of n+m custom-made cards, which consists of n cards labelled from 1 to n and m jokers. Since zscoder is lonely, he wants to play a game with himself using those cards.
Initially, the deck is shuffled uniformly randomly and placed on the table. zscoder has a set S which is initially empty.
Every second, zscoder draws the top card from the deck.
* If the card has a number x written on it, zscoder removes the card and adds x to the set S.
* If the card drawn is a joker, zscoder places all the cards back into the deck and reshuffles (uniformly randomly) the n+m cards to form a new deck (hence the new deck now contains all cards from 1 to n and the m jokers). Then, if S currently contains all the elements from 1 to n, the game ends. Shuffling the deck doesn't take time at all.
What is the expected number of seconds before the game ends? We can show that the answer can be written in the form P/Q where P, Q are relatively prime integers and Q ≠ 0 mod 998244353. Output the value of (P ⋅ Q^{-1}) modulo 998244353.
Input
The only line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^{6}).
Output
Output a single integer, the value of (P ⋅ Q^{-1}) modulo 998244353.
Examples
Input
2 1
Output
5
Input
3 2
Output
332748127
Input
14 9
Output
969862773
Note
For the first sample, it can be proven that the expected time before the game ends is 5 seconds.
For the second sample, it can be proven that the expected time before the game ends is 28/3 seconds. | ```python
def modInverse(a, m) :
m0 = m; y = 0; x = 1
if (m == 1): return 0
while (a > 1):
q = a // m; t = m; m = a % m; a = t; t = y; y = x - q * y; x = t
if (x < 0): x = x + m0
return x
prime = 998244353
n, m = map(int, input().split())
z = 0
for i in range(1, n+1): z += modInverse(i, prime)
ans = (1+m*z)*(1+n*modInverse(m+1, prime))
print(ans % prime)
``` |
1417_D. Make Them Equal | You are given an array a consisting of n positive integers, numbered from 1 to n. You can perform the following operation no more than 3n times:
1. choose three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9);
2. assign a_i := a_i - x ⋅ i, a_j := a_j + x ⋅ i.
After each operation, all elements of the array should be non-negative.
Can you find a sequence of no more than 3n operations after which all elements of the array are equal?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^4) — the number of elements in the array. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the elements of the array.
It is guaranteed that the sum of n over all test cases does not exceed 10^4.
Output
For each test case print the answer to it as follows:
* if there is no suitable sequence of operations, print -1;
* otherwise, print one integer k (0 ≤ k ≤ 3n) — the number of operations in the sequence. Then print k lines, the m-th of which should contain three integers i, j and x (1 ≤ i, j ≤ n; 0 ≤ x ≤ 10^9) for the m-th operation.
If there are multiple suitable sequences of operations, print any of them. Note that you don't have to minimize k.
Example
Input
3
4
2 16 4 18
6
1 2 3 4 5 6
5
11 19 1 1 3
Output
2
4 1 2
2 3 3
-1
4
1 2 4
2 4 5
2 3 3
4 5 1 | ```python
# ------------------- fast io --------------------
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")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#s = input()
req = sum(a) / n
if req != int(req):
print(-1)
continue
req = int(req)
print((n-1)*3)
for i in range(1, n):
next = (i + 1 - a[i]) % (i+1)
print(1, i+1, next)
a[0] -= next
a[i] += next
print(i+1, 1, a[i]//(i+1))
a[0] += a[i]
a[i] = 0
for i in range(1, n):
print(1, i+1, req)
``` |
1434_B. Shurikens | Tenten runs a weapon shop for ninjas. Today she is willing to sell n shurikens which cost 1, 2, ..., n ryo (local currency). During a day, Tenten will place the shurikens onto the showcase, which is empty at the beginning of the day. Her job is fairly simple: sometimes Tenten places another shuriken (from the available shurikens) on the showcase, and sometimes a ninja comes in and buys a shuriken from the showcase. Since ninjas are thrifty, they always buy the cheapest shuriken from the showcase.
Tenten keeps a record for all events, and she ends up with a list of the following types of records:
* + means that she placed another shuriken on the showcase;
* - x means that the shuriken of price x was bought.
Today was a lucky day, and all shurikens were bought. Now Tenten wonders if her list is consistent, and what could be a possible order of placing the shurikens on the showcase. Help her to find this out!
Input
The first line contains the only integer n (1≤ n≤ 10^5) standing for the number of shurikens.
The following 2n lines describe the events in the format described above. It's guaranteed that there are exactly n events of the first type, and each price from 1 to n occurs exactly once in the events of the second type.
Output
If the list is consistent, print "YES". Otherwise (that is, if the list is contradictory and there is no valid order of shurikens placement), print "NO".
In the first case the second line must contain n space-separated integers denoting the prices of shurikens in order they were placed. If there are multiple answers, print any.
Examples
Input
4
+
+
- 2
+
- 3
+
- 1
- 4
Output
YES
4 2 3 1
Input
1
- 1
+
Output
NO
Input
3
+
+
+
- 2
- 1
- 3
Output
NO
Note
In the first example Tenten first placed shurikens with prices 4 and 2. After this a customer came in and bought the cheapest shuriken which costed 2. Next, Tenten added a shuriken with price 3 on the showcase to the already placed 4-ryo. Then a new customer bought this 3-ryo shuriken. After this she added a 1-ryo shuriken. Finally, the last two customers bought shurikens 1 and 4, respectively. Note that the order [2, 4, 3, 1] is also valid.
In the second example the first customer bought a shuriken before anything was placed, which is clearly impossible.
In the third example Tenten put all her shurikens onto the showcase, after which a customer came in and bought a shuriken with price 2. This is impossible since the shuriken was not the cheapest, we know that the 1-ryo shuriken was also there. | ```python
import os
import sys
from io import BytesIO, IOBase
# 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()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(300000)
# from heapq import *
# from collections import deque as dq
# from math import ceil,floor,sqrt,pow
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
# from functools import lru_cache
n = N()
res = [0]*(n+2)
d = []
now = 0
flag = True
for _ in range(2*n):
s = input().strip()
# print(len(s))
if s=='+':
d.append(now)
now+=1
else:
v = int(s[2:])
if not d:
flag = False
break
t = d.pop()
if v<res[t+1]:
flag = False
break
res[t] = v
if not flag:
print('NO')
else:
print('YES')
print_list(res[:n])
``` |
1459_B. Move and Turn | A robot is standing at the origin of the infinite two-dimensional plane. Each second the robot moves exactly 1 meter in one of the four cardinal directions: north, south, west, and east. For the first step the robot can choose any of the four directions, but then at the end of every second it has to turn 90 degrees left or right with respect to the direction it just moved in. For example, if the robot has just moved north or south, the next step it takes has to be either west or east, and vice versa.
The robot makes exactly n steps from its starting position according to the rules above. How many different points can the robot arrive to at the end? The final orientation of the robot can be ignored.
Input
The only line contains a single integer n (1 ≤ n ≤ 1000) — the number of steps the robot makes.
Output
Print a single integer — the number of different possible locations after exactly n steps.
Examples
Input
1
Output
4
Input
2
Output
4
Input
3
Output
12
Note
In the first sample case, the robot will end up 1 meter north, south, west, or east depending on its initial direction.
In the second sample case, the robot will always end up √{2} meters north-west, north-east, south-west, or south-east. | ```python
def calculate(n):
res = 0
if (n%2 == 1):
for i in range(2, n+2, 2):
res += i
return res * 2
else:
if (n%4 == 0):
for i in range(1, int(n/2) + 1):
res += i
res *= 2
res += n/2 + 1
return int(res)
else:
for i in range(1, int(n/2) + 1):
res += i
res *= 2
res += (n+2)/2
return int(res)
print(calculate(int(input())))
``` |
1485_B. Replace and Keep Sorted | Given a positive integer k, two arrays are called k-similar if:
* they are strictly increasing;
* they have the same length;
* all their elements are positive integers between 1 and k (inclusive);
* they differ in exactly one position.
You are given an integer k, a strictly increasing array a and q queries. For each query, you are given two integers l_i ≤ r_i. Your task is to find how many arrays b exist, such that b is k-similar to array [a_{l_i},a_{l_i+1}…,a_{r_i}].
Input
The first line contains three integers n, q and k (1≤ n, q ≤ 10^5, n≤ k ≤ 10^9) — the length of array a, the number of queries and number k.
The second line contains n integers a_1, a_2, …,a_n (1 ≤ a_i ≤ k). This array is strictly increasing — a_1 < a_2 < … < a_n.
Each of the following q lines contains two integers l_i, r_i (1 ≤ l_i ≤ r_i ≤ n).
Output
Print q lines. The i-th of them should contain the answer to the i-th query.
Examples
Input
4 2 5
1 2 4 5
2 3
3 4
Output
4
3
Input
6 5 10
2 4 6 7 8 9
1 4
1 2
3 5
1 6
5 5
Output
8
9
7
6
9
Note
In the first example:
In the first query there are 4 arrays that are 5-similar to [2,4]: [1,4],[3,4],[2,3],[2,5].
In the second query there are 3 arrays that are 5-similar to [4,5]: [1,5],[2,5],[3,5]. | ```python
n, q, k = map(int, input().split())
a = list(map(int, input().split()))
b, c = [], [0]
if n > 1:
for i in range(n):
if i == 0:
b.append(a[i+1] - 3)
elif i == (n-1):
b.append(k - a[i-1] - 2)
else:
b.append(a[i+1] - a[i-1] - 2)
for i in range(n):
c.append(c[i] + b[i])
for i in range(q):
if n == 1:
print(k-1)
continue
result = 0
l, r = map(int, input().split())
if l == r:
print(k-1)
continue
l -= 1
r -= 1
result += a[l+1] + k - a[r-1] - 3
result += c[r] - c[l+1]
print(result)
``` |
1509_C. The Sports Festival | The student council is preparing for the relay race at the sports festival.
The council consists of n members. They will run one after the other in the race, the speed of member i is s_i. The discrepancy d_i of the i-th stage is the difference between the maximum and the minimum running speed among the first i members who ran. Formally, if a_i denotes the speed of the i-th member who participated in the race, then d_i = max(a_1, a_2, ..., a_i) - min(a_1, a_2, ..., a_i).
You want to minimize the sum of the discrepancies d_1 + d_2 + ... + d_n. To do this, you are allowed to change the order in which the members run. What is the minimum possible sum that can be achieved?
Input
The first line contains a single integer n (1 ≤ n ≤ 2000) — the number of members of the student council.
The second line contains n integers s_1, s_2, ..., s_n (1 ≤ s_i ≤ 10^9) – the running speeds of the members.
Output
Print a single integer — the minimum possible value of d_1 + d_2 + ... + d_n after choosing the order of the members.
Examples
Input
3
3 1 2
Output
3
Input
1
5
Output
0
Input
6
1 6 3 3 6 3
Output
11
Input
6
104 943872923 6589 889921234 1000000000 69
Output
2833800505
Note
In the first test case, we may choose to make the third member run first, followed by the first member, and finally the second. Thus a_1 = 2, a_2 = 3, and a_3 = 1. We have:
* d_1 = max(2) - min(2) = 2 - 2 = 0.
* d_2 = max(2, 3) - min(2, 3) = 3 - 2 = 1.
* d_3 = max(2, 3, 1) - min(2, 3, 1) = 3 - 1 = 2.
The resulting sum is d_1 + d_2 + d_3 = 0 + 1 + 2 = 3. It can be shown that it is impossible to achieve a smaller value.
In the second test case, the only possible rearrangement gives d_1 = 0, so the minimum possible result is 0. | ```python
n = int(input())
s = list(map(int, input().split()))
s.sort()
dp = [0]*n
for i in range(1, n):
for j in range(n-i):
dp[j] = s[i+j] - s[j] + min(dp[j], dp[j+1])
print(dp[0])
``` |
1535_D. Playoff Tournament | 2^k teams participate in a playoff tournament. The tournament consists of 2^k - 1 games. They are held as follows: first of all, the teams are split into pairs: team 1 plays against team 2, team 3 plays against team 4 (exactly in this order), and so on (so, 2^{k-1} games are played in that phase). When a team loses a game, it is eliminated, and each game results in elimination of one team (there are no ties). After that, only 2^{k-1} teams remain. If only one team remains, it is declared the champion; otherwise, 2^{k-2} games are played: in the first one of them, the winner of the game "1 vs 2" plays against the winner of the game "3 vs 4", then the winner of the game "5 vs 6" plays against the winner of the game "7 vs 8", and so on. This process repeats until only one team remains.
For example, this picture describes the chronological order of games with k = 3:
<image>
Let the string s consisting of 2^k - 1 characters describe the results of the games in chronological order as follows:
* if s_i is 0, then the team with lower index wins the i-th game;
* if s_i is 1, then the team with greater index wins the i-th game;
* if s_i is ?, then the result of the i-th game is unknown (any team could win this game).
Let f(s) be the number of possible winners of the tournament described by the string s. A team i is a possible winner of the tournament if it is possible to replace every ? with either 1 or 0 in such a way that team i is the champion.
You are given the initial state of the string s. You have to process q queries of the following form:
* p c — replace s_p with character c, and print f(s) as the result of the query.
Input
The first line contains one integer k (1 ≤ k ≤ 18).
The second line contains a string consisting of 2^k - 1 characters — the initial state of the string s. Each character is either ?, 0, or 1.
The third line contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
Then q lines follow, the i-th line contains an integer p and a character c (1 ≤ p ≤ 2^k - 1; c is either ?, 0, or 1), describing the i-th query.
Output
For each query, print one integer — f(s).
Example
Input
3
0110?11
6
5 1
6 ?
7 ?
1 ?
5 ?
1 1
Output
1
2
3
3
5
4 | ```python
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def solve(z, dp, s):
n = len(dp)
while 1:
dp[z] = 0
if s[z] == '?':
if 2 * z + 1 < n:
dp[z] += dp[2 * z + 1]
else:
dp[z] += 1
if 2 * z + 2 < n:
dp[z] += dp[2 * z + 2]
else:
dp[z] += 1
elif s[z] == "1":
if 2 * z + 1 < n:
dp[z] += dp[2 * z + 1]
else:
dp[z] += 1
else:
if 2 * z + 2 < n:
dp[z] += dp[2 * z + 2]
else:
dp[z] += 1
if not z:
return
z = (z - 1) // 2
def main():
input()
s = list(input().rstrip())
s.reverse()
n = len(s)
dp = [0] * n
for i in range(n - 1, -1, -1):
if s[i] == "?":
if 2 * i + 1 < n:
dp[i] += dp[2 * i + 1]
else:
dp[i] += 1
if 2 * i + 2 < n:
dp[i] += dp[2 * i + 2]
else:
dp[i] += 1
elif s[i] == "1":
if 2 * i + 1 < n:
dp[i] += dp[2 * i + 1]
else:
dp[i] = 1
else:
if 2 * i + 2 < n:
dp[i] += dp[2 * i + 2]
else:
dp[i] = 1
for i in range(int(input())):
x, y = input().split()
x = n - int(x)
s[x] = y
solve(x, dp, s)
print(dp[0])
# 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")
if __name__ == "__main__":
main()
``` |
22_D. Segments | You are given n segments on the Ox-axis. You can drive a nail in any integer point on the Ox-axis line nail so, that all segments containing this point, are considered nailed down. If the nail passes through endpoint of some segment, this segment is considered to be nailed too. What is the smallest number of nails needed to nail all the segments down?
Input
The first line of the input contains single integer number n (1 ≤ n ≤ 1000) — amount of segments. Following n lines contain descriptions of the segments. Each description is a pair of integer numbers — endpoints coordinates. All the coordinates don't exceed 10000 by absolute value. Segments can degenarate to points.
Output
The first line should contain one integer number — the smallest number of nails needed to nail all the segments down. The second line should contain coordinates of driven nails separated by space in any order. If the answer is not unique, output any.
Examples
Input
2
0 2
2 5
Output
1
2
Input
5
0 3
4 2
4 8
8 10
7 7
Output
3
7 10 3 | ```python
n = int(input())
lis = list()
cou = 1
arr = list()
for i in range(n):
a, b = map(int, input().split())
if a > b:
lis.append([b, a])
else:
lis.append([a, b])
lis = sorted(lis, key=lambda l: l[1])
i = 0
j = 1
arr.append(lis[i][1])
while(i < n and j < n):
if lis[i][1] < lis[j][0]:
cou += 1
i = j
arr.append(lis[i][1])
else:
j += 1
print(cou)
print(*arr)
``` |
255_C. Almost Arithmetical Progression | Gena loves sequences of numbers. Recently, he has discovered a new type of sequences which he called an almost arithmetical progression. A sequence is an almost arithmetical progression, if its elements can be represented as:
* a1 = p, where p is some integer;
* ai = ai - 1 + ( - 1)i + 1·q (i > 1), where q is some integer.
Right now Gena has a piece of paper with sequence b, consisting of n integers. Help Gena, find there the longest subsequence of integers that is an almost arithmetical progression.
Sequence s1, s2, ..., sk is a subsequence of sequence b1, b2, ..., bn, if there is such increasing sequence of indexes i1, i2, ..., ik (1 ≤ i1 < i2 < ... < ik ≤ n), that bij = sj. In other words, sequence s can be obtained from b by crossing out some elements.
Input
The first line contains integer n (1 ≤ n ≤ 4000). The next line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 106).
Output
Print a single integer — the length of the required longest subsequence.
Examples
Input
2
3 5
Output
2
Input
4
10 20 10 30
Output
3
Note
In the first test the sequence actually is the suitable subsequence.
In the second test the following subsequence fits: 10, 20, 10. | ```python
import sys
from math import log2,floor,ceil,sqrt
# import bisect
# from collections import deque
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD = 10**9+7
n = int(ri())
arr = Ri()
a = sorted(arr)
dic = {}
ite = 1
for i in range(n):
if a[i] not in dic:
dic[a[i]] = ite
ite+=1
for i in range(n):
arr[i] = dic[arr[i]]
dp = list2d(n,n+1,0)
for i in range(n):
for j in range(n+1):
dp[i][j] = 1
maxx = 1
for i in range(1,n):
for j in range(i-1,-1,-1):
dp[i][arr[j]] = max(dp[i][arr[j]], dp[j][arr[i]]+1)
maxx = max(maxx,dp[i][arr[j]])
print(maxx)
``` |
279_C. Ladder | You've got an array, consisting of n integers a1, a2, ..., an. Also, you've got m queries, the i-th query is described by two integers li, ri. Numbers li, ri define a subsegment of the original array, that is, the sequence of numbers ali, ali + 1, ali + 2, ..., ari. For each query you should check whether the corresponding segment is a ladder.
A ladder is a sequence of integers b1, b2, ..., bk, such that it first doesn't decrease, then doesn't increase. In other words, there is such integer x (1 ≤ x ≤ k), that the following inequation fulfills: b1 ≤ b2 ≤ ... ≤ bx ≥ bx + 1 ≥ bx + 2... ≥ bk. Note that the non-decreasing and the non-increasing sequences are also considered ladders.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of array elements and the number of queries. The second line contains the sequence of integers a1, a2, ..., an (1 ≤ ai ≤ 109), where number ai stands for the i-th array element.
The following m lines contain the description of the queries. The i-th line contains the description of the i-th query, consisting of two integers li, ri (1 ≤ li ≤ ri ≤ n) — the boundaries of the subsegment of the initial array.
The numbers in the lines are separated by single spaces.
Output
Print m lines, in the i-th line print word "Yes" (without the quotes), if the subsegment that corresponds to the i-th query is the ladder, or word "No" (without the quotes) otherwise.
Examples
Input
8 6
1 2 1 3 3 5 2 1
1 3
2 3
2 4
8 8
1 4
5 8
Output
Yes
Yes
No
Yes
No
Yes | ```python
n,q = map(int,input().split())
arr = [int(x) for x in input().split()]
inc = [-1] * n
dec = [-1] * n
inc[n-1] = n-1
for i in range(n-2, -1, -1):
if(arr[i]<=arr[i+1]):
inc[i] = inc[i+1]
else:
inc[i] = i
dec[n-1] = n-1
for i in range(n-2, -1, -1):
if(arr[i]>=arr[i+1]):
dec[i] = dec[i+1]
else:
dec[i] = i
for i in range(q):
l,r = map(int,input().split())
if(dec[inc[l-1]]>=r-1):
print("Yes")
else:
print("No")
``` |
301_B. Yaroslav and Time | Yaroslav is playing a game called "Time". The game has a timer showing the lifespan he's got left. As soon as the timer shows 0, Yaroslav's character dies and the game ends. Also, the game has n clock stations, station number i is at point (xi, yi) of the plane. As the player visits station number i, he increases the current time on his timer by ai. The stations are for one-time use only, so if the player visits some station another time, the time on his timer won't grow.
A player spends d·dist time units to move between stations, where dist is the distance the player has covered and d is some constant. The distance between stations i and j is determined as |xi - xj| + |yi - yj|.
Initially, the player is at station number 1, and the player has strictly more than zero and strictly less than one units of time. At station number 1 one unit of money can increase the time on the timer by one time unit (you can buy only integer number of time units).
Now Yaroslav is wondering, how much money he needs to get to station n. Help Yaroslav. Consider the time to buy and to increase the timer value negligibly small.
Input
The first line contains integers n and d (3 ≤ n ≤ 100, 103 ≤ d ≤ 105) — the number of stations and the constant from the statement.
The second line contains n - 2 integers: a2, a3, ..., an - 1 (1 ≤ ai ≤ 103). The next n lines contain the coordinates of the stations. The i-th of them contains two integers xi, yi (-100 ≤ xi, yi ≤ 100).
It is guaranteed that no two stations are located at the same point.
Output
In a single line print an integer — the answer to the problem.
Examples
Input
3 1000
1000
0 0
0 1
0 3
Output
2000
Input
3 1000
1000
1 0
1 1
1 2
Output
1000 | ```python
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
n, dc = mints()
a = list(mints())
a.append(0)
x = [0]*n
y = [0]*n
for i in range(n):
x[i], y[i] = mints()
d = [1<<30]*n
d[0] = 0
was = [False]*n
for i in range(n):
m = 1<<30
mi = 0
for j in range(n):
if not was[j] and m > d[j]:
m = d[j]
mi = j
j = mi
was[j] = True
for k in range(n):
if not was[k]:
dd = d[j] + (abs(x[k]-x[j])+abs(y[k]-y[j]))*dc
dd -= a[k-1]
if d[k] > dd:
d[k] = dd
print(d[-1])
solve()
``` |
34_A. Reconnaissance 2 | n soldiers stand in a circle. For each soldier his height ai is known. A reconnaissance unit can be made of such two neighbouring soldiers, whose heights difference is minimal, i.e. |ai - aj| is minimal. So each of them will be less noticeable with the other. Output any pair of soldiers that can form a reconnaissance unit.
Input
The first line contains integer n (2 ≤ n ≤ 100) — amount of soldiers. Then follow the heights of the soldiers in their order in the circle — n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 1000). The soldier heights are given in clockwise or counterclockwise direction.
Output
Output two integers — indexes of neighbouring soldiers, who should form a reconnaissance unit. If there are many optimum solutions, output any of them. Remember, that the soldiers stand in a circle.
Examples
Input
5
10 12 13 15 10
Output
5 1
Input
4
10 20 30 40
Output
1 2 | ```python
n = int(input())
a = list(map(int, input().split()))
x = a[0]
for i in range(n-1):
a[i] = abs(a[i] - a[i+1])
a[-1] = abs(x - a[-1])
m = min(a)
ind = a.index(m)
p, q = ind+1, ind+2
if q > n:
q = 1
print(p,q)
``` |
373_B. Making Sequences is Fun | We'll define S(n) for positive integer n as follows: the number of the n's digits in the decimal base. For example, S(893) = 3, S(114514) = 6.
You want to make a consecutive integer sequence starting from number m (m, m + 1, ...). But you need to pay S(n)·k to add the number n to the sequence.
You can spend a cost up to w, and you want to make the sequence as long as possible. Write a program that tells sequence's maximum length.
Input
The first line contains three integers w (1 ≤ w ≤ 1016), m (1 ≤ m ≤ 1016), k (1 ≤ k ≤ 109).
Please, do not write the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
The first line should contain a single integer — the answer to the problem.
Examples
Input
9 1 1
Output
9
Input
77 7 7
Output
7
Input
114 5 14
Output
6
Input
1 1 2
Output
0 | ```python
from math import *
w, m, k = list(map(int, input().split()))
cnt = 0
add = 9*10**(-1) if m < 10 else 0
for i in range(int(log10(m)), int(1e10)):
v = (9 * 10**i - (m-1-9*10**(i-1)+add if i == int(log10(m)) else 0)) * (i+1) * k
if w - v < 0:
cnt += w//((i+1)*k)
break
w -= v
cnt += v//(k*(i+1))
print(int(cnt))
``` |
394_D. Physical Education and Buns | The Physical education teacher at SESC is a sort of mathematician too. His most favorite topic in mathematics is progressions. That is why the teacher wants the students lined up in non-decreasing height form an arithmetic progression.
To achieve the goal, the gym teacher ordered a lot of magical buns from the dining room. The magic buns come in two types: when a student eats one magic bun of the first type, his height increases by one, when the student eats one magical bun of the second type, his height decreases by one. The physical education teacher, as expected, cares about the health of his students, so he does not want them to eat a lot of buns. More precisely, he wants the maximum number of buns eaten by some student to be minimum.
Help the teacher, get the maximum number of buns that some pupils will have to eat to achieve the goal of the teacher. Also, get one of the possible ways for achieving the objective, namely, the height of the lowest student in the end and the step of the resulting progression.
Input
The single line contains integer n (2 ≤ n ≤ 103) — the number of students. The second line contains n space-separated integers — the heights of all students. The height of one student is an integer which absolute value doesn't exceed 104.
Output
In the first line print the maximum number of buns eaten by some student to achieve the teacher's aim. In the second line, print two space-separated integers — the height of the lowest student in the end and the step of the progression. Please, pay attention that the step should be non-negative.
If there are multiple possible answers, you can print any of them.
Examples
Input
5
-3 -4 -2 -3 3
Output
2
-3 1
Input
5
2 -3 -1 -4 3
Output
1
-4 2
Note
Lets look at the first sample. We can proceed in the following manner:
* don't feed the 1-st student, his height will stay equal to -3;
* give two buns of the first type to the 2-nd student, his height become equal to -2;
* give two buns of the first type to the 3-rd student, his height become equal to 0;
* give two buns of the first type to the 4-th student, his height become equal to -1;
* give two buns of the second type to the 5-th student, his height become equal to 1.
To sum it up, when the students line up in non-decreasing height it will be an arithmetic progression: -3, -2, -1, 0, 1. The height of the lowest student is equal to -3, the step of the progression is equal to 1. The maximum number of buns eaten by one student is equal to 2. | ```python
q = 10001
n, a = int(input()), list(map(int, input().split()))
a.sort()
for i in range(40000 // (n - 1) + 1):
b = [a[j] - j * i for j in range(n)]
u, v = max(b), min(b)
p = (u - v + 1) // 2
if p < q: q, s, d = p, v + p, i
print(q)
print(s, d)
``` |
417_E. Square Table | While resting on the ship after the "Russian Code Cup" a boy named Misha invented an interesting game. He promised to give his quadrocopter to whoever will be the first one to make a rectangular table of size n × m, consisting of positive integers such that the sum of the squares of numbers for each row and each column was also a square.
Since checking the correctness of the table manually is difficult, Misha asks you to make each number in the table to not exceed 108.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 100) — the size of the table.
Output
Print the table that meets the condition: n lines containing m integers, separated by spaces. If there are multiple possible answers, you are allowed to print anyone. It is guaranteed that there exists at least one correct answer.
Examples
Input
1 1
Output
1
Input
1 2
Output
3 4 | ```python
"""
Codeforces Round 241 Div 1 Problem E
Author : chaotic_iak
Language: Python 3.3.4
"""
class InputHandlerObject(object):
inputs = []
def getInput(self, n = 0):
res = ""
inputs = self.inputs
if not inputs: inputs.extend(input().split(" "))
if n == 0:
res = inputs[:]
inputs[:] = []
while n > len(inputs):
inputs.extend(input().split(" "))
if n > 0:
res = inputs[:n]
inputs[:n] = []
return res
InputHandler = InputHandlerObject()
g = InputHandler.getInput
############################## SOLUTION ##############################
n,m = [int(x) for x in g()]
def sqr(n):
if n == 1:
return [1]
if n == 2:
return [4,3]
if n % 2:
return [(n+1)//2, 2] + [1] * (n-2)
return [(n-2)//2] + [1] * (n-1)
a = sqr(n)
b = sqr(m)
for i in range(n):
res = [str(a[i]*x) for x in b]
print(" ".join(res))
``` |
466_D. Increase Sequence | Peter has a sequence of integers a1, a2, ..., an. Peter wants all numbers in the sequence to equal h. He can perform the operation of "adding one on the segment [l, r]": add one to all elements of the sequence with indices from l to r (inclusive). At that, Peter never chooses any element as the beginning of the segment twice. Similarly, Peter never chooses any element as the end of the segment twice. In other words, for any two segments [l1, r1] and [l2, r2], where Peter added one, the following inequalities hold: l1 ≠ l2 and r1 ≠ r2.
How many distinct ways are there to make all numbers in the sequence equal h? Print this number of ways modulo 1000000007 (109 + 7). Two ways are considered distinct if one of them has a segment that isn't in the other way.
Input
The first line contains two integers n, h (1 ≤ n, h ≤ 2000). The next line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 2000).
Output
Print a single integer — the answer to the problem modulo 1000000007 (109 + 7).
Examples
Input
3 2
1 1 1
Output
4
Input
5 1
1 1 1 1 1
Output
1
Input
4 3
3 2 1 1
Output
0 | ```python
n,h = map(int,input().split())
a = list(map(int,input().split()))
a = [h-i for i in a]
if min(a) < 0 or a[0] > 1 or a[-1] > 1:
print(0)
else:
t = 1
for i in range(1,n):
dif = a[i-1]-a[i]
if dif >1 or dif <-1:t = 0
else:
if dif == 0:t*=(a[i-1]+1)
elif dif == 1:t*=(a[i-1])
#print(t)
t%=(1000000000+7)
print(t)
``` |
48_B. Land Lot | Vasya has a beautiful garden where wonderful fruit trees grow and yield fantastic harvest every year. But lately thieves started to sneak into the garden at nights and steal the fruit too often. Vasya can’t spend the nights in the garden and guard the fruit because there’s no house in the garden! Vasya had been saving in for some time and finally he decided to build the house. The rest is simple: he should choose in which part of the garden to build the house. In the evening he sat at his table and drew the garden’s plan. On the plan the garden is represented as a rectangular checkered field n × m in size divided into squares whose side length is 1. In some squares Vasya marked the trees growing there (one shouldn’t plant the trees too close to each other that’s why one square contains no more than one tree). Vasya wants to find a rectangular land lot a × b squares in size to build a house on, at that the land lot border should go along the lines of the grid that separates the squares. All the trees that grow on the building lot will have to be chopped off. Vasya loves his garden very much, so help him choose the building land lot location so that the number of chopped trees would be as little as possible.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 50) which represent the garden location. The next n lines contain m numbers 0 or 1, which describe the garden on the scheme. The zero means that a tree doesn’t grow on this square and the 1 means that there is a growing tree. The last line contains two integers a and b (1 ≤ a, b ≤ 50). Note that Vasya can choose for building an a × b rectangle as well a b × a one, i.e. the side of the lot with the length of a can be located as parallel to the garden side with the length of n, as well as parallel to the garden side with the length of m.
Output
Print the minimum number of trees that needs to be chopped off to select a land lot a × b in size to build a house on. It is guaranteed that at least one lot location can always be found, i. e. either a ≤ n and b ≤ m, or a ≤ m и b ≤ n.
Examples
Input
2 2
1 0
1 1
1 1
Output
0
Input
4 5
0 0 1 0 1
0 1 1 1 0
1 0 1 0 1
1 1 1 1 1
2 3
Output
2
Note
In the second example the upper left square is (1,1) and the lower right is (3,2). | ```python
n, m = map(int, input().split())
t = [[0] * (m + 1)] + [[] for i in range(n)]
t[1] = [0] + list(map(int, input().split()))
for j in range(2, m + 1): t[1][j] += t[1][j - 1]
for i in range(2, n + 1):
t[i] = [0] + list(map(int, input().split()))
for j in range(2, m + 1): t[i][j] += t[i][j - 1]
for j in range(1, m + 1): t[i][j] += t[i - 1][j]
a, b = map(int, input().split())
if a <= n and b <= m:
p = min(t[i + a][j + b] + t[i][j] - t[i + a][j] - t[i][j + b] for i in range(n - a + 1) for j in range(m - b + 1))
a, b = b, a
if a <= n and b <= m:
q = min(t[i + a][j + b] + t[i][j] - t[i + a][j] - t[i][j + b] for i in range(n - a + 1) for j in range(m - b + 1))
if b <= n and a <= m: p = min(p, q)
else: p = q
print(p)
``` |
567_B. Berland National Library | Berland National Library has recently been built in the capital of Berland. In addition, in the library you can take any of the collected works of Berland leaders, the library has a reading room.
Today was the pilot launch of an automated reading room visitors' accounting system! The scanner of the system is installed at the entrance to the reading room. It records the events of the form "reader entered room", "reader left room". Every reader is assigned a registration number during the registration procedure at the library — it's a unique integer from 1 to 106. Thus, the system logs events of two forms:
* "+ ri" — the reader with registration number ri entered the room;
* "- ri" — the reader with registration number ri left the room.
The first launch of the system was a success, it functioned for some period of time, and, at the time of its launch and at the time of its shutdown, the reading room may already have visitors.
Significant funds of the budget of Berland have been spent on the design and installation of the system. Therefore, some of the citizens of the capital now demand to explain the need for this system and the benefits that its implementation will bring. Now, the developers of the system need to urgently come up with reasons for its existence.
Help the system developers to find the minimum possible capacity of the reading room (in visitors) using the log of the system available to you.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100) — the number of records in the system log. Next follow n events from the system journal in the order in which the were made. Each event was written on a single line and looks as "+ ri" or "- ri", where ri is an integer from 1 to 106, the registration number of the visitor (that is, distinct visitors always have distinct registration numbers).
It is guaranteed that the log is not contradictory, that is, for every visitor the types of any of his two consecutive events are distinct. Before starting the system, and after stopping the room may possibly contain visitors.
Output
Print a single integer — the minimum possible capacity of the reading room.
Examples
Input
6
+ 12001
- 12001
- 1
- 1200
+ 1
+ 7
Output
3
Input
2
- 1
- 2
Output
2
Input
2
+ 1
- 1
Output
1
Note
In the first sample test, the system log will ensure that at some point in the reading room were visitors with registration numbers 1, 1200 and 12001. More people were not in the room at the same time based on the log. Therefore, the answer to the test is 3. | ```python
'''input
2
+ 1
- 1
'''
m, p = 0, []
for _ in range(int(input())):
i = input().split()
if i[0] == "+":
p.append(i[1])
else:
if i[1] in p:
p.remove(i[1])
else:
m += 1
m = max(m, len(p))
print(m)
``` |
610_A. Pasha and Stick | Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | ```python
x=int(input())
print((x%2==0)*((x//2-1)//2))
#fueaijskrgd/t
``` |
630_K. Indivisibility | IT City company developing computer games decided to upgrade its way to reward its employees. Now it looks the following way. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is not divisible by any number from 2 to 10 every developer of this game gets a small bonus.
A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.
Input
The only line of the input contains one integer n (1 ≤ n ≤ 1018) — the prediction on the number of people who will buy the game.
Output
Output one integer showing how many numbers from 1 to n are not divisible by any number from 2 to 10.
Examples
Input
12
Output
2 | ```python
def precalc(st, end):
count = 0
for i in range(st, end + 1):
if not any(i % k == 0 for k in [2,3,5,7]):
count += 1
return count
n = int(input())
buckets = 2*3*4*5*6*7
c = int(n / buckets)
res = c * precalc(1, buckets) + precalc(c * buckets+1, n)
print(res)
``` |
659_C. Tanya and Toys | In Berland recently a new collection of toys went on sale. This collection consists of 109 types of toys, numbered with integers from 1 to 109. A toy from the new collection of the i-th type costs i bourles.
Tania has managed to collect n different types of toys a1, a2, ..., an from the new collection. Today is Tanya's birthday, and her mother decided to spend no more than m bourles on the gift to the daughter. Tanya will choose several different types of toys from the new collection as a gift. Of course, she does not want to get a type of toy which she already has.
Tanya wants to have as many distinct types of toys in her collection as possible as the result. The new collection is too diverse, and Tanya is too little, so she asks you to help her in this.
Input
The first line contains two integers n (1 ≤ n ≤ 100 000) and m (1 ≤ m ≤ 109) — the number of types of toys that Tanya already has and the number of bourles that her mom is willing to spend on buying new toys.
The next line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the types of toys that Tanya already has.
Output
In the first line print a single integer k — the number of different types of toys that Tanya should choose so that the number of different types of toys in her collection is maximum possible. Of course, the total cost of the selected toys should not exceed m.
In the second line print k distinct space-separated integers t1, t2, ..., tk (1 ≤ ti ≤ 109) — the types of toys that Tanya should choose.
If there are multiple answers, you may print any of them. Values of ti can be printed in any order.
Examples
Input
3 7
1 3 4
Output
2
2 5
Input
4 14
4 6 12 8
Output
4
7 2 3 1
Note
In the first sample mom should buy two toys: one toy of the 2-nd type and one toy of the 5-th type. At any other purchase for 7 bourles (assuming that the toys of types 1, 3 and 4 have already been bought), it is impossible to buy two and more toys. | ```python
n, m = map(int, input().split())
a = set(map(int, input().split()))
s, z, k = "", 1, 0
while m >= z:
if z not in a:
m -= z
k += 1
s+=(str(z)+" ")
z += 1
print(k)
print(s)
``` |
727_B. Bill Total Value | Vasily exited from a store and now he wants to recheck the total price of all purchases in his bill. The bill is a string in which the names of the purchases and their prices are printed in a row without any spaces. Check has the format "name1price1name2price2...namenpricen", where namei (name of the i-th purchase) is a non-empty string of length not more than 10, consisting of lowercase English letters, and pricei (the price of the i-th purchase) is a non-empty string, consisting of digits and dots (decimal points). It is possible that purchases with equal names have different prices.
The price of each purchase is written in the following format. If the price is an integer number of dollars then cents are not written.
Otherwise, after the number of dollars a dot (decimal point) is written followed by cents in a two-digit format (if number of cents is between 1 and 9 inclusively, there is a leading zero).
Also, every three digits (from less significant to the most) in dollars are separated by dot (decimal point). No extra leading zeroes are allowed. The price always starts with a digit and ends with a digit.
For example:
* "234", "1.544", "149.431.10", "0.99" and "123.05" are valid prices,
* ".333", "3.33.11", "12.00", ".33", "0.1234" and "1.2" are not valid.
Write a program that will find the total price of all purchases in the given bill.
Input
The only line of the input contains a non-empty string s with length not greater than 1000 — the content of the bill.
It is guaranteed that the bill meets the format described above. It is guaranteed that each price in the bill is not less than one cent and not greater than 106 dollars.
Output
Print the total price exactly in the same format as prices given in the input.
Examples
Input
chipsy48.32televizor12.390
Output
12.438.32
Input
a1b2c3.38
Output
6.38
Input
aa0.01t0.03
Output
0.04 | ```python
import re
def spnum(s):
a = s.split(".")
if len(a[-1]) == 2:
a.append(a[-1])
a[-2] = '.'
return eval("".join(a))
s = input()
dollars = re.findall(r"[.0-9]+", s)
for i in range(len(dollars)):
if "." in dollars[i]:
dollars[i] = spnum(dollars[i])
else:
dollars[i] = eval(dollars[i])
#print(dollars)
ans = eval("%0.2f"%(sum(dollars)))
if ans - int(ans) == 0:
ans = int(ans)
ans = str(ans)
anss = []
cur = 0
#print(ans)
if "." in ans:
anss.append(ans[-3:len(ans)])
#print(anss)
for i in range(4, len(ans)+1):
cur += 1
anss.append(ans[-i])
if cur % 3 == 0 and i != len(ans):
cur = 0
anss.append(".")
#print(anss)
else:
for i in range(1, len(ans)+1):
cur += 1
anss.append(ans[-i])
if cur % 3 == 0 and i != len(ans):
cur = 0
anss.append(".")
ans = "".join(anss[::-1])
if (len(ans) >= 3 and ans[-2] == "."):
print(ans+"0")
else:
print(ans)
``` |
748_C. Santa Claus and Robot | Santa Claus has Robot which lives on the infinite grid and can move along its lines. He can also, having a sequence of m points p1, p2, ..., pm with integer coordinates, do the following: denote its initial location by p0. First, the robot will move from p0 to p1 along one of the shortest paths between them (please notice that since the robot moves only along the grid lines, there can be several shortest paths). Then, after it reaches p1, it'll move to p2, again, choosing one of the shortest ways, then to p3, and so on, until he has visited all points in the given order. Some of the points in the sequence may coincide, in that case Robot will visit that point several times according to the sequence order.
While Santa was away, someone gave a sequence of points to Robot. This sequence is now lost, but Robot saved the protocol of its unit movements. Please, find the minimum possible length of the sequence.
Input
The first line of input contains the only positive integer n (1 ≤ n ≤ 2·105) which equals the number of unit segments the robot traveled. The second line contains the movements protocol, which consists of n letters, each being equal either L, or R, or U, or D. k-th letter stands for the direction which Robot traveled the k-th unit segment in: L means that it moved to the left, R — to the right, U — to the top and D — to the bottom. Have a look at the illustrations for better explanation.
Output
The only line of input should contain the minimum possible length of the sequence.
Examples
Input
4
RURD
Output
2
Input
6
RRULDD
Output
2
Input
26
RRRULURURUULULLLDLDDRDRDLD
Output
7
Input
3
RLL
Output
2
Input
4
LRLR
Output
4
Note
The illustrations to the first three tests are given below.
<image> <image> <image>
The last example illustrates that each point in the sequence should be counted as many times as it is presented in the sequence. | ```python
n = int(input())
line = input()
moves = 'UDLR'
used = dict()
opp = dict()
opp['U'] = 'D'
opp['D'] = 'U'
opp['L'] = 'R'
opp['R'] = 'L'
for i in moves:
used[i] = 0
i = len(line) - 1
ans = 0
while i >= 0:
ans += 1
for j in moves:
used[j] = 0
while i >= 0 and not used[opp[line[i]]]:
used[line[i]] = 1
i -= 1
print(ans)
``` |
771_B. Bear and Different Names | In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO". | ```python
l=['Aa','Ab','Ac','Ad','Ae','Af','Ag','Ah','Ai','Aj','Ak','Al','Am','An','Ao','Ap','Aq','Ar','As','At','Au','Av','Aw','Ax','Ay','Az','Aaa','Abb','Acc','Add','Aee','Aff','Agg','Ahh','Aii','Ajj','Akk','All','Amm','Ann','Aoo','App','Aqq','Arr','Ass','Att','Auu','Avv','Aww','Axx','Ayy']
n,k=map(int,input().split())
li=list(map(str,input().split()))
lc=l[:n]
for i in range(len(li)):
if li[i]=="NO":
lc[i+k-1]=lc[i]
for i in lc:
print(i,end=" ")
``` |
796_B. Find The Bone | Zane the wizard is going to perform a magic show shuffling the cups.
There are n cups, numbered from 1 to n, placed along the x-axis on a table that has m holes on it. More precisely, cup i is on the table at the position x = i.
The problematic bone is initially at the position x = 1. Zane will confuse the audience by swapping the cups k times, the i-th time of which involves the cups at the positions x = ui and x = vi. If the bone happens to be at the position where there is a hole at any time, it will fall into the hole onto the ground and will not be affected by future swapping operations.
Do not forget that Zane is a wizard. When he swaps the cups, he does not move them ordinarily. Instead, he teleports the cups (along with the bone, if it is inside) to the intended positions. Therefore, for example, when he swaps the cup at x = 4 and the one at x = 6, they will not be at the position x = 5 at any moment during the operation.
<image>
Zane’s puppy, Inzane, is in trouble. Zane is away on his vacation, and Inzane cannot find his beloved bone, as it would be too exhausting to try opening all the cups. Inzane knows that the Codeforces community has successfully helped Zane, so he wants to see if it could help him solve his problem too. Help Inzane determine the final position of the bone.
Input
The first line contains three integers n, m, and k (2 ≤ n ≤ 106, 1 ≤ m ≤ n, 1 ≤ k ≤ 3·105) — the number of cups, the number of holes on the table, and the number of swapping operations, respectively.
The second line contains m distinct integers h1, h2, ..., hm (1 ≤ hi ≤ n) — the positions along the x-axis where there is a hole on the table.
Each of the next k lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the positions of the cups to be swapped.
Output
Print one integer — the final position along the x-axis of the bone.
Examples
Input
7 3 4
3 4 6
1 2
2 5
5 7
7 1
Output
1
Input
5 1 2
2
1 2
2 4
Output
2
Note
In the first sample, after the operations, the bone becomes at x = 2, x = 5, x = 7, and x = 1, respectively.
In the second sample, after the first operation, the bone becomes at x = 2, and falls into the hole onto the ground. | ```python
n , m , k = list(map(int,input().split()))
h = list(map(int,input().split()))
used = [0] * int(1e7)
for x in h:
used[x] = 1
t = 1
for i in range(k):
u , v = list(map(int,input().split()))
if used[t]:
print(t)
exit(0)
elif u == t:
if used[v] == 1:
print(v)
exit(0)
t = v
elif v == t:
if used[u] == 1:
print(u)
exit(0)
t = u
print(t)
``` |
816_C. Karen and Game | On the way to school, Karen became fixated on the puzzle game on her phone!
<image>
The game is played as follows. In each level, you have a grid with n rows and m columns. Each cell originally contains the number 0.
One move consists of choosing one row or column, and adding 1 to all of the cells in that row or column.
To win the level, after all the moves, the number in the cell at the i-th row and j-th column should be equal to gi, j.
Karen is stuck on one level, and wants to know a way to beat this level using the minimum number of moves. Please, help her with this task!
Input
The first line of input contains two integers, n and m (1 ≤ n, m ≤ 100), the number of rows and the number of columns in the grid, respectively.
The next n lines each contain m integers. In particular, the j-th integer in the i-th of these rows contains gi, j (0 ≤ gi, j ≤ 500).
Output
If there is an error and it is actually not possible to beat the level, output a single integer -1.
Otherwise, on the first line, output a single integer k, the minimum number of moves necessary to beat the level.
The next k lines should each contain one of the following, describing the moves in the order they must be done:
* row x, (1 ≤ x ≤ n) describing a move of the form "choose the x-th row".
* col x, (1 ≤ x ≤ m) describing a move of the form "choose the x-th column".
If there are multiple optimal solutions, output any one of them.
Examples
Input
3 5
2 2 2 3 2
0 0 0 1 0
1 1 1 2 1
Output
4
row 1
row 1
col 4
row 3
Input
3 3
0 0 0
0 1 0
0 0 0
Output
-1
Input
3 3
1 1 1
1 1 1
1 1 1
Output
3
row 1
row 2
row 3
Note
In the first test case, Karen has a grid with 3 rows and 5 columns. She can perform the following 4 moves to beat the level:
<image>
In the second test case, Karen has a grid with 3 rows and 3 columns. It is clear that it is impossible to beat the level; performing any move will create three 1s on the grid, but it is required to only have one 1 in the center.
In the third test case, Karen has a grid with 3 rows and 3 columns. She can perform the following 3 moves to beat the level:
<image>
Note that this is not the only solution; another solution, among others, is col 1, col 2, col 3. | ```python
n, m = [int(i) for i in input().split(' ')]
g = []
c, f = 0, 0
ans = ''
def row():
global n, m, g, c, ans
for i in range(n):
t = min(g[i])
c += t
ans += ('row %d\n' % (i+1))*t
for j in range(m):
g[i][j] -= t
def col():
global n, m, g, c, ans
for i in range(m):
r = [_[i] for _ in g]
t = min(r)
c += t
ans += ('col %d\n' % (i+1))*t
for j in range(n):
g[j][i] -= t
for i in range(n):
g.append([int(_) for _ in input().split(' ')])
if m >= n:
row()
col()
else:
col()
row()
for i in range(n):
for j in range(m):
if g[i][j] > 0:
f = 1
break
if f == 1:
print(-1)
else:
print(c)
print(ans, end='')
``` |
841_C. Leha and Function | Leha like all kinds of strange things. Recently he liked the function F(n, k). Consider all possible k-element subsets of the set [1, 2, ..., n]. For subset find minimal element in it. F(n, k) — mathematical expectation of the minimal element among all k-element subsets.
But only function does not interest him. He wants to do interesting things with it. Mom brought him two arrays A and B, each consists of m integers. For all i, j such that 1 ≤ i, j ≤ m the condition Ai ≥ Bj holds. Help Leha rearrange the numbers in the array A so that the sum <image> is maximally possible, where A' is already rearranged array.
Input
First line of input data contains single integer m (1 ≤ m ≤ 2·105) — length of arrays A and B.
Next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 109) — array A.
Next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109) — array B.
Output
Output m integers a'1, a'2, ..., a'm — array A' which is permutation of the array A.
Examples
Input
5
7 3 5 3 4
2 1 3 2 3
Output
4 7 3 5 3
Input
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Output
2 6 4 5 8 8 6 | ```python
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.sort()
a.reverse()
j=[]
for i in range(n):
j.append([b[i],i])
j.sort()
ans=[0]*n
for i in range(n):
ans[j[i][1]]=str(a[i])
print(' '.join(ans))
``` |
888_B. Buggy Robot | Ivan has a robot which is situated on an infinite grid. Initially the robot is standing in the starting cell (0, 0). The robot can process commands. There are four types of commands it can perform:
* U — move from the cell (x, y) to (x, y + 1);
* D — move from (x, y) to (x, y - 1);
* L — move from (x, y) to (x - 1, y);
* R — move from (x, y) to (x + 1, y).
Ivan entered a sequence of n commands, and the robot processed it. After this sequence the robot ended up in the starting cell (0, 0), but Ivan doubts that the sequence is such that after performing it correctly the robot ends up in the same cell. He thinks that some commands were ignored by robot. To acknowledge whether the robot is severely bugged, he needs to calculate the maximum possible number of commands that were performed correctly. Help Ivan to do the calculations!
Input
The first line contains one number n — the length of sequence of commands entered by Ivan (1 ≤ n ≤ 100).
The second line contains the sequence itself — a string consisting of n characters. Each character can be U, D, L or R.
Output
Print the maximum possible number of commands from the sequence the robot could perform to end up in the starting cell.
Examples
Input
4
LDUR
Output
4
Input
5
RRRUU
Output
0
Input
6
LLRRRR
Output
4 | ```python
n=input()
s=input()
print((min(s.count('L'),s.count('R'))+min(s.count('D'),s.count('U')))*2)
``` |
910_C. Minimum Sum | Petya has n positive integers a1, a2, ..., an.
His friend Vasya decided to joke and replaced all digits in Petya's numbers with a letters. He used the lowercase letters of the Latin alphabet from 'a' to 'j' and replaced all digits 0 with one letter, all digits 1 with another letter and so on. For any two different digits Vasya used distinct letters from 'a' to 'j'.
Your task is to restore Petya's numbers. The restored numbers should be positive integers without leading zeros. Since there can be multiple ways to do it, determine the minimum possible sum of all Petya's numbers after the restoration. It is guaranteed that before Vasya's joke all Petya's numbers did not have leading zeros.
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the number of Petya's numbers.
Each of the following lines contains non-empty string si consisting of lowercase Latin letters from 'a' to 'j' — the Petya's numbers after Vasya's joke. The length of each string does not exceed six characters.
Output
Determine the minimum sum of all Petya's numbers after the restoration. The restored numbers should be positive integers without leading zeros. It is guaranteed that the correct restore (without leading zeros) exists for all given tests.
Examples
Input
3
ab
de
aj
Output
47
Input
5
abcdef
ghij
bdef
accbd
g
Output
136542
Input
3
aa
jj
aa
Output
44
Note
In the first example, you need to replace the letter 'a' with the digit 1, the letter 'b' with the digit 0, the letter 'd' with the digit 2, the letter 'e' with the digit 3, and the letter 'j' with the digit 4. So after the restoration numbers will look like [10, 23, 14]. The sum of them is equal to 47, which is the minimum possible sum of the numbers after the correct restoration.
In the second example the numbers after the restoration can look like: [120468, 3579, 2468, 10024, 3].
In the second example the numbers after the restoration can look like: [11, 22, 11]. | ```python
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
import threading
from collections import defaultdict
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")
#-------------------game starts now-----------------------------------------------------
n = int(input())
d = [0] * (ord('j') + 1)
fr = [0] * (ord('j') + 1)
ans = 0
for i in range(n):
s = input()
fr[ord(s[0])] = 1
for j in range(len(s)):
d[ord(s[j])] += 10 ** (len(s) - j - 1)
a = [(d[i], i) for i in range(len(d))]
a.sort(reverse=True)
cr, f = 1, 1
for c, i in a:
if f and not fr[i]:
f = 0
else:
ans += cr * c
cr += 1
print(ans)
``` |
932_E. Team Work | You have a team of N people. For a particular task, you can pick any non-empty subset of people. The cost of having x people for the task is xk.
Output the sum of costs over all non-empty subsets of people.
Input
Only line of input contains two integers N (1 ≤ N ≤ 109) representing total number of people and k (1 ≤ k ≤ 5000).
Output
Output the sum of costs for all non empty subsets modulo 109 + 7.
Examples
Input
1 1
Output
1
Input
3 2
Output
24
Note
In the first example, there is only one non-empty subset {1} with cost 11 = 1.
In the second example, there are seven non-empty subsets.
- {1} with cost 12 = 1
- {2} with cost 12 = 1
- {1, 2} with cost 22 = 4
- {3} with cost 12 = 1
- {1, 3} with cost 22 = 4
- {2, 3} with cost 22 = 4
- {1, 2, 3} with cost 32 = 9
The total cost is 1 + 1 + 4 + 1 + 4 + 4 + 9 = 24. | ```python
# ############################## import
# def stirling2_list(n, mod=10 ** 9 + 7):
# if not n:
# return [0]
# res = [0, 1]
# for i in range(n - 1):
# res = [0, 1] + [(res[j - 1] + j * res[j]) % mod for j in range(2, 2 + i)] + [1]
# return res
# Explain:
# ans = \sum_{i=1}^{n} \binom{n}{i} i^k
# Notice that (1+x)^n = \sum_{i=0}^{n} \binom{n}{i} x^i
# differential and multiply by x on both side, we can get
# n(1+x)^{n-1}x=\sum_{i=0}^{n}\binom{n}{i}ix^i
# we can keep doing this process to get \sum_{i=0}^{n}\binom{n}{i}i^kx^i
# and the answer is the left side function, with x = 1
#
# Let f_0(x) = (1+x)^n
# and f_m(x) = f_{m-1}'(x)x
# so the answer is f_{k}(1)
# We calculate the first few of patterns
# We can observe that:
# f_1 = f_0'x
# f_2 = f_0'x + 1f_0''x^2
# f_3 = f_0'x + 3f_0''x^2 + f_0'''x^3
# f_4 = f_0'x + 7f_0''x^2 + 6f_0'''x^3 + f_0''''x^4
# The coefficients is Stirling numbers of the second kind
# And f_0 with differentiating k times is just
# n(n-1)(n-2)...(n-(k-1))(1+x)^{n-k}
# We can find them out in one iteration
# ############################## main
MOD = 10 ** 9 + 7
INV = 500000004
n, k = map(int, input().split())
# (1+x)^n, n(1+x)^{n-1}, n(n-1)(1+x)^{n-2}, ...
# 2^n, n*2^{n-1}, n(n-1)*2^{n-2}, ...
# f_4 = f_0' + 7f_0'' + 6f_0''' + f_0''''
d = 1
p = pow(2, n, MOD)
ans = 0
stirling2_list = [0, 1]
for i in range(k - 1):
stirling2_list = [0, 1] + [(stirling2_list[j - 1] + j * stirling2_list[j]) % MOD for j in range(2, 2 + i)] + [1]
for stirling in stirling2_list:
ans = (ans + stirling * d * p) % MOD
d = d * n % MOD
n -= 1
p = p * INV % MOD
print(ans)
``` |
p02584 AtCoder Beginner Contest 175 - Walking Takahashi | Takahashi, who lives on the number line, is now at coordinate X. He will make exactly K moves of distance D in the positive or negative direction.
More specifically, in one move, he can go from coordinate x to x + D or x - D.
He wants to make K moves so that the absolute value of the coordinate of the destination will be the smallest possible.
Find the minimum possible absolute value of the coordinate of the destination.
Constraints
* -10^{15} \leq X \leq 10^{15}
* 1 \leq K \leq 10^{15}
* 1 \leq D \leq 10^{15}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
X K D
Output
Print the minimum possible absolute value of the coordinate of the destination.
Examples
Input
6 2 4
Output
2
Input
7 4 3
Output
1
Input
10 1 2
Output
8
Input
1000000000000000 1000000000000000 1000000000000000
Output
1000000000000000 | ```python
x,k,d=map(int,input().split())
x=abs(x)
m=min(k,x//d)
x-=d*m
k-=m
k%=2
x-=d*k
print(abs(x))
``` |
p02715 AtCoder Beginner Contest 162 - Sum of gcd of Tuples (Hard) | Consider sequences \\{A_1,...,A_N\\} of length N consisting of integers between 1 and K (inclusive).
There are K^N such sequences. Find the sum of \gcd(A_1, ..., A_N) over all of them.
Since this sum can be enormous, print the value modulo (10^9+7).
Here \gcd(A_1, ..., A_N) denotes the greatest common divisor of A_1, ..., A_N.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq K \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
Output
Print the sum of \gcd(A_1, ..., A_N) over all K^N sequences, modulo (10^9+7).
Examples
Input
3 2
Output
9
Input
3 200
Output
10813692
Input
100000 100000
Output
742202979 | ```python
mod = 10 ** 9 + 7
N, K = map(int, input().split())
A = [0] + [pow(K // x, N, mod) for x in range(1, K + 1)]
for x in reversed(range(1, K + 1)):
for i in range(2, K // x + 1):
A[x] -= A[i * x]
print(sum(i * a for i, a in enumerate(A)) % mod)
``` |
p02844 Sumitomo Mitsui Trust Bank Programming Contest 2019 - Lucky PIN | AtCoder Inc. has decided to lock the door of its office with a 3-digit PIN code.
The company has an N-digit lucky number, S. Takahashi, the president, will erase N-3 digits from S and concatenate the remaining 3 digits without changing the order to set the PIN code.
How many different PIN codes can he set this way?
Both the lucky number and the PIN code may begin with a 0.
Constraints
* 4 \leq N \leq 30000
* S is a string of length N consisting of digits.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of different PIN codes Takahashi can set.
Examples
Input
4
0224
Output
3
Input
6
123123
Output
17
Input
19
3141592653589793238
Output
329 | ```python
N = int(input())
S = input()
ans = 0
for i in range(1000):
cnt = 0
n = str(i).zfill(3)
for c in S:
if c == n[cnt]:
cnt += 1
if cnt == 3:
ans += 1
break
print(ans)
``` |
p02981 AtCoder Beginner Contest 133 - T or T | N of us are going on a trip, by train or taxi.
The train will cost each of us A yen (the currency of Japan).
The taxi will cost us a total of B yen.
How much is our minimum total travel expense?
Constraints
* All values in input are integers.
* 1 \leq N \leq 20
* 1 \leq A \leq 50
* 1 \leq B \leq 50
Input
Input is given from Standard Input in the following format:
N A B
Output
Print an integer representing the minimum total travel expense.
Examples
Input
4 2 9
Output
8
Input
4 2 7
Output
7
Input
4 2 8
Output
8 | ```python
n,a,b = map(int,input().split())
print(min(b,a*n))
``` |
p03264 AtCoder Beginner Contest 108 - Pair | Find the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive). The order does not matter.
Constraints
* 2\leq K\leq 100
* K is an integer.
Input
Input is given from Standard Input in the following format:
K
Output
Print the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive).
Examples
Input
3
Output
2
Input
6
Output
9
Input
11
Output
30
Input
50
Output
625 | ```python
K = int(input())
print((K//2)*(-(-K//2)))
``` |
p03422 AtCoder Regular Contest 091 - Strange Nim | Takahashi and Aoki are playing a stone-taking game. Initially, there are N piles of stones, and the i-th pile contains A_i stones and has an associated integer K_i.
Starting from Takahashi, Takahashi and Aoki take alternate turns to perform the following operation:
* Choose a pile. If the i-th pile is selected and there are X stones left in the pile, remove some number of stones between 1 and floor(X/K_i) (inclusive) from the pile.
The player who first becomes unable to perform the operation loses the game. Assuming that both players play optimally, determine the winner of the game. Here, floor(x) represents the largest integer not greater than x.
Constraints
* 1 \leq N \leq 200
* 1 \leq A_i,K_i \leq 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1 K_1
:
A_N K_N
Output
If Takahashi will win, print `Takahashi`; if Aoki will win, print `Aoki`.
Examples
Input
2
5 2
3 3
Output
Aoki
Input
3
3 2
4 3
5 1
Output
Takahashi
Input
3
28 3
16 4
19 2
Output
Aoki
Input
4
3141 59
26535 897
93 23
8462 64
Output
Takahashi | ```python
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def grundy(a,k):
while 1:
if a<k:return 0
if a%k==0:return a//k
once=a//k+1
seg=a%k
cnt=(seg+once-1)//once
a-=cnt*once
win=0
for _ in range(II()):
a,k=MI()
win^=grundy(a,k)
if win:print("Takahashi")
else:print("Aoki")
``` |
p03580 CODE FESTIVAL 2017 qual B - 101 to 010 | N cells are arranged in a row. Some of them may contain tokens. You are given a string s that consists of `0`s and `1`s. If the i-th character of s is `1`, the i-th cell (from left) contains a token. Otherwise, it doesn't contain a token.
Snuke wants to perform the following operation as many times as possible. In each operation, he chooses three consecutive cells. Let's call the cells X, Y, Z from left to right. In order for the operation to be valid, both X and Z must contain tokens and Y must not contain a token. Then, he removes these two tokens and puts a new token on Y.
How many operations can he perform if he performs operations in the optimal way?
Constraints
* 1 \leq N \leq 500,000
* |s| = N
* Each character in s is either `0` or `1`.
Input
Input is given from Standard Input in the following format:
N
s
Output
Print the answer.
Examples
Input
7
1010101
Output
2
Input
50
10101000010011011110001001111110000101010111100110
Output
10 | ```python
import sys
readline = sys.stdin.readline
INF = 10**9+7
class Segtree:
def __init__(self, A, intv, initialize = True, segf = max):
self.N = len(A)
self.N0 = 2**(self.N-1).bit_length()
self.intv = intv
self.segf = segf
if initialize:
self.data = [intv]*self.N0 + A + [intv]*(self.N0 - self.N)
for i in range(self.N0-1, 0, -1):
self.data[i] = self.segf(self.data[2*i], self.data[2*i+1])
else:
self.data = [intv]*(2*self.N0)
def update(self, k, x):
k += self.N0
self.data[k] = x
while k > 0 :
k = k >> 1
self.data[k] = self.segf(self.data[2*k], self.data[2*k+1])
def query(self, l, r):
L, R = l+self.N0, r+self.N0
s = self.intv
while L < R:
if R & 1:
R -= 1
s = self.segf(s, self.data[R])
if L & 1:
s = self.segf(s, self.data[L])
L += 1
L >>= 1
R >>= 1
return s
def binsearch(self, l, r, check, reverse = False):
L, R = l+self.N0, r+self.N0
SL, SR = [], []
while L < R:
if R & 1:
R -= 1
SR.append(R)
if L & 1:
SL.append(L)
L += 1
L >>= 1
R >>= 1
if reverse:
for idx in (SR + SL[::-1]):
if check(self.data[idx]):
break
else:
return -1
while idx < self.N0:
if check(self.data[2*idx+1]):
idx = 2*idx + 1
else:
idx = 2*idx
return idx - self.N0
else:
pre = self.data[l+self.N0]
for idx in (SL + SR[::-1]):
if not check(self.segf(pre, self.data[idx])):
pre = self.segf(pre, self.data[idx])
else:
break
else:
return -1
while idx < self.N0:
if check(self.segf(pre, self.data[2*idx])):
idx = 2*idx
else:
pre = self.segf(pre, self.data[2*idx])
idx = 2*idx + 1
return idx - self.N0
N = int(readline())
S = [0]+list(map(int, readline().strip()))
leftone = [None]*(N+1)
left = None
for i in range(N+1):
if S[i] == 1:
if left is None:
left = i
leftone[i] = left
else:
left = None
T = Segtree([None]*(N+1), -INF, initialize = False)
dp = [0]*(N+1)
T.update(0, 0)
T.update(1, -1)
T.update(2, -2)
for i in range(3, N+1):
res = dp[i-1]
if S[i] == 1:
if S[i-1] == 0 and S[i-2] == 1:
left = leftone[i-2]
res = max(res, T.query(left-1, i-2)+i-2)
if leftone[i] > 2 and S[leftone[i]-1] == 0 and S[leftone[i]-2] == 1:
res = max(res, dp[leftone[i]-3] + i-leftone[i]+2-1)
dp[i] = res
T.update(i, dp[i]-i)
print(dp[-1])
``` |
p03737 AtCoder Beginner Contest 059 - Three-letter acronym | You are given three words s_1, s_2 and s_3, each composed of lowercase English letters, with spaces in between. Print the acronym formed from the uppercased initial letters of the words.
Constraints
* s_1, s_2 and s_3 are composed of lowercase English letters.
* 1 ≤ |s_i| ≤ 10 (1≤i≤3)
Input
Input is given from Standard Input in the following format:
s_1 s_2 s_3
Output
Print the answer.
Examples
Input
atcoder beginner contest
Output
ABC
Input
resident register number
Output
RRN
Input
k nearest neighbor
Output
KNN
Input
async layered coding
Output
ALC | ```python
l=input().split()
r=''
for i in l:
r+=i[0].upper()
print(r)
``` |
p03899 CODE FESTIVAL 2016 Tournament Round 3 (Parallel) - Struck Out | There are N panels arranged in a row in Takahashi's house, numbered 1 through N. The i-th panel has a number A_i written on it. Takahashi is playing by throwing balls at these panels.
Takahashi threw a ball K times. Let the panel hit by a boll in the i-th throw be panel p_i. He set the score for the i-th throw as i \times A_{p_i}.
He was about to calculate the total score for his throws, when he realized that he forgot the panels hit by balls, p_1,p_2,...,p_K. The only fact he remembers is that for every i (1 ≦ i ≦ K-1), 1 ≦ p_{i+1}-p_i ≦ M holds. Based on this fact, find the maximum possible total score for his throws.
Constraints
* 1 ≦ M ≦ N ≦ 100,000
* 1 ≦ K ≦ min(300,N)
* 1 ≦ A_i ≦ 10^{9}
Input
The input is given from Standard Input in the following format:
N M K
A_1 A_2 … A_N
Output
Print the maximum possible total score for Takahashi's throws.
Examples
Input
5 2 3
10 2 8 10 2
Output
56
Input
5 5 2
5 2 10 5 9
Output
28
Input
10 3 5
3 7 2 6 9 4 8 5 1 1000000000
Output
5000000078 | ```python
from collections import deque
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
#dp[i][j]: i番目の的をj回目にあてた時のpointの最大値
dp = [0] * (N + 1)
for j in range(K):
newDP = [0] * (N + 1)
que = deque() # val, index
for i in range(j, N - K + j + 1):
while que and que[-1][0] < dp[i]:
que.pop()
que.append((dp[i], i))
while que and que[0][1] <= i - M:
que.popleft()
newDP[i+1] = que[0][0] + (j+1)*A[i]
dp = newDP
print(max(dp))
``` |
p00005 GCD and LCM | Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given a and b.
Constraints
* 0 < a, b ≤ 2,000,000,000
* LCM(a, b) ≤ 2,000,000,000
* The number of data sets ≤ 50
Input
Input consists of several data sets. Each data set contains a and b separated by a single space in a line. The input terminates with EOF.
Output
For each data set, print GCD and LCM separated by a single space in a line.
Example
Input
8 6
50000000 30000000
Output
2 24
10000000 150000000 | ```python
def gcd(a,b):
a,b=max(a,b),min(a,b)
while b!=0:
a,b=b,a%b
return a
def lcm(a,b):
return a*b//gcd(a,b)
while True:
try:
x,y=map(int,input().split())
print(gcd(x,y),lcm(x,y))
except EOFError:
break
``` |
p00137 Middle-Square Method | Create a program of the square picking method, which is one of the classical random number generation methods. The square harvesting method was proposed by von Neumann in the mid-1940s.
In the square picking method, when the number of digits of the generated random number is n, the square of the initial value s is calculated, and the value is regarded as a 2n digit number (the number of squared digits as shown in the example below). If is not enough, make up for 0.) Let the n numbers in the center be the first random number. Then square this random number and take the n numbers in the center in the same way to get the next random number. For example, if 123 is the initial value
1232 = 00015129 → 0151
1512 = 00022801 → 0228
2282 = 00051984 → 0519
5192 = 00269361 → 2693
26932 = 07252249 → 2522
It will be like. Use this method to create a program that takes the initial value s (a positive integer less than 10000) as an input and generates and outputs 10 random numbers when n = 4.
Input
Given multiple datasets. The first line gives the number of datasets d (d ≤ 10). For each dataset, one row is given the initial value s (integer, 1 ≤ s <10000).
Output
For each dataset
Case x: (x is a dataset number starting with 1)
The first generated random number (integer)
The second generated random number (integer)
:
:
10th generated random number (integer)
Please output.
Example
Input
2
123
567
Output
Case 1:
151
228
519
2693
2522
3604
9888
7725
6756
6435
Case 2:
3214
3297
8702
7248
5335
4622
3628
1623
6341
2082 | ```python
def method(s):
count=0
ans=[]
while count!=10:
s=str(s**2).zfill(8)
s=int(s[2]+s[3]+s[4]+s[5])
ans.append(s)
count +=1
return ans
N=int(input())
for i in range(N):
s=int(input())
print("Case %d:"%(i+1))
for j in range(10):
print(method(s)[j])
``` |
p00270 Railroad | We have decided to introduce an automatic ticket gate to the railway network of a certain country. One of the difficult issues to implement is determining whether a given ticket can move between designated stations. Each ticket has a boarding station and a getting-off station. With this ticket, you can not only "get on at the boarding station and get off at the getting off station", but you are also allowed to get on and off the train.
There are S stations on this rail network, of which Group R stations are adjacent and can be traversed in both directions without going through other stations. There is only one railroad track connecting adjacent stations. The distance between adjacent stations is the distance measured along this railroad track. There are multiple possible routes from one station to another, depending on the shape of the railway network, but the route with the shortest distance is called the shortest route. If there are multiple such routes, both are accepted as the shortest route.
You can move from station c to station d with a ticket for boarding station a and getting off station b if there is a route p that meets all of the following conditions.
* Route p is the shortest route from station a to station b.
* Route p is a route that starts from station a, goes through station c, then station d, and ends at station b. The section from station c to station d is the shortest route between these two stations.
You will be given route map and ticket information. Next, you will be given several pairs of start and end points, so write a program that determines whether you can move from the start point to the end point with that ticket.
input
The input consists of one dataset. Input data is given in the following format.
S R
u1 v1 w1
u2 v2 w2
::
uR vR wR
a b Q
c1 d1
::
cQ dQ
The numbers given on each line are separated by a single space.
The first line consists of two integers. S (2 ≤ S ≤ 100000) is the number of stations that appear on the railroad map, and R (1 ≤ R ≤ 200000) is the number of pairs of adjacent stations. The following R line is given information on the railroad tracks that directly connect adjacent stations. ui and vi (1 ≤ ui, vi ≤ S) indicate the station numbers at both ends of the i-th line. wi (1 ≤ wi ≤ 1000) is an integer representing the distance between these stations. However, numbers from 1 to S are assigned to each station without duplication, and ui ≠ vi.
The next line consists of three integers. The first two integers represent the ticket sections, where a is the boarding station and b is the getting-off station (1 ≤ a, b ≤ S). The third integer Q (1 ≤ Q ≤ 40000) indicates the number of questions. The question is given on the following Q line. ci and di (1 ≤ ci, di ≤ S) indicate the boarding and alighting stations of the i-th question. However, a ≠ b and ci ≠ di.
output
For each question, print Yes if you can move with the given ticket, or No if you can't.
Example
Input
6 7
1 2 3
1 4 1
2 3 5
4 3 1
3 6 2
4 5 2
5 6 1
1 6 6
1 6
4 3
4 6
5 6
2 6
2 5
Output
Yes
Yes
Yes
Yes
No
No | ```python
from heapq import heappush, heappop
s, r = map(int, input().split())
edges = [[] for _ in range(s)]
for _ in range(r):
u, v, w = map(int, input().split())
u -= 1
v -= 1
edges[u].append((v, w))
edges[v].append((u, w))
a, b, q = map(int, input().split())
a -= 1
b -= 1
def dijkstra(start):
INF = 10 ** 20
dist = [INF] * s
dist[start] = 0
parents = [[] for _ in range(s)]
que = []
heappush(que, (0, start))
while que:
score, node = heappop(que)
for to, w in edges[node]:
if dist[to] > score + w:
dist[to] = score + w
parents[to] = {node}
heappush(que, (score + w, to))
elif dist[to] == score + w:
parents[to].add(node)
return dist, parents
def on_shortest_path(c, d, mem):
if c == d:return True
if d in mem:return False
mem.add(d)
if dist_from_a[c] >= dist_from_a[d]:return False
for parent in parents[d]:
if on_shortest_path(c, parent, mem):return True
return False
dist_from_a, parents = dijkstra(a)
dist_from_b, _ = dijkstra(b)
shortest = dist_from_a[b]
for _ in range(q):
c, d = map(int, input().split())
c -= 1
d -= 1
if dist_from_a[c] + dist_from_b[c] == shortest and \
dist_from_a[d] + dist_from_b[d] == shortest and \
on_shortest_path(c, d, set()):
print("Yes")
else:
print("No")
``` |
p00458 Crossing Black Ice | problem
One day in the cold winter, JOI Taro decided to break the thin ice in the plaza and play. The square is rectangular and is divided into m sections in the east-west direction and n sections in the north-south direction, that is, m × n. In addition, there are sections with and without thin ice. JOI Taro decided to move the plot while breaking the thin ice according to the following rules.
* You can start breaking thin ice from any compartment with thin ice.
* Adjacent to either north, south, east, or west, you can move to a section with thin ice that has not yet been broken.
* Be sure to break the thin ice in the area you moved to.
Create a program to find the maximum number of sections that JOI Taro can move while breaking thin ice. However, 1 ≤ m ≤ 90 and 1 ≤ n ≤ 90. With the input data given, there are no more than 200,000 ways to move.
input
The input consists of multiple datasets. Each dataset is given in the following format.
The input is n + 2 lines. The integer m is written on the first line. The integer n is written on the second line. In each line from the 3rd line to the n + 2nd line, m 0s or 1s are written, separated by blanks, and indicates whether or not there is thin ice in each section. If we write the i-th section from the north and the j-th section from the west as (i, j) (1 ≤ i ≤ n, 1 ≤ j ≤ m), the j-th value on the second line of i + 2 is It is 1 if there is thin ice in compartment (i, j) and 0 if there is no thin ice in compartment (i, j).
When both m and n are 0, it indicates the end of input. The number of data sets does not exceed 5.
output
Output the maximum number of sections that can be moved for each data set on one line.
Examples
Input
3
3
1 1 0
1 0 1
1 1 0
5
3
1 1 1 0 1
1 1 0 0 0
1 0 0 0 1
0
0
Output
5
5
Input
None
Output
None | ```python
def solve():
while True:
m, n = int(input()), int(input())
if not m:
break
ices = [[0] + list(map(int,input().split())) + [0] for _ in range(n)]
ices.insert(0, [0] * (m + 2),)
ices.append([0] * (m + 2))
score = [[0] * (m + 2) for _ in range(n + 2)]
for x in range(1, n + 1):
for y in range(1, m + 1):
score[x][y] = ices[x - 1][y] + ices[x + 1][y] + ices[x][y - 1] + ices[x][y + 1]
def search(x, y, imap, acc):
imap[x][y] = 0
acc += 1
ret = acc
a = b = c = d = 0
if imap[x - 1][y]:
a = search(x - 1, y, imap, acc)
if ret < a:
ret = a
if imap[x + 1][y]:
b = search(x + 1, y, imap, acc)
if ret < b:
ret = b
if imap[x][y - 1]:
c = search(x, y - 1, imap, acc)
if ret < c:
ret = c
if imap[x][y + 1]:
d = search(x, y + 1, imap, acc)
if ret < d:
ret = d
imap[x][y] = 1
return ret
ans = 0
for x in range(1, n + 1):
for y in range(1, m + 1):
if score[x][y] in [1, 2] and ices[x][y]:
a = search(x, y, ices, 0)
if ans < a:
ans = a
print(ans)
solve()
``` |
p00648 Watchin' TVA | Animation is one of methods for making movies and in Japan, it is popular to broadcast as a television program or perform as a movie. Many people, especially the young, love one. And here is an anime lover called Jack. We say he is an mysterious guy with uncertain age. He likes anime which are broadcasted in midnight and early morning especially.
In his room, there is a huge piece of paper on the wall. He writes a timetable of TV anime on it. In his house, he can watch all Japanese TV anime programs that are broadcasted in Japan using a secret and countrywide live system. However he can not watch all anime and must give up to watch some programs because they are "broadcasted at the same time" in a season. Here, programs are "broadcasted at the same time" means that two or more programs have one or more common minutes in broadcasting time. Increasing the number of anime programs in recent makes him nervous. Actually, some people buy DVDs after the program series ends or visit a web site called vhefoo. Anyway, he loves to watch programs on his live system. Of course, he is not able to watch two or more programs at the same time. However, as described above, he must give up some programs broadcasted at the same time. Therefore, he has a set of programs F and he watches programs in a set F absolutely.
Your task is to write a program that reads a timetable and outputs the maximum number of watchable programs, keeping that Jack watches all programs in the set F. Of course, there are multiple choices of programs, so we want the number of programs he can watch. If two or more programs in a set F are broadcasted at the same time, you must give Jack an unfortunate announcement. In this case, your program outputs -1. In addition, each anime program is a program of 30 minutes.
Hint
Second dataset: He can watch program E after watching B. Then he can choose a program either I or J after watching H. Therefore he can watch maximum 4 programs.
Constraints
The number of datasets is less than or equal to 400.
1≤N≤500
Input
Input consists of multiple datasets.
A dataset is given in a following format.
N
PROGRAM1
PROGRAM2
...
PROGRAMN
P
FAV1
FAV2
...
FAVP
N is the number of programs in a season.
PROGRAMi(1≤i≤N)is a string which has the following format.
name weekday start
* name is a program name. This is a a string having between 1 and 32 characters and these names do not overlap each other program. A name consists of alphanumeric characters and '_'(underscore).
* weekday is a broadcasting weekday about the corresponding program. This is an integer. 0 means Sunday and 1 is Monday and so on (2:Tuesday, 3:Wednesday, 4:Thursday, 5:Friday, 6:Saturday).
* start is a starting time of the program broadcasting. This is an integer between 600 and 2929. First one or two digits represent hour and the last two digits represent minute. If the hour has one digit it will be a representation "900" for example. Note: a program may have an integer more than or equal to 2400 as start, if the program begins the next day. For example, a program begins from 2500 on Monday should be interpreted as a program begins from 0100 on Tuesday. There are no input the minute of start exceeds 59. And when the hour of start is equal to 29, there are no input the minute of start exceeds 29.
P is an integer and represents the number of elements in the set F. And FAVi(1≤i≤P≤N) is a string for a program name which Jack watches absolutely. You can assume names which are not given in program descriptions will not appear in the set F.
The last line contains a single 0 which represents the end of input.
Output
For each dataset, output an integer S that represents maximum number of programs Jack can watch in the following format.
S
Example
Input
1
galaxy_angel 0 600
1
galaxy_angel
11
A 0 600
B 0 610
C 0 610
D 0 610
E 0 640
EE 0 700
F 0 710
G 0 710
H 0 710
I 0 740
J 0 750
2
B
H
42
nchj 6 2620
anhnnnmewbktthsrn 4 2515
gntmdsh 1 1800
achnnl 4 2540
hnskirh 0 2200
aonexrcst 0 1700
dgdys 6 2330
hdnnara 4 2525
dnpaonntssotk 4 2555
ddmnwndrlnd 6 2500
C 4 2445
astrttnomch 0 2330
seknnqasr 1 2630
sftnt 4 2630
stnsgt 2 2605
drrnenmknmrmr 4 2610
hnzm 6 2713
yndmsoazzlsn 6 2658
mrahlcalv 4 2615
hshzrhkkrhs 1 900
ortchntsbshni 0 2430
kmnmzshrski 1 2530
sktdnc 4 1800
gykkybrkjhkirkhn 2 2459
trk 0 900
30zzsinhkntiik 3 2700
sngkotmmmirprdx 1 2600
yran 2 2529
tntissygntinybu 1 2614
skiichhtki 5 2505
tgrbnny 6 2558
dnbrsnki 3 1927
yugozxl 1 1930
frbllchrmn 1 1928
fjrg 1 1955
shwmngtr 0 2200
xmn 5 2200
rngnkkrskitikihn 0 2100
szysz 0 1254
prttyrythmaulrdrm 6 1000
sckiesfrntrqst 5 1820
mshdr 1 2255
1
mrahlcalv
0
Output
1
4
31 | ```python
# AOJ 1063: Watchin' TVA
# Python3 2018.7.8 bal4u
while True:
n = int(input())
if n == 0: break
dic, tbl = {}, []
for i in range(n):
nm, w, s = input().split()
w, s = int(w), int(s)
h, m = s//100, s%100
s = (1440*w + h*60 + m) % 10080
e = s + 30;
tbl.append([s, e, 0, nm])
dic[nm] = i
for i in range(int(input())): tbl[dic[input()]][2] = 1
if n == 1:
print(1)
continue
tbl.sort(key=lambda x:(x[0],x[2]))
for i in range(len(tbl)):
if tbl[i][2]:
k = i
break
ans, i, j = 1, k, k
while True:
j += 1
if i >= n: i = 0
if j >= n: j = 0
if j == k: break
e = tbl[i][1] - 10080 if tbl[i][1] >= 10080 else 0
if (tbl[i][0] <= tbl[j][0] and tbl[j][0] < tbl[i][1]) \
or tbl[j][0] < e:
if tbl[j][2] and tbl[i][2]:
ans = -1
break
elif tbl[j][2]: i = j
elif tbl[j][0] <= tbl[k][0] and tbl[k][0] < tbl[j][1]: pass
else:
ans += 1
i = j
print(ans)
``` |
p00924 Bit String Reordering | Example
Input
6 3
1 0 0 1 0 1
1 3 2
Output
1 | ```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:
n,m = LI()
b = LI()
p = LI()
r = inf
t = []
for i in range(m):
t += [i % 2] * p[i]
if sorted(collections.Counter(t).items()) == sorted(collections.Counter(b).items()):
tr = 0
pi = 0
for i in range(n):
if t[i] != 1:
continue
while b[pi] != 1:
pi += 1
tr += abs(i-pi)
pi += 1
r = tr
t = []
for i in range(m):
t += [(i+1) % 2] * p[i]
if sorted(collections.Counter(t).items()) == sorted(collections.Counter(b).items()):
tr = 0
pi = 0
for i in range(n):
if t[i] != 1:
continue
while b[pi] != 1:
pi += 1
tr += abs(i-pi)
pi += 1
if r > tr:
r = tr
rr.append(r)
break
return '\n'.join(map(str, rr))
print(main())
``` |
p01942 Taiyaki-Master and Eater | E: Taiyaki-Master and Eater
story
Tsuta is very good at making Taiyaki. Ebi-chan loves Taiyaki made by Tsuta-san. The two are happy to make and eat Taiyaki every week, but Tsuta-san's recent worries are that Ebi-chan, who is in the middle of eating, eats the food while making Taiyaki.
Mr. Tsuta, who decided to make Taiyaki at the school festival, is worried about sales if he is eaten by Ebi-chan as usual, so it would be nice if he could know the state of Taiyaki in the range he is paying attention to. thought. Let's help Tsuta-san so that the school festival will be successful.
problem
There is a rectangular taiyaki plate with vertical H and horizontal W, and it takes T minutes from setting the taiyaki to baking. This plate can bake up to HW Taiyaki at a time, at the i (1 \ leq i \ leq H) th place from the top and the j (1 \ leq j \ leq W) th place from the left. Taiyaki is represented by (i, j).
The following three types of events occur a total of Q times. In the initial state, Taiyaki is not set in any place.
* At time t, Tsuta-san sets one Taiyaki at (h, w). The taiyaki is baked in T minutes and can be eaten at time t + T. However, the Taiyaki is not set in the place where the Taiyaki is already set.
* At time t, Ebi-chan tries to pick up and eat the Taiyaki at (h, w). However, you can only eat taiyaki that has already been baked. After eating the pinch, the taiyaki disappears from that place (that is, the taiyaki is not set). Note that a pinch-eating event may occur where the taiyaki is not baked or is not.
* For Taiyaki in a rectangular area (including (h_1, w_1) and (h_2, w_2)) where the upper left is (h_1, w_1) and the lower right is (h_2, w_2), the following number is the time t At that point, Mr. Tsuta counts how many each is.
* Number of Taiyaki already baked
* Number of Taiyaki that have not been baked yet
Input format
H W T Q
t_1 c_1 h_ {11} w_ {11} (h_ {12} w_ {12})
t_2 c_2 h_ {21} w_ {21} (h_ {22} w_ {22})
...
t_Q c_Q h_ {Q1} w_ {Q1} (h_ {Q2} w_ {Q2})
All inputs are given as integers.
The first line gives the vertical H, horizontal W of the taiyaki plate, the time T from setting the taiyaki to baking, and the number of events Q.
The 1 + i (1 \ leq i \ leq Q) line gives the content of the event that occurred at time t_i.
* c_i represents the type of event. If this value is 0, it means an event that sets Taiyaki, if it is 1, it means an event that eats a pinch, and if it is 2, it means an event that counts Taiyaki.
* h_ {i1} (1 \ leq h_ {i1} \ leq H) and w_ {i1} (1 \ leq w_ {i1} \ leq W) have the following meanings at c_i = 0, 1.
* When c_i = 0, set one Taiyaki in the place of (h_ {i1}, w_ {i1}).
* When c_i = 1, if there is a baked Taiyaki in the place of (h_ {i1}, w_ {i1}), it will be eaten, otherwise it will do nothing.
* h_ {i2} and w_ {i2} are given only when c_i = 2.
* When c_i = 2, count the taiyaki in the rectangular area where the upper left is (h_ {i1}, w_ {i1}) and the lower right is (h_ {i2}, w_ {i2}).
Be careful if you are using slow functions for I / O, as you can expect a lot of I / O.
Constraint
* 1 \ leq H \ leq 2 \ times 10 ^ 3
* 1 \ leq W \ leq 2 \ times 10 ^ 3
* 1 \ leq T \ leq 10 ^ 9
* 1 \ leq Q \ leq 10 ^ 5
* 1 \ leq t_i \ leq 10 ^ 9
* If i \ lt j, then t_i \ lt t_j
* 0 \ leq c_i \ leq 2
* 1 \ leq h_ {i1} \ leq h_ {i2} \ leq H
* 1 \ leq w_ {i1} \ leq w_ {i2} \ leq W
Output format
Let n be (the number of c_i = 2 (1 \ leq i \ leq Q)). Output the result of Taiyaki count to n lines in order of event occurrence time according to the following writing method.
a_1 b_1
a_2 b_2
...
a_n b_n
* a_i is the "number of baked taiyaki" in the area.
* b_i is the "number of unbaked taiyaki" in the area.
* Don't forget the newline at the end.
Input example 1
3 3 3 6
1 0 1 1
2 2 1 1 2 2
3 1 1 1
4 0 2 1
5 2 1 1 2 2
6 2 2 1 3 3
Output example 1
0 1
1 1
0 1
In this input / output example, the following events have occurred.
<image>
* Set Taiyaki at (1, 1) at time 1 minute. This Taiyaki is baked in 4 minutes.
* At time 2 minutes, count the taiyaki in the upper left (1, 1) and lower right (2, 2) rectangular areas. Since the Taiyaki set in (1, 1) has not been baked yet, `0 1` is output.
* At time 3 minutes, I try to pick up the Taiyaki at (1, 1), but I don't do anything because it hasn't been baked yet.
<image>
* At time 4 minutes, set Taiyaki at (2, 1). This Taiyaki is baked at 7 minutes.
<image>
* At time 5 minutes, count the taiyaki in the upper left (1, 1) and lower right (2, 2) rectangular areas. Since the Taiyaki of (1, 1) has been baked and the Taiyaki of (2, 1) has not been baked yet, `1 1` is output.
<image>
* At time 6 minutes, count the taiyaki in the rectangular area on the upper left (2, 1) and lower right (3, 3). Since the Taiyaki of (2, 1) has not been baked yet, `0 1` is output.
Example
Input
3 3 3 6
1 0 1 1
2 2 1 1 2 2
3 1 1 1
4 0 2 1
5 2 1 1 2 2
6 2 2 1 3 3
Output
0 1
1 1
0 1 | ```python
from heapq import heappush, heappop
H, W, T, Q = map(int, input().split())
que = []
state = [[0]*(W+1) for i in range(H+1)]
data1 = [[0]*(W+1) for i in range(H+1)]
data2 = [[0]*(W+1) for i in range(H+1)]
def get(data, h, w):
s = 0
while h:
w0 = w
el = data[h]
while w0:
s += el[w0]
w0 -= w0 & -w0
h -= h & -h
return s
def add(data, h, w, x):
while h <= H:
w0 = w
el = data[h]
while w0 <= W:
el[w0] += x
w0 += w0 & -w0
h += h & -h
for q in range(Q):
t, c, *ps = map(int, input().split())
while que and que[0][0] <= t:
_, h0, w0 = heappop(que)
add(data1, h0, w0, -1)
add(data2, h0, w0, 1)
state[h0][w0] = 2
if c == 0:
h0, w0 = ps
state[h0][w0] = 1
add(data1, h0, w0, 1)
heappush(que, (t + T, h0, w0))
elif c == 1:
h0, w0 = ps
if state[h0][w0] == 2:
add(data2, h0, w0, -1)
state[h0][w0] = 0
else:
h0, w0, h1, w1 = ps
result1 = get(data1, h1, w1) - get(data1, h1, w0-1) - get(data1, h0-1, w1) + get(data1, h0-1, w0-1)
result2 = get(data2, h1, w1) - get(data2, h1, w0-1) - get(data2, h0-1, w1) + get(data2, h0-1, w0-1)
print(result2, result1)
``` |
p02223 String Set | Problem statement
Of the string set $ S $ that meets the following conditions, configure $ 1 $ with the largest number of elements.
* The length of the string contained in $ S $ is $ 1 $ or more and $ N $ or less.
* The lengths of the strings contained in $ S $ are different.
* The string contained in $ S $ consists only of the characters `0` and` 1`.
* For any $ 2 $ string contained in $ S $, one is not a substring of the other.
However, the substring of the string $ x $ is the string obtained by removing more than $ 0 $ characters from the beginning and end of $ x $.
Constraint
* $ 1 \ leq N \ leq 300 $
* $ N $ is an integer
* * *
input
Input is given from standard input in the following format.
$ N $
output
Output $ 1 $ of the string set $ S $ that satisfies the condition with the maximum number of elements. There may be multiple such $ S $, but any output will be correct.
Specifically, output in the following format.
Output $ K $, the number of elements of $ S $, on the $ 1 $ line.
Output all $ S $ elements from the $ 2 $ line to the $ K + 1 $ line. Print $ 1 $ of $ S $ elements on each line.
$ K $
$ S_1 $
$ S_2 $
$ \ vdots $
$ S_K $
* * *
Input example 1
2
Output example 1
2
0
11
The string set $ \\ {0, 11 \\} $ is the set with the largest number of elements that meets the conditions.
* * *
Input example 2
1
Output example 2
1
0
Example
Input
2
Output
2
0
11 | ```python
N = int(input())
if N==1:
print(1)
print(0)
elif N==2:
print(2)
print(0)
print(11)
else:
print(N-1)
for i in range(N-1):
print('0' + '1'*i + '0')
``` |
p02375 Range Query on a Tree II | Write a program which manipulates a weighted rooted tree $T$ with the following operations:
* $add(v,w)$: add $w$ to all edges from the root to node $u$
* $getSum(u)$: report the sum of weights of all edges from the root to node $u$
The given tree $T$ consists of $n$ nodes and every node has a unique ID from $0$ to $n-1$ respectively where ID of the root is $0$. Note that all weights are initialized to zero.
Constraints
* All the inputs are given in integers
* $ 2 \leq n \leq 100000 $
* $ c_j < c_{j+1} $ $( 1 \leq j \leq k-1 )$
* $ 2 \leq q \leq 200000 $
* $ 1 \leq u,v \leq n-1 $
* $ 1 \leq w \leq 10000 $
Input
The input is given in the following format.
$n$
$node_0$
$node_1$
$node_2$
$:$
$node_{n-1}$
$q$
$query_1$
$query_2$
$:$
$query_{q}$
The first line of the input includes an integer $n$, the number of nodes in the tree.
In the next $n$ lines,the information of node $i$ is given in the following format:
ki c1 c2 ... ck
$k_i$ is the number of children of node $i$, and $c_1$ $c_2$ ... $c_{k_i}$ are node IDs of 1st, ... $k$th child of node $i$.
In the next line, the number of queries $q$ is given. In the next $q$ lines, $i$th query is given in the following format:
0 v w
or
1 u
The first integer represents the type of queries.'0' denotes $add(v, w)$ and '1' denotes $getSum(u)$.
Output
For each $getSum$ query, print the sum in a line.
Examples
Input
6
2 1 2
2 3 5
0
0
0
1 4
7
1 1
0 3 10
1 2
0 4 20
1 3
0 5 40
1 4
Output
0
0
40
150
Input
4
1 1
1 2
1 3
0
6
0 3 1000
0 2 1000
0 1 1000
1 1
1 2
1 3
Output
3000
5000
6000 | ```python
#!/usr/bin/env python3
# GRL_5_E: Tree - Range Query on Tree 2
# Undirected Graph
class Edge:
__slots__ = ('v', 'w')
def __init__(self, v, w):
self.v = v
self.w = w
def either(self):
return self.v
def other(self, v):
if v == self.v:
return self.w
else:
return self.v
class Graph:
def __init__(self, v):
self.v = v
self._edges = [[] for _ in range(v)]
def add(self, e):
self._edges[e.v].append(e)
self._edges[e.w].append(e)
def adj(self, v):
return self._edges[v]
def edges(self):
for es in self._edges:
for e in es:
yield e
class HeavyLightDecomposition:
class _Path:
__slots__ = ('nodes', '_index')
def __init__(self):
self.nodes = []
self._index = None
@property
def head(self):
return self.nodes[0]
@property
def size(self):
return len(self.nodes)
def append(self, v):
self.nodes.append(v)
def index(self, v):
if self._index is None:
self._index = {v: i for i, v in enumerate(self.nodes)}
return self._index[v]
def next(self, v):
return self.nodes[self.index(v)+1]
def __init__(self, graph, root):
self._paths = {}
self._parent = [root] * graph.v
self._head = [-1] * graph.v
self._find_paths(graph, root)
def _find_paths(self, graph, root):
def create_path(v):
path = self._Path()
u = v
while u != -1:
path.append(u)
self._head[u] = v
u = heavy[u]
return path
size = [1] * graph.v
maxsize = [0] * graph.v
heavy = [-1] * graph.v
visited = [False] * graph.v
stack = [root]
while stack:
v = stack.pop()
if not visited[v]:
visited[v] = True
stack.append(v)
for e in graph.adj(v):
w = e.other(v)
if not visited[w]:
self._parent[w] = v
stack.append(w)
else:
if v != root:
p = self._parent[v]
if size[v] > maxsize[p]:
maxsize[p] = size[v]
heavy[p] = v
size[p] += size[v]
for e in graph.adj(v):
w = e.other(v)
if w != self._parent[v] and w != heavy[v]:
self._paths[w] = create_path(w)
self._paths[root] = create_path(root)
def parent(self, v):
return self._parent[v]
def paths(self):
return self._paths.values()
def get_path(self, v):
return self._paths[self._head[v]]
class PathSum2:
"""PathSum with range update.
"""
def __init__(self, graph, root):
self.root = root
self.hld = HeavyLightDecomposition(graph, root)
self.rq = {p.head: RangeQuery(p.size) for p in self.hld.paths()}
def add(self, v, val):
u = v
while u != self.root:
path = self.hld.get_path(u)
head = path.head
if head != self.root:
i = path.index(head)
else:
i = path.index(path.next(head))
j = path.index(u)
self.rq[head].add(i+1, j+1, val)
u = self.hld.parent(head)
def get(self, v):
weight = 0
u = v
while u != self.root:
path = self.hld.get_path(u)
head = path.head
i = path.index(head)
j = path.index(u)
weight += self.rq[head].sum(i+1, j+1)
u = self.hld.parent(head)
return weight
# Binary Indexed Tree
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (self.size+1)
def add(self, i, v):
while i <= self.size:
self.bit[i] += v
i += (i & -i)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
class RangeQuery:
def __init__(self, n):
self.size = n
self.bit1 = BinaryIndexedTree(n+1)
self.bit2 = BinaryIndexedTree(n+1)
def add(self, i, j, v):
self.bit1.add(i, v * -i)
self.bit1.add(j+1, v * (j+1))
self.bit2.add(i, v)
self.bit2.add(j+1, -v)
def sum(self, i, j):
s = self.bit1.sum(j+1) + (j+1)*self.bit2.sum(j+1)
s -= self.bit1.sum(i) + i*self.bit2.sum(i)
return s
def run():
n = int(input())
g = Graph(n)
for i in range(n):
k, *cs = [int(i) for i in input().split()]
if k > 0:
for j in cs:
g.add(Edge(i, j))
ps = PathSum2(g, 0)
q = int(input())
for _ in range(q):
com, *args = [int(i) for i in input().split()]
if com == 0:
u, val = args
ps.add(u, val)
elif com == 1:
u, = args
print(ps.get(u))
else:
raise ValueError('invalid command')
if __name__ == '__main__':
run()
``` |
1042_B. Vitamins | Berland shop sells n kinds of juices. Each juice has its price c_i. Each juice includes some set of vitamins in it. There are three types of vitamins: vitamin "A", vitamin "B" and vitamin "C". Each juice can contain one, two or all three types of vitamins in it.
Petya knows that he needs all three types of vitamins to stay healthy. What is the minimum total price of juices that Petya has to buy to obtain all three vitamins? Petya obtains some vitamin if he buys at least one juice containing it and drinks it.
Input
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the number of juices.
Each of the next n lines contains an integer c_i (1 ≤ c_i ≤ 100 000) and a string s_i — the price of the i-th juice and the vitamins it contains. String s_i contains from 1 to 3 characters, and the only possible characters are "A", "B" and "C". It is guaranteed that each letter appears no more than once in each string s_i. The order of letters in strings s_i is arbitrary.
Output
Print -1 if there is no way to obtain all three vitamins. Otherwise print the minimum total price of juices that Petya has to buy to obtain all three vitamins.
Examples
Input
4
5 C
6 B
16 BAC
4 A
Output
15
Input
2
10 AB
15 BA
Output
-1
Input
5
10 A
9 BC
11 CA
4 A
5 B
Output
13
Input
6
100 A
355 BCA
150 BC
160 AC
180 B
190 CA
Output
250
Input
2
5 BA
11 CB
Output
16
Note
In the first example Petya buys the first, the second and the fourth juice. He spends 5 + 6 + 4 = 15 and obtains all three vitamins. He can also buy just the third juice and obtain three vitamins, but its cost is 16, which isn't optimal.
In the second example Petya can't obtain all three vitamins, as no juice contains vitamin "C". | ```python
n = int(input())
a = [1000000,1000000,1000000,1000000,1000000,1000000,1000000]
for i in range(n):
s = input()
k = s.split(" ")
q = int(k[0])
p = k[1]
p = sorted(p)
p = "".join(p)
if(p=='A' or p=='B' or p=='C'):
a[int(ord(p[0])-ord('A'))] = min(a[int(ord(p[0])-ord('A'))],q)
elif(p=='AB'):
a[3] = min(a[3],q)
elif(p=='AC'):
a[4] = min(a[4],q)
elif(p=='BC'):
a[5] = min(a[5],q)
elif(p=='ABC'):
a[6] = min(a[6],q)
# print(a)
x = a[0]+a[1]+a[2]
y1 = a[4]+a[5]
y2 = a[3]+a[4]
y3 = a[3]+a[5]
y4 = a[0]+a[5]
y5 = a[1]+a[4]
y6 = a[2]+a[3]
z = a[6]
# print(x,y1,y2,y3,y4,y5,y6,z)
ans = min(x,y1,y2,y3,y4,y5,y6,z)
if(ans==1000000):
print(-1)
else:
print(ans)
``` |
1065_A. Vasya and Chocolate | There is a special offer in Vasya's favourite supermarket: if the customer buys a chocolate bars, he or she may take b additional bars for free. This special offer can be used any number of times.
Vasya currently has s roubles, and he wants to get as many chocolate bars for free. Each chocolate bar costs c roubles. Help Vasya to calculate the maximum possible number of chocolate bars he can get!
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of testcases.
Each of the next t lines contains four integers s, a, b, c~(1 ≤ s, a, b, c ≤ 10^9) — the number of roubles Vasya has, the number of chocolate bars you have to buy to use the special offer, the number of bars you get for free, and the cost of one bar, respectively.
Output
Print t lines. i-th line should contain the maximum possible number of chocolate bars Vasya can get in i-th test.
Example
Input
2
10 3 1 1
1000000000 1 1000000000 1
Output
13
1000000001000000000
Note
In the first test of the example Vasya can buy 9 bars, get 3 for free, buy another bar, and so he will get 13 bars.
In the second test Vasya buys 1000000000 bars and gets 1000000000000000000 for free. So he has 1000000001000000000 bars. | ```python
n = int(input())
for i in range(n):
a,b,c,d = map(int,input().split())
z = a//d
x = z//b
v = x*c
print(z+v)
``` |
1133_F1. Spanning Tree with Maximum Degree | You are given an undirected unweighted connected graph consisting of n vertices and m edges. It is guaranteed that there are no self-loops or multiple edges in the given graph.
Your task is to find any spanning tree of this graph such that the maximum degree over all vertices is maximum possible. Recall that the degree of a vertex is the number of edges incident to it.
Input
The first line contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, n - 1 ≤ m ≤ min(2 ⋅ 10^5, (n(n-1))/(2))) — the number of vertices and edges, respectively.
The following m lines denote edges: edge i is represented by a pair of integers v_i, u_i (1 ≤ v_i, u_i ≤ n, u_i ≠ v_i), which are the indices of vertices connected by the edge. There are no loops or multiple edges in the given graph, i. e. for each pair (v_i, u_i) there are no other pairs (v_i, u_i) or (u_i, v_i) in the list of edges, and for each pair (v_i, u_i) the condition v_i ≠ u_i is satisfied.
Output
Print n-1 lines describing the edges of a spanning tree such that the maximum degree over all vertices is maximum possible. Make sure that the edges of the printed spanning tree form some subset of the input edges (order doesn't matter and edge (v, u) is considered the same as the edge (u, v)).
If there are multiple possible answers, print any of them.
Examples
Input
5 5
1 2
2 3
3 5
4 3
1 5
Output
3 5
2 1
3 2
3 4
Input
4 6
1 2
1 3
1 4
2 3
2 4
3 4
Output
4 1
1 2
1 3
Input
8 9
1 2
2 3
2 5
1 6
3 4
6 5
4 5
2 7
5 8
Output
3 2
2 5
8 5
6 1
2 7
1 2
3 4
Note
Picture corresponding to the first example: <image>
In this example the number of edges of spanning tree incident to the vertex 3 is 3. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer.
Picture corresponding to the second example: <image>
In this example the number of edges of spanning tree incident to the vertex 1 is 3. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer.
Picture corresponding to the third example: <image>
In this example the number of edges of spanning tree incident to the vertex 2 is 4. It is the maximum degree over all vertices of the spanning tree. It is easy to see that we cannot obtain a better answer. But because this example is symmetric, we can choose almost the same spanning tree but with vertex 5 instead of 2. | ```python
def dfs(s):
stk,cnt=[],[]
stk.append(s)
cnt.append(0)
while (len(stk)>0):
s=stk[-1]
ll=cnt[-1]
visit[s]=1
flag=1
for j in range(ll,len(adj[s]),1):
if visit[adj[s][j]]==0:
cnt[-1]=j+1
stk.append(adj[s][j])
cnt.append(0)
flag=0
break
if flag:
stk.pop()
cnt.pop()
n,m,d=map(int,input().split())
adj=[0]*(n+1)
for i in range(n+1):
adj[i]=[]
for i in range(m):
x,y=map(int,input().split())
adj[x].append(y)
adj[y].append(x)
visit=[0]*(n+1)
visit[1]=1
ans=[0]*m
ct=0
mark=[0]*(n+1)
mark[1]=1
for l in range(len(adj[1])):
i=adj[1][l]
if visit[i]==0:
dfs(i)
ans[ct]=[1,i]
mark[i]=1
ct+=1
if ct>d:
print("NO")
exit()
if ct<d:
for i in range(len(adj[1])):
if mark[adj[1][i]]==0:
ans[ct]=[1,adj[1][i]]
mark[adj[1][i]]=1
ct+=1
if ct==d:
break
if ct<d:
print("NO")
exit()
i=0
while (i<ct):
k=ans[i][1]
if visit[k]:
# print(k,adj[k])
for j in range(len(adj[k])):
if mark[adj[k][j]]==0:
mark[adj[k][j]]=1
ans[ct]=[k,adj[k][j]]
ct+=1
visit[k]=0
i+=1
print("YES")
for i in range(ct):
print(*ans[i])
``` |
1154_C. Gourmet Cat | Polycarp has a cat and his cat is a real gourmet! Dependent on a day of the week he eats certain type of food:
* on Mondays, Thursdays and Sundays he eats fish food;
* on Tuesdays and Saturdays he eats rabbit stew;
* on other days of week he eats chicken stake.
Polycarp plans to go on a trip and already packed his backpack. His backpack contains:
* a daily rations of fish food;
* b daily rations of rabbit stew;
* c daily rations of chicken stakes.
Polycarp has to choose such day of the week to start his trip that his cat can eat without additional food purchases as long as possible. Print the maximum number of days the cat can eat in a trip without additional food purchases, if Polycarp chooses the day of the week to start his trip optimally.
Input
The first line of the input contains three positive integers a, b and c (1 ≤ a, b, c ≤ 7⋅10^8) — the number of daily rations of fish food, rabbit stew and chicken stakes in Polycarps backpack correspondingly.
Output
Print the maximum number of days the cat can eat in a trip without additional food purchases, if Polycarp chooses the day of the week to start his trip optimally.
Examples
Input
2 1 1
Output
4
Input
3 2 2
Output
7
Input
1 100 1
Output
3
Input
30 20 10
Output
39
Note
In the first example the best day for start of the trip is Sunday. In this case, during Sunday and Monday the cat will eat fish food, during Tuesday — rabbit stew and during Wednesday — chicken stake. So, after four days of the trip all food will be eaten.
In the second example Polycarp can start his trip in any day of the week. In any case there are food supplies only for one week in Polycarps backpack.
In the third example Polycarp can start his trip in any day, excluding Wednesday, Saturday and Sunday. In this case, the cat will eat three different dishes in three days. Nevertheless that after three days of a trip there will be 99 portions of rabbit stew in a backpack, can cannot eat anything in fourth day of a trip. | ```python
import copy
nums = [0, 1, 2, 0, 2, 1, 0]
asdf = [3, 2, 2]
things = list(map(int, input().split(' ')))
max_idx = 0
for i in range(7):
stuff = copy.deepcopy(things)
idx = i
while stuff[0] >= 0 and stuff[1] >= 0 and stuff[2] >= 0 and idx < 7:
stuff[nums[idx % 7]] -= 1
idx += 1
num_weeks = min([stuff[0] // asdf[0],
stuff[1] // asdf[1],
stuff[2] // asdf[2]])
stuff[0] -= asdf[0] * num_weeks
stuff[1] -= asdf[1] * num_weeks
stuff[2] -= asdf[2] * num_weeks
idx += 7 * num_weeks
while stuff[0] >= 0 and stuff[1] >= 0 and stuff[2] >= 0:
stuff[nums[idx % 7]] -= 1
idx += 1
idx -= i
if max_idx < idx:
max_idx = idx
print(max_idx - 1)
``` |
1176_A. Divide it! | You are given an integer n.
You can perform any of the following operations with this number an arbitrary (possibly, zero) number of times:
1. Replace n with n/2 if n is divisible by 2;
2. Replace n with 2n/3 if n is divisible by 3;
3. Replace n with 4n/5 if n is divisible by 5.
For example, you can replace 30 with 15 using the first operation, with 20 using the second operation or with 24 using the third operation.
Your task is to find the minimum number of moves required to obtain 1 from n or say that it is impossible to do it.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 1000) — the number of queries.
The next q lines contain the queries. For each query you are given the integer number n (1 ≤ n ≤ 10^{18}).
Output
Print the answer for each query on a new line. If it is impossible to obtain 1 from n, print -1. Otherwise, print the minimum number of moves required to do it.
Example
Input
7
1
10
25
30
14
27
1000000000000000000
Output
0
4
6
6
-1
6
72 | ```python
nq=int(input())
q=[int(input()) for i in range(nq)]
def check3(number):
l=list(str(number))
s=0
for i in l:
s+=int(i)
if s%3==0 :
return 'yes'
else:
return 'no'
def check5(number):
if number%10==5 or number%10==0:
return 'yes'
else:
return 'no'
def check2(number):
if number%2==0:
return 'yes'
else:
return 'no'
def check_div(number):
temp=number
counter=0
if temp==1 or temp==0:
print(0)
elif temp==2:
print(1)
else:
while True:
if check5(temp)=='yes':
counter+=1
temp=(4*temp)//5
if temp==5 or temp==3 or temp==2:
counter+=1
print(counter)
break
elif check5(temp)=='no':
if check3(temp)=='yes':
counter+=1
temp=(2*temp)//3
if temp==5 or temp==3 or temp==2:
counter+=1
print(counter)
break
elif check3(temp)=='no':
if check2(temp)=='yes':
counter+=1
temp=temp//2
if temp==5 or temp==3 or temp==2:
counter+=1
print(counter)
break
elif check2(temp)=='no':
print(-1)
break
#main running function
for num in q:
check_div(num)
``` |
1234_B2. Social Network (hard version) | The only difference between easy and hard versions are constraints on n and k.
You are messaging in one of the popular social networks via your smartphone. Your smartphone can show at most k most recent conversations with your friends. Initially, the screen is empty (i.e. the number of displayed conversations equals 0).
Each conversation is between you and some of your friends. There is at most one conversation with any of your friends. So each conversation is uniquely defined by your friend.
You (suddenly!) have the ability to see the future. You know that during the day you will receive n messages, the i-th message will be received from the friend with ID id_i (1 ≤ id_i ≤ 10^9).
If you receive a message from id_i in the conversation which is currently displayed on the smartphone then nothing happens: the conversations of the screen do not change and do not change their order, you read the message and continue waiting for new messages.
Otherwise (i.e. if there is no conversation with id_i on the screen):
* Firstly, if the number of conversations displayed on the screen is k, the last conversation (which has the position k) is removed from the screen.
* Now the number of conversations on the screen is guaranteed to be less than k and the conversation with the friend id_i is not displayed on the screen.
* The conversation with the friend id_i appears on the first (the topmost) position on the screen and all the other displayed conversations are shifted one position down.
Your task is to find the list of conversations (in the order they are displayed on the screen) after processing all n messages.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 2 ⋅ 10^5) — the number of messages and the number of conversations your smartphone can show.
The second line of the input contains n integers id_1, id_2, ..., id_n (1 ≤ id_i ≤ 10^9), where id_i is the ID of the friend which sends you the i-th message.
Output
In the first line of the output print one integer m (1 ≤ m ≤ min(n, k)) — the number of conversations shown after receiving all n messages.
In the second line print m integers ids_1, ids_2, ..., ids_m, where ids_i should be equal to the ID of the friend corresponding to the conversation displayed on the position i after receiving all n messages.
Examples
Input
7 2
1 2 3 2 1 3 2
Output
2
2 1
Input
10 4
2 3 3 1 1 2 1 2 3 3
Output
3
1 3 2
Note
In the first example the list of conversations will change in the following way (in order from the first to last message):
* [];
* [1];
* [2, 1];
* [3, 2];
* [3, 2];
* [1, 3];
* [1, 3];
* [2, 1].
In the second example the list of conversations will change in the following way:
* [];
* [2];
* [3, 2];
* [3, 2];
* [1, 3, 2];
* and then the list will not change till the end. | ```python
#!/usr/bin/env python3
'''
https://github.com/dhruvildave
http://codeforces.com/contest/1234/problem/B1
'''
from collections import deque
def soln() -> None:
'''Driver code'''
def logic() -> None:
'''Logic'''
n, k = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
s = set()
q = deque(maxlen=k)
for i in arr:
if i not in s:
if len(q) == k:
s.remove(q[-1])
q.appendleft(i)
s.add(i)
print(len(q))
for i in q:
print(i, end=' ')
print()
logic()
if __name__ == '__main__':
soln()
``` |
1253_A. Single Push | You're given two arrays a[1 ... n] and b[1 ... n], both of the same length n.
In order to perform a push operation, you have to choose three integers l, r, k satisfying 1 ≤ l ≤ r ≤ n and k > 0. Then, you will add k to elements a_l, a_{l+1}, …, a_r.
For example, if a = [3, 7, 1, 4, 1, 2] and you choose (l = 3, r = 5, k = 2), the array a will become [3, 7, \underline{3, 6, 3}, 2].
You can do this operation at most once. Can you make array a equal to array b?
(We consider that a = b if and only if, for every 1 ≤ i ≤ n, a_i = b_i)
Input
The first line contains a single integer t (1 ≤ t ≤ 20) — the number of test cases in the input.
The first line of each test case contains a single integer n (1 ≤ n ≤ 100\ 000) — the number of elements in each array.
The second line of each test case contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000).
The third line of each test case contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ 1000).
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output one line containing "YES" if it's possible to make arrays a and b equal by performing at most once the described operation or "NO" if it's impossible.
You can print each letter in any case (upper or lower).
Example
Input
4
6
3 7 1 4 1 2
3 7 3 6 3 2
5
1 1 1 1 1
1 2 1 3 1
2
42 42
42 42
1
7
6
Output
YES
NO
YES
NO
Note
The first test case is described in the statement: we can perform a push operation with parameters (l=3, r=5, k=2) to make a equal to b.
In the second test case, we would need at least two operations to make a equal to b.
In the third test case, arrays a and b are already equal.
In the fourth test case, it's impossible to make a equal to b, because the integer k has to be positive. | ```python
T=int(input())
s=[]
for t in range(T):
dif=0;h=0
n=int(input())
a=[int(k) for k in input().split()]
b =[int(k) for k in input().split()]
for i in range (n):
if(a[i]==b[i]):
continue
else:
dif=b[i]-a[i]
h=i
break
if(dif<0):
a=0
else:
for i in range(h, n):
if(b[i]>a[i]):
a[i] = a[i] + dif
elif(a[i]<b[i]):
a=0
else:
break
if(a==b):
s.append("YES")
else:
s.append("NO")
for i in s:
print(i)
``` |
1296_F. Berland Beauty | There are n railway stations in Berland. They are connected to each other by n-1 railway sections. The railway network is connected, i.e. can be represented as an undirected tree.
You have a map of that network, so for each railway section you know which stations it connects.
Each of the n-1 sections has some integer value of the scenery beauty. However, these values are not marked on the map and you don't know them. All these values are from 1 to 10^6 inclusive.
You asked m passengers some questions: the j-th one told you three values:
* his departure station a_j;
* his arrival station b_j;
* minimum scenery beauty along the path from a_j to b_j (the train is moving along the shortest path from a_j to b_j).
You are planning to update the map and set some value f_i on each railway section — the scenery beauty. The passengers' answers should be consistent with these values.
Print any valid set of values f_1, f_2, ..., f_{n-1}, which the passengers' answer is consistent with or report that it doesn't exist.
Input
The first line contains a single integer n (2 ≤ n ≤ 5000) — the number of railway stations in Berland.
The next n-1 lines contain descriptions of the railway sections: the i-th section description is two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), where x_i and y_i are the indices of the stations which are connected by the i-th railway section. All the railway sections are bidirected. Each station can be reached from any other station by the railway.
The next line contains a single integer m (1 ≤ m ≤ 5000) — the number of passengers which were asked questions. Then m lines follow, the j-th line contains three integers a_j, b_j and g_j (1 ≤ a_j, b_j ≤ n; a_j ≠ b_j; 1 ≤ g_j ≤ 10^6) — the departure station, the arrival station and the minimum scenery beauty along his path.
Output
If there is no answer then print a single integer -1.
Otherwise, print n-1 integers f_1, f_2, ..., f_{n-1} (1 ≤ f_i ≤ 10^6), where f_i is some valid scenery beauty along the i-th railway section.
If there are multiple answers, you can print any of them.
Examples
Input
4
1 2
3 2
3 4
2
1 2 5
1 3 3
Output
5 3 5
Input
6
1 2
1 6
3 1
1 5
4 1
4
6 1 3
3 4 1
6 5 2
1 2 5
Output
5 3 1 2 1
Input
6
1 2
1 6
3 1
1 5
4 1
4
6 1 1
3 4 3
6 5 3
1 2 4
Output
-1 | ```python
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
from collections import deque
n = int(input())
G = [[] for i in range(n)]
edges = []
for i in range(n-1):
a,b = map(int, input().split())
a,b = a-1,b-1
G[a].append(b)
G[b].append(a)
edges.append((a,b))
dep = [0]*n
par = [0]*n
def bfs(root):
que = deque()
que.append((-1,root,0))
while que:
p,v,d = que.pop()
dep[v]=d
par[v]=p
for to in G[v]:
if to != p:
que.append((v,to,d+1))
bfs(0)
num = [1]*n
def lca(a,b,g):
cnt = 0
if dep[a] < dep[b]:
a,b = b,a
while dep[a] > dep[b]:
if num[a] <= g:
num[a] = g
cnt += 1
a = par[a]
while a!=b:
if num[a] <= g:
num[a] = g
cnt += 1
if num[b] <= g:
num[b] = g
cnt += 1
a = par[a]
b = par[b]
return cnt > 0
q = int(input())
query = []
for i in range(q):
a,b,g = map(int, input().split())
a,b = a-1,b-1
query.append((g,a,b))
query.sort(reverse=True)
for g,a,b in query:
if not lca(a,b,g):
print(-1)
exit()
ans = []
for a,b in edges:
if dep[a] < dep[b]:
a,b = b,a
ans.append(num[a])
print(*ans)
``` |
1320_A. Journey Planning | Tanya wants to go on a journey across the cities of Berland. There are n cities situated along the main railroad line of Berland, and these cities are numbered from 1 to n.
Tanya plans her journey as follows. First of all, she will choose some city c_1 to start her journey. She will visit it, and after that go to some other city c_2 > c_1, then to some other city c_3 > c_2, and so on, until she chooses to end her journey in some city c_k > c_{k - 1}. So, the sequence of visited cities [c_1, c_2, ..., c_k] should be strictly increasing.
There are some additional constraints on the sequence of cities Tanya visits. Each city i has a beauty value b_i associated with it. If there is only one city in Tanya's journey, these beauty values imply no additional constraints. But if there are multiple cities in the sequence, then for any pair of adjacent cities c_i and c_{i + 1}, the condition c_{i + 1} - c_i = b_{c_{i + 1}} - b_{c_i} must hold.
For example, if n = 8 and b = [3, 4, 4, 6, 6, 7, 8, 9], there are several three possible ways to plan a journey:
* c = [1, 2, 4];
* c = [3, 5, 6, 8];
* c = [7] (a journey consisting of one city is also valid).
There are some additional ways to plan a journey that are not listed above.
Tanya wants her journey to be as beautiful as possible. The beauty value of the whole journey is the sum of beauty values over all visited cities. Can you help her to choose the optimal plan, that is, to maximize the beauty value of the journey?
Input
The first line contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of cities in Berland.
The second line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 4 ⋅ 10^5), where b_i is the beauty value of the i-th city.
Output
Print one integer — the maximum beauty of a journey Tanya can choose.
Examples
Input
6
10 7 1 9 10 15
Output
26
Input
1
400000
Output
400000
Input
7
8 9 26 11 12 29 14
Output
55
Note
The optimal journey plan in the first example is c = [2, 4, 5].
The optimal journey plan in the second example is c = [1].
The optimal journey plan in the third example is c = [3, 6]. | ```python
n = int(input())
a = input().split()
a = [int(x) for x in a]
a = [a[i]-i for i in range(n)]
d = {}
for i in range(n):
if (a[i] not in d):
d[a[i]] = 0
d[a[i]] += a[i]+i
m = 0
for k in d:
m = max(m,d[k])
print(m)
``` |
1339_D. Edge Weight Assignment | You have unweighted tree of n vertices. You have to assign a positive weight to each edge so that the following condition would hold:
* For every two different leaves v_{1} and v_{2} of this tree, [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges on the simple path between v_{1} and v_{2} has to be equal to 0.
Note that you can put very large positive integers (like 10^{(10^{10})}).
It's guaranteed that such assignment always exists under given constraints. Now let's define f as the number of distinct weights in assignment.
<image> In this example, assignment is valid, because bitwise XOR of all edge weights between every pair of leaves is 0. f value is 2 here, because there are 2 distinct edge weights(4 and 5).
<image> In this example, assignment is invalid, because bitwise XOR of all edge weights between vertex 1 and vertex 6 (3, 4, 5, 4) is not 0.
What are the minimum and the maximum possible values of f for the given tree? Find and print both.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in given tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print two integers — the minimum and maximum possible value of f can be made from valid assignment of given tree. Note that it's always possible to make an assignment under given constraints.
Examples
Input
6
1 3
2 3
3 4
4 5
5 6
Output
1 4
Input
6
1 3
2 3
3 4
4 5
4 6
Output
3 3
Input
7
1 2
2 7
3 4
4 7
5 6
6 7
Output
1 6
Note
In the first example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image>
In the second example, possible assignments for each minimum and maximum are described in picture below. The f value of valid assignment of this tree is always 3.
<image>
In the third example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image> | ```python
import sys
lines = sys.stdin.readlines()
n = int(lines[0].strip())
edges = {}
for i in range(1,n):
(u, v) = map(int, lines[i].strip().split(" "))
if u not in edges: edges[u] = []
if v not in edges: edges[v] = []
edges[u].append(v)
edges[v].append(u)
leaves = []
parLeave = {}
for u in edges.keys():
if len(edges[u]) == 1:
leaves.append(u)
parLeave[u] = edges[u][0]
maxF = n - (len(leaves) - len(set(parLeave.values()))) - 1
parity = {leaves[0]: 0}
stack = [leaves[0]]
seen = set(stack)
while stack:
node = stack.pop()
for adj in edges[node]:
if adj not in seen:
parity[adj] = 1- parity[node]
stack.append(adj)
seen.add(adj)
parityOfLeaves = list(map(lambda x: parity[x], leaves))
if min(parityOfLeaves) == max(parityOfLeaves): minF = 1
else: minF = 3
print("{} {}".format(minF, maxF))
``` |
1360_H. Binary Median | Consider all binary strings of length m (1 ≤ m ≤ 60). A binary string is a string that consists of the characters 0 and 1 only. For example, 0110 is a binary string, and 012aba is not. Obviously, there are exactly 2^m such strings in total.
The string s is lexicographically smaller than the string t (both have the same length m) if in the first position i from the left in which they differ, we have s[i] < t[i]. This is exactly the way strings are compared in dictionaries and in most modern programming languages when comparing them in a standard way. For example, the string 01011 is lexicographically smaller than the string 01100, because the first two characters are the same, and the third character in the first string is less than that in the second.
We remove from this set n (1 ≤ n ≤ min(2^m-1, 100)) distinct binary strings a_1, a_2, …, a_n, each of length m. Thus, the set will have k=2^m-n strings. Sort all strings of the resulting set in lexicographical ascending order (as in the dictionary).
We number all the strings after sorting from 0 to k-1. Print the string whose index is ⌊ (k-1)/(2) ⌋ (such an element is called median), where ⌊ x ⌋ is the rounding of the number down to the nearest integer.
For example, if n=3, m=3 and a=[010, 111, 001], then after removing the strings a_i and sorting, the result will take the form: [000, 011, 100, 101, 110]. Thus, the desired median is 100.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. Then, t test cases follow.
The first line of each test case contains integers n (1 ≤ n ≤ min(2^m-1, 100)) and m (1 ≤ m ≤ 60), where n is the number of strings to remove, and m is the length of binary strings. The next n lines contain a_1, a_2, …, a_n — distinct binary strings of length m.
The total length of all given binary strings in all test cases in one test does not exceed 10^5.
Output
Print t answers to the test cases. For each test case, print a string of length m — the median of the sorted sequence of remaining strings in the corresponding test case.
Example
Input
5
3 3
010
001
111
4 3
000
111
100
011
1 1
1
1 1
0
3 2
00
01
10
Output
100
010
0
1
11
Note
The first test case is explained in the statement.
In the second test case, the result after removing strings and sorting is [001, 010, 101, 110]. Therefore, the desired median is 010. | ```python
for nt in range(int(input())):
n,m = map(int,input().split())
r = []
for i in range(n):
r.append(int(input(),2))
r.sort()
left = 2**m-n
med = (left-1)//2
for i in range(n):
if r[i]<=med:
med+=1
ans = bin(med)[2:]
ans = "0"*(m-len(ans))+ans
print (ans)
``` |
1381_A2. Prefix Flip (Hard Version) | This is the hard version of the problem. The difference between the versions is the constraint on n and the required number of operations. You can make hacks only if all versions of the problem are solved.
There are two binary strings a and b of length n (a binary string is a string consisting of symbols 0 and 1). In an operation, you select a prefix of a, and simultaneously invert the bits in the prefix (0 changes to 1 and 1 changes to 0) and reverse the order of the bits in the prefix.
For example, if a=001011 and you select the prefix of length 3, it becomes 011011. Then if you select the entire string, it becomes 001001.
Your task is to transform the string a into b in at most 2n operations. It can be proved that it is always possible.
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 3t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 10^5) — the length of the binary strings.
The next two lines contain two binary strings a and b of length n.
It is guaranteed that the sum of n across all test cases does not exceed 10^5.
Output
For each test case, output an integer k (0≤ k≤ 2n), followed by k integers p_1,…,p_k (1≤ p_i≤ n). Here k is the number of operations you use and p_i is the length of the prefix you flip in the i-th operation.
Example
Input
5
2
01
10
5
01011
11100
2
01
01
10
0110011011
1000110100
1
0
1
Output
3 1 2 1
6 5 2 5 3 1 2
0
9 4 1 2 10 4 1 2 1 5
1 1
Note
In the first test case, we have 01→ 11→ 00→ 10.
In the second test case, we have 01011→ 00101→ 11101→ 01000→ 10100→ 00100→ 11100.
In the third test case, the strings are already the same. Another solution is to flip the prefix of length 2, which will leave a unchanged. | ```python
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil
from collections import defaultdict
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
from collections import deque
ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin.readline().rstrip()
t = ip()
for _ in range(t):
n = ip()
a = ips()
b = ips()
ch1 = []
ch2 = []
a += '0'
b += '0'
for i in range(1,n+1):
if a[i-1] != a[i]:
ch1.append(i)
if b[i-1] != b[i]:
ch2.append(i)
ch2 = ch2[::-1]
ans = ch1+ch2
ans = [len(ans)]+ans
print(*ans)
``` |
1401_B. Ternary Sequence | You are given two sequences a_1, a_2, ..., a_n and b_1, b_2, ..., b_n. Each element of both sequences is either 0, 1 or 2. The number of elements 0, 1, 2 in the sequence a is x_1, y_1, z_1 respectively, and the number of elements 0, 1, 2 in the sequence b is x_2, y_2, z_2 respectively.
You can rearrange the elements in both sequences a and b however you like. After that, let's define a sequence c as follows:
c_i = \begin{cases} a_i b_i & \mbox{if }a_i > b_i \\\ 0 & \mbox{if }a_i = b_i \\\ -a_i b_i & \mbox{if }a_i < b_i \end{cases}
You'd like to make ∑_{i=1}^n c_i (the sum of all elements of the sequence c) as large as possible. What is the maximum possible sum?
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers x_1, y_1, z_1 (0 ≤ x_1, y_1, z_1 ≤ 10^8) — the number of 0-s, 1-s and 2-s in the sequence a.
The second line of each test case also contains three integers x_2, y_2, z_2 (0 ≤ x_2, y_2, z_2 ≤ 10^8; x_1 + y_1 + z_1 = x_2 + y_2 + z_2 > 0) — the number of 0-s, 1-s and 2-s in the sequence b.
Output
For each test case, print the maximum possible sum of the sequence c.
Example
Input
3
2 3 2
3 3 1
4 0 1
2 3 0
0 0 1
0 0 1
Output
4
2
0
Note
In the first sample, one of the optimal solutions is:
a = \{2, 0, 1, 1, 0, 2, 1\}
b = \{1, 0, 1, 0, 2, 1, 0\}
c = \{2, 0, 0, 0, 0, 2, 0\}
In the second sample, one of the optimal solutions is:
a = \{0, 2, 0, 0, 0\}
b = \{1, 1, 0, 1, 0\}
c = \{0, 2, 0, 0, 0\}
In the third sample, the only possible solution is:
a = \{2\}
b = \{2\}
c = \{0\} | ```python
def checkKey(dict, key):
if key in dict:
return True
return False
# def helper(s):
# l=len(s)
# if (l==1):
# l=[]
# l.append(s)
# return l
# ch=s[0]
# recresult=helper(s[1:])
# myresult=[]
# myresult.append(ch)
# for st in recresult:
# myresult.append(st)
# ts=ch+st
# myresult.append(ts)
# return myresult
# mod=1000000000+7
# def helper(s,n,open,close,i):
# if(i==2*n):
# for i in s:
# print(i,end='')
# print()
# return
# if(open<n):
# s[i]='('
# helper(s,n,open+1,close,i+1)
# if(close<open):
# s[i]=')'
# helper(s,n,open,close+1,i+1)
# def helper(arr,i,n):
# if(i==n-1):
# recresult=[arr[i]]
# return recresult
# digit=arr[i]
# recresult=helper(arr,i+1,n)
# myresult=[]
# for i in recresult:
# myresult.append(i)
# myresult.append(i+digit);
# myresult.append(digit)
# return myresult
# import copy
# n=int(input())
# arr=list(map(int,input().split()))
# ans=[]
# def helper(arr,i,n):
# if(i==n-1):
# # for a in arr:
# # print(a,end=" ")
# # print()
# l=copy.deepcopy(arr)
# ans.append(l)
# return
# for j in range(i,n):
# if(i!=j):
# if(arr[i]==arr[j]):
# continue
# else:
# arr[i],arr[j]=arr[j],arr[i]
# helper(arr,i+1,n)
# arr[j],arr[i]=arr[i],arr[j]
# else:
# arr[i],arr[j]=arr[j],arr[i]
# helper(arr,i+1,n)
# def helper(sol,n,m):
# for i in range(n+1):
# for j in range(m+1):
# print(sol[i][j],end=" ")
# print()
# def rat_in_a_maze(maze,sol,i,j,n,m):
# if(i==n and j==m):
# sol[i][j]=1
# helper(sol,n,m)
# exit()
# if(i>n or j>m):
# return False
# if(maze[i][j]=='X'):
# return False
# maze[i][j]='X'
# sol[i][j]=1
# if(rat_in_a_maze(maze,sol,i,j+1,n,m)):
# return True
# elif(rat_in_a_maze(maze,sol,i+1,j,n,m)):
# return True
# sol[i][j]=0
# return False
test=int (input())
for t_ in range(test):
x1,y1,z1=map(int, input().split())
x2,y2,z2=map(int, input().split())
s=0
temp=min(z1,y2)
s+=2*temp
z1-=temp
y2-=temp
temp=min(z1,z2)
s+=0
z1-=temp
z2-=temp
temp=min(y1,x2)
s+=0
y1-=temp
x2-=temp
temp=min(y1,y2)
s+=0
y1-=temp
y2-=temp
temp=min(y1,z2)
s-=2*temp
y1-=temp
x2-=temp
print(s)
``` |
1424_I. Bubble Cup hypothesis | The Bubble Cup hypothesis stood unsolved for 130 years. Who ever proves the hypothesis will be regarded as one of the greatest mathematicians of our time! A famous mathematician Jerry Mao managed to reduce the hypothesis to this problem:
Given a number m, how many polynomials P with coefficients in set {\{0,1,2,3,4,5,6,7\}} have: P(2)=m?
Help Jerry Mao solve the long standing problem!
Input
The first line contains a single integer t (1 ≤ t ≤ 5⋅ 10^5) - number of test cases.
On next line there are t numbers, m_i (1 ≤ m_i ≤ 10^{18}) - meaning that in case i you should solve for number m_i.
Output
For each test case i, print the answer on separate lines: number of polynomials P as described in statement such that P(2)=m_i, modulo 10^9 + 7.
Example
Input
2
2 4
Output
2
4
Note
In first case, for m=2, polynomials that satisfy the constraint are x and 2.
In second case, for m=4, polynomials that satisfy the constraint are x^2, x + 2, 2x and 4. | ```python
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O region
BUFSIZE = 8192
from sys import stderr
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 print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def fsep(): return map(float, inp().split())
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def pow(x, y, p):
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1): # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def gcd(a, b):
if a == b: return a
while b > 0: a, b = b, a % b
return a
# discrete binary search
# minimise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# if isvalid(l):
# return l
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m - 1):
# return m
# if isvalid(m):
# r = m + 1
# else:
# l = m
# return m
# maximise:
# def search():
# l = 0
# r = 10 ** 15
#
# for i in range(200):
# # print(l,r)
# if isvalid(r):
# return r
# if l == r:
# return l
# m = (l + r) // 2
# if isvalid(m) and not isvalid(m + 1):
# return m
# if isvalid(m):
# l = m
# else:
# r = m - 1
# return m
##to find factorial and ncr
# N=100000
# mod = 10**9 +7
# fac = [1, 1]
# finv = [1, 1]
# inv = [0, 1]
#
# for i in range(2, N + 1):
# fac.append((fac[-1] * i) % mod)
# inv.append(mod - (inv[mod % i] * (mod // i) % mod))
# finv.append(finv[-1] * inv[-1] % mod)
#
#
# def comb(n, r):
# if n < r:
# return 0
# else:
# return fac[n] * (finv[r] * finv[n - r] % mod) % mod
##############Find sum of product of subsets of size k in a array
# ar=[0,1,2,3]
# k=3
# n=len(ar)-1
# dp=[0]*(n+1)
# dp[0]=1
# for pos in range(1,n+1):
# dp[pos]=0
# l=max(1,k+pos-n-1)
# for j in range(min(pos,k),l-1,-1):
# dp[j]=dp[j]+ar[pos]*dp[j-1]
# print(dp[k])
def prefix_sum(ar): # [1,2,3,4]->[1,3,6,10]
return list(accumulate(ar))
def suffix_sum(ar): # [1,2,3,4]->[10,9,7,4]
return list(accumulate(ar[::-1]))[::-1]
def N():
return int(inp())
# =========================================================================================
from collections import defaultdict
def numberOfSetBits(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
def solve():
n=N()
ar=lis()
for i in range(len(ar)):
m=ar[i]
v = m // 2
u = v // 2
w = (v - u)
print((u * w + u + w + 1) % mod)
solve()
#testcase(int(inp()))
``` |
1496_A. Split it! | Kawashiro Nitori is a girl who loves competitive programming.
One day she found a string and an integer. As an advanced problem setter, she quickly thought of a problem.
Given a string s and a parameter k, you need to check if there exist k+1 non-empty strings a_1,a_2...,a_{k+1}, such that $$$s=a_1+a_2+… +a_k+a_{k+1}+R(a_k)+R(a_{k-1})+…+R(a_{1}).$$$
Here + represents concatenation. We define R(x) as a reversed string x. For example R(abcd) = dcba. Note that in the formula above the part R(a_{k+1}) is intentionally skipped.
Input
The input consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case description contains two integers n, k (1≤ n≤ 100, 0≤ k≤ ⌊ n/2 ⌋) — the length of the string s and the parameter k.
The second line of each test case description contains a single string s of length n, consisting of lowercase English letters.
Output
For each test case, print "YES" (without quotes), if it is possible to find a_1,a_2,…,a_{k+1}, and "NO" (without quotes) otherwise.
You can print letters in any case (upper or lower).
Example
Input
7
5 1
qwqwq
2 1
ab
3 1
ioi
4 2
icpc
22 0
dokidokiliteratureclub
19 8
imteamshanghaialice
6 3
aaaaaa
Output
YES
NO
YES
NO
YES
NO
NO
Note
In the first test case, one possible solution is a_1=qw and a_2=q.
In the third test case, one possible solution is a_1=i and a_2=o.
In the fifth test case, one possible solution is a_1=dokidokiliteratureclub. | ```python
from os import path
import sys,time
# mod = int(1e9 + 7)
# import re
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque
from itertools import combinations ,accumulate
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *
from functools import reduce
from operator import mul
star = lambda x: print(' '.join(map(str, x)))
grid = lambda r :[lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
INF = float('inf')
if (path.exists('input.txt')):
sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
import sys
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil
def st(): return list(stdin.readline().strip())
def inp():
return int(stdin.readline())
def inlt():
return list(map(int, stdin.readline().split()))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return map(int, stdin.readline().split())
def pr(n): return stdout.write(str(n)+"\n")
def solve():
n,k = invr()
s=input()
l = 0
r = len(s)-1
while r>l and k>0:
if s[l]==s[r]:
l+=1
r-=1
k-=1
else:
break
if r>=l:
k = k-1
if k<0:
print('YES')
else:
print('NO')
'''if s==s[::-1]:
print('NO')
else:
print('YES')'''
t = 1
t = inp()
for _ in range(t):
solve()
``` |
1519_D. Maximum Sum of Products | You are given two integer arrays a and b of length n.
You can reverse at most one subarray (continuous subsegment) of the array a.
Your task is to reverse such a subarray that the sum ∑_{i=1}^n a_i ⋅ b_i is maximized.
Input
The first line contains one integer n (1 ≤ n ≤ 5000).
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^7).
The third line contains n integers b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^7).
Output
Print single integer — maximum possible sum after reversing at most one subarray (continuous subsegment) of a.
Examples
Input
5
2 3 2 1 3
1 3 2 4 2
Output
29
Input
2
13 37
2 4
Output
174
Input
6
1 8 7 6 3 6
5 9 6 8 8 6
Output
235
Note
In the first example, you can reverse the subarray [4, 5]. Then a = [2, 3, 2, 3, 1] and 2 ⋅ 1 + 3 ⋅ 3 + 2 ⋅ 2 + 3 ⋅ 4 + 1 ⋅ 2 = 29.
In the second example, you don't need to use the reverse operation. 13 ⋅ 2 + 37 ⋅ 4 = 174.
In the third example, you can reverse the subarray [3, 5]. Then a = [1, 8, 3, 6, 7, 6] and 1 ⋅ 5 + 8 ⋅ 9 + 3 ⋅ 6 + 6 ⋅ 8 + 7 ⋅ 8 + 6 ⋅ 6 = 235. | ```python
import random
from datetime import datetime
def test(n, a, b):
def testOdd(k):
result = base_sum
curr_sum = base_sum
for i in range(1, n):
i1 = k - i
i2 = k + i
if i1 < 0 or i2 >=n:
break
curr_sum = curr_sum - (a[i1] - a[i2]) * (b[i1] - b[i2])
result = max(curr_sum, result)
return result
def testEven(k):
result = base_sum
curr_sum = base_sum
for i in range(1, n):
i1 = k - i + 1
i2 = k + i
if i1 < 0 or i2 >=n:
break
curr_sum = curr_sum - (a[i1] - a[i2]) * (b[i1] - b[i2])
result = max(curr_sum, result)
return result
base_sum = sum(x * y for x, y in zip(a, b))
result = base_sum
for k in range(n):
result = max(result, testOdd(k))
result = max(result, testEven(k))
return result
n = int(input())
a = input().split(' ')
a = [int(a[i]) for i in range(n)]
b = input().split(' ')
b = [int(b[i]) for i in range(n)]
# n = 5000
# print(datetime.now())
# a = [random.randint(1, 10000000) for _ in range(n)]
# b = [random.randint(1, 10000000) for _ in range(n)]
result = test(n, a, b)
print(result)
``` |
1546_D. AquaMoon and Chess | Cirno gave AquaMoon a chessboard of size 1 × n. Its cells are numbered with integers from 1 to n from left to right. In the beginning, some of the cells are occupied with at most one pawn, and other cells are unoccupied.
In each operation, AquaMoon can choose a cell i with a pawn, and do either of the following (if possible):
* Move pawn from it to the (i+2)-th cell, if i+2 ≤ n and the (i+1)-th cell is occupied and the (i+2)-th cell is unoccupied.
* Move pawn from it to the (i-2)-th cell, if i-2 ≥ 1 and the (i-1)-th cell is occupied and the (i-2)-th cell is unoccupied.
You are given an initial state of the chessboard. AquaMoon wants to count the number of states reachable from the initial state with some sequence of operations. But she is not good at programming. Can you help her? As the answer can be large find it modulo 998 244 353.
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the size of the chessboard.
The second line contains a string of n characters, consists of characters "0" and "1". If the i-th character is "1", the i-th cell is initially occupied; otherwise, the i-th cell is initially unoccupied.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of states that reachable from the initial state with some sequence of operations modulo 998 244 353.
Example
Input
6
4
0110
6
011011
5
01010
20
10001111110110111000
20
00110110100110111101
20
11101111011000100010
Output
3
6
1
1287
1287
715
Note
In the first test case the strings "1100", "0110" and "0011" are reachable from the initial state with some sequence of operations. | ```python
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
import io
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
from collections import Counter
import threading
#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)
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")
#-------------------game starts now-----------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: max(a,b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
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 __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._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 "SegmentTree({0})".format(self.data)
class SegmentTree1:
def __init__(self, data, default=0, func=lambda a, b: a+b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
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 __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._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 "SegmentTree({0})".format(self.data)
MOD=10**9+7
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10001)]
prime[0]=prime[1]=False
#pp=[0]*10000
def SieveOfEratosthenes(n=10000):
p = 2
c=0
while (p <= n):
if (prime[p] == True):
c+=1
for i in range(p, n+1, p):
#pp[i]=1
prime[i] = False
p += 1
#-----------------------------------DSU--------------------------------------------------
class DSU:
def __init__(self, R, C):
#R * C is the source, and isn't a grid square
self.par = range(R*C + 1)
self.rnk = [0] * (R*C + 1)
self.sz = [1] * (R*C + 1)
def find(self, x):
if self.par[x] != x:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
xr, yr = self.find(x), self.find(y)
if xr == yr: return
if self.rnk[xr] < self.rnk[yr]:
xr, yr = yr, xr
if self.rnk[xr] == self.rnk[yr]:
self.rnk[xr] += 1
self.par[yr] = xr
self.sz[xr] += self.sz[yr]
def size(self, x):
return self.sz[self.find(x)]
def top(self):
# Size of component at ephemeral "source" node at index R*C,
# minus 1 to not count the source itself in the size
return self.size(len(self.sz) - 1) - 1
#---------------------------------Lazy Segment Tree--------------------------------------
# https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
class LazySegTree:
def __init__(self, _op, _e, _mapping, _composition, _id, v):
def set(p, x):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
_d[p] = x
for i in range(1, _log + 1):
_update(p >> i)
def get(p):
assert 0 <= p < _n
p += _size
for i in range(_log, 0, -1):
_push(p >> i)
return _d[p]
def prod(l, r):
assert 0 <= l <= r <= _n
if l == r:
return _e
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push(r >> i)
sml = _e
smr = _e
while l < r:
if l & 1:
sml = _op(sml, _d[l])
l += 1
if r & 1:
r -= 1
smr = _op(_d[r], smr)
l >>= 1
r >>= 1
return _op(sml, smr)
def apply(l, r, f):
assert 0 <= l <= r <= _n
if l == r:
return
l += _size
r += _size
for i in range(_log, 0, -1):
if ((l >> i) << i) != l:
_push(l >> i)
if ((r >> i) << i) != r:
_push((r - 1) >> i)
l2 = l
r2 = r
while l < r:
if l & 1:
_all_apply(l, f)
l += 1
if r & 1:
r -= 1
_all_apply(r, f)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, _log + 1):
if ((l >> i) << i) != l:
_update(l >> i)
if ((r >> i) << i) != r:
_update((r - 1) >> i)
def _update(k):
_d[k] = _op(_d[2 * k], _d[2 * k + 1])
def _all_apply(k, f):
_d[k] = _mapping(f, _d[k])
if k < _size:
_lz[k] = _composition(f, _lz[k])
def _push(k):
_all_apply(2 * k, _lz[k])
_all_apply(2 * k + 1, _lz[k])
_lz[k] = _id
_n = len(v)
_log = _n.bit_length()
_size = 1 << _log
_d = [_e] * (2 * _size)
_lz = [_id] * _size
for i in range(_n):
_d[_size + i] = v[i]
for i in range(_size - 1, 0, -1):
_update(i)
self.set = set
self.get = get
self.prod = prod
self.apply = apply
MIL = 1 << 20
def makeNode(total, count):
# Pack a pair into a float
return (total * MIL) + count
def getTotal(node):
return math.floor(node / MIL)
def getCount(node):
return node - getTotal(node) * MIL
nodeIdentity = makeNode(0.0, 0.0)
def nodeOp(node1, node2):
return node1 + node2
# Equivalent to the following:
return makeNode(
getTotal(node1) + getTotal(node2), getCount(node1) + getCount(node2)
)
identityMapping = -1
def mapping(tag, node):
if tag == identityMapping:
return node
# If assigned, new total is the number assigned times count
count = getCount(node)
return makeNode(tag * count, count)
def composition(mapping1, mapping2):
# If assigned multiple times, take first non-identity assignment
return mapping1 if mapping1 != identityMapping else mapping2
#---------------------------------Pollard rho--------------------------------------------
def memodict(f):
"""memoization decorator for a function taking a single argument"""
class memodict(dict):
def __missing__(self, key):
ret = self[key] = f(key)
return ret
return memodict().__getitem__
def pollard_rho(n):
"""returns a random factor of n"""
if n & 1 == 0:
return 2
if n % 3 == 0:
return 3
s = ((n - 1) & (1 - n)).bit_length() - 1
d = n >> s
for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
p = pow(a, d, n)
if p == 1 or p == n - 1 or a % n == 0:
continue
for _ in range(s):
prev = p
p = (p * p) % n
if p == 1:
return math.gcd(prev - 1, n)
if p == n - 1:
break
else:
for i in range(2, n):
x, y = i, (i * i + 1) % n
f = math.gcd(abs(x - y), n)
while f == 1:
x, y = (x * x + 1) % n, (y * y + 1) % n
y = (y * y + 1) % n
f = math.gcd(abs(x - y), n)
if f != n:
return f
return n
@memodict
def prime_factors(n):
"""returns a Counter of the prime factorization of n"""
if n <= 1:
return Counter()
f = pollard_rho(n)
return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)
def distinct_factors(n):
"""returns a list of all distinct factors of n"""
factors = [1]
for p, exp in prime_factors(n).items():
factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
return factors
def all_factors(n):
"""returns a sorted list of all distinct factors of n"""
small, large = [], []
for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
if not n % i:
small.append(i)
large.append(n // i)
if small[-1] == large[-1]:
large.pop()
large.reverse()
small.extend(large)
return small
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n,i, key):
left = 0
right = n-1
mid = 0
res=n
while (left <= right):
mid = (right + left)//2
if (arr[mid][i] > key):
res=mid
right = mid-1
else:
left = mid + 1
return res
def binarySearch1(arr, n,i, key):
left = 0
right = n-1
mid = 0
res=-1
while (left <= right):
mid = (right + left)//2
if (arr[mid][i] > key):
right = mid-1
else:
res=mid
left = mid + 1
return res
#---------------------------------running code------------------------------------------
t=1
t=int(input())
for _ in range (t):
n=int(input())
#n,m=map(int,input().split())
#a=list(map(int,input().split()))
#tp=list(map(int,input().split()))
s=input()
groups=0
zeros=0
ones=0
for i in s:
if i=='0':
groups+=ones//2
ones=0
zeros+=1
else:
ones+=1
groups+=ones//2
S=Combination(omod)
print(S.ncr(groups+zeros, groups))
``` |
194_A. Exams | One day the Codeforces round author sat exams. He had n exams and he needed to get an integer from 2 to 5 for each exam. He will have to re-sit each failed exam, i.e. the exam that gets mark 2.
The author would need to spend too much time and effort to make the sum of his marks strictly more than k. That could have spoilt the Codeforces round. On the other hand, if the sum of his marks is strictly less than k, the author's mum won't be pleased at all.
The Codeforces authors are very smart and they always get the mark they choose themselves. Also, the Codeforces authors just hate re-sitting exams.
Help the author and find the minimum number of exams he will have to re-sit if he passes the exams in the way that makes the sum of marks for all n exams equal exactly k.
Input
The single input line contains space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 250) — the number of exams and the required sum of marks.
It is guaranteed that there exists a way to pass n exams in the way that makes the sum of marks equal exactly k.
Output
Print the single number — the minimum number of exams that the author will get a 2 for, considering that the sum of marks for all exams must equal k.
Examples
Input
4 8
Output
4
Input
4 10
Output
2
Input
1 3
Output
0
Note
In the first sample the author has to get a 2 for all his exams.
In the second sample he should get a 3 for two exams and a 2 for two more.
In the third sample he should get a 3 for one exam. | ```python
n, k = map(int, input().split())
q = k // n
r = k % n
if q > 2:
print(0)
else:
print(n - r)
``` |
218_A. Mountain Scenery | Little Bolek has found a picture with n mountain peaks painted on it. The n painted peaks are represented by a non-closed polyline, consisting of 2n segments. The segments go through 2n + 1 points with coordinates (1, y1), (2, y2), ..., (2n + 1, y2n + 1), with the i-th segment connecting the point (i, yi) and the point (i + 1, yi + 1). For any even i (2 ≤ i ≤ 2n) the following condition holds: yi - 1 < yi and yi > yi + 1.
We shall call a vertex of a polyline with an even x coordinate a mountain peak.
<image> The figure to the left shows the initial picture, the figure to the right shows what the picture looks like after Bolek's actions. The affected peaks are marked red, k = 2.
Bolek fancied a little mischief. He chose exactly k mountain peaks, rubbed out the segments that went through those peaks and increased each peak's height by one (that is, he increased the y coordinate of the corresponding points). Then he painted the missing segments to get a new picture of mountain peaks. Let us denote the points through which the new polyline passes on Bolek's new picture as (1, r1), (2, r2), ..., (2n + 1, r2n + 1).
Given Bolek's final picture, restore the initial one.
Input
The first line contains two space-separated integers n and k (1 ≤ k ≤ n ≤ 100). The next line contains 2n + 1 space-separated integers r1, r2, ..., r2n + 1 (0 ≤ ri ≤ 100) — the y coordinates of the polyline vertices on Bolek's picture.
It is guaranteed that we can obtain the given picture after performing the described actions on some picture of mountain peaks.
Output
Print 2n + 1 integers y1, y2, ..., y2n + 1 — the y coordinates of the vertices of the polyline on the initial picture. If there are multiple answers, output any one of them.
Examples
Input
3 2
0 5 3 5 1 5 2
Output
0 5 3 4 1 4 2
Input
1 1
0 2 0
Output
0 1 0 | ```python
n, k = map(int, input().split())
tab = [int(x) for x in input().split()]
i = 1
while k > 0:
if tab[i - 1] < tab[i] - 1 and tab[i + 1] < tab[i] - 1:
tab[i] -= 1
k -= 1
i += 2
print(' '.join(map(str, tab)))
``` |
241_E. Flights | LiLand is a country, consisting of n cities. The cities are numbered from 1 to n. The country is well known because it has a very strange transportation system. There are many one-way flights that make it possible to travel between the cities, but the flights are arranged in a way that once you leave a city you will never be able to return to that city again.
Previously each flight took exactly one hour, but recently Lily has become the new manager of transportation system and she wants to change the duration of some flights. Specifically, she wants to change the duration of some flights to exactly 2 hours in such a way that all trips from city 1 to city n take the same time regardless of their path.
Your task is to help Lily to change the duration of flights.
Input
First line of the input contains two integer numbers n and m (2 ≤ n ≤ 1000; 1 ≤ m ≤ 5000) specifying the number of cities and the number of flights.
Each of the next m lines contains two integers ai and bi (1 ≤ ai < bi ≤ n) specifying a one-directional flight from city ai to city bi. It is guaranteed that there exists a way to travel from city number 1 to city number n using the given flights. It is guaranteed that there is no sequence of flights that forms a cyclical path and no two flights are between the same pair of cities.
Output
If it is impossible for Lily to do her task, print "No" (without quotes) on the only line of the output.
Otherwise print "Yes" (without quotes) on the first line of output, then print an integer ansi (1 ≤ ansi ≤ 2) to each of the next m lines being the duration of flights in new transportation system. You should print these numbers in the order that flights are given in the input.
If there are multiple solutions for the input, output any of them.
Examples
Input
3 3
1 2
2 3
1 3
Output
Yes
1
1
2
Input
4 4
1 2
2 3
3 4
1 4
Output
No
Input
5 6
1 2
2 3
3 5
1 4
4 5
1 3
Output
Yes
1
1
1
2
1
2 | ```python
#Flights
from queue import Queue
def BFS(node ,mk,G):
q = Queue()
q.put(node)
mk[node] = True
while not q.empty():
top = q.get()
for ady in G[top]:
if not mk[ady]:
mk[ady] = True
q.put(ady)
def InitValue(n,m):
G1 = [[]for _ in range(n+1)]
G2 = [[]for _ in range(n+1)]
E = []
for _ in range(m):
u,v = map(int,input().split())
G1[u].append(v)
G2[v].append(u)
E.append((u,v))
return G1,G2,E
def Cleen_Graf(mk1,mk2,n,m,G1,G2):
E2 = []
for e in E:
if mk1[e[0]] and mk2[e[0]] and mk1[e[1]] and mk2[e[1]]:
E2.append((e[0],e[1],2))
E2.append((e[1],e[0],-1))
return E2
def Bellman_Ford(n,E2):
dist = [10e12 for _ in range(n+1)]
dist[1] = 0
is_posibol = True
for _ in range(n):
for e in E2:
dist[e[1]] = min(dist[e[1]],dist[e[0]]+e[2])
for e in E2:
if dist[e[0]]+e[2] < dist[e[1]]:
is_posibol = False
return dist,is_posibol
if __name__ == '__main__':
n,m = map(int,input().split())
G1,G2,E = InitValue(n,m)
mk1 = [False for _ in range(n+1)]
mk2 = [False for _ in range(n+1)]
BFS(1,mk1,G1)
BFS(n,mk2,G2)
E2 = Cleen_Graf(mk1,mk2,n,m,G1,G2)
dist,is_posibol = Bellman_Ford(n,E2)
if not is_posibol:
print("No")
else:
print("Yes")
for e in E:
if mk1[e[0]] and mk2[e[0]] and mk1[e[1]] and mk2[e[1]]:
print(dist[e[1]]- dist[e[0]])
else:
print(1)
``` |
28_D. Don't fear, DravDe is kind | A motorcade of n trucks, driving from city «Z» to city «З», has approached a tunnel, known as Tunnel of Horror. Among truck drivers there were rumours about monster DravDe, who hunts for drivers in that tunnel. Some drivers fear to go first, others - to be the last, but let's consider the general case. Each truck is described with four numbers:
* v — value of the truck, of its passangers and cargo
* c — amount of passanger on the truck, the driver included
* l — total amount of people that should go into the tunnel before this truck, so that the driver can overcome his fear («if the monster appears in front of the motorcade, he'll eat them first»)
* r — total amount of people that should follow this truck, so that the driver can overcome his fear («if the monster appears behind the motorcade, he'll eat them first»).
Since the road is narrow, it's impossible to escape DravDe, if he appears from one side. Moreover, the motorcade can't be rearranged. The order of the trucks can't be changed, but it's possible to take any truck out of the motorcade, and leave it near the tunnel for an indefinite period. You, as the head of the motorcade, should remove some of the trucks so, that the rest of the motorcade can move into the tunnel and the total amount of the left trucks' values is maximal.
Input
The first input line contains integer number n (1 ≤ n ≤ 105) — amount of trucks in the motorcade. The following n lines contain four integers each. Numbers in the i-th line: vi, ci, li, ri (1 ≤ vi ≤ 104, 1 ≤ ci ≤ 105, 0 ≤ li, ri ≤ 105) — describe the i-th truck. The trucks are numbered from 1, counting from the front of the motorcade.
Output
In the first line output number k — amount of trucks that will drive into the tunnel. In the second line output k numbers — indexes of these trucks in ascending order. Don't forget please that you are not allowed to change the order of trucks. If the answer is not unique, output any.
Examples
Input
5
1 1 0 3
1 1 1 2
1 1 2 1
1 1 3 0
2 1 3 0
Output
4
1 2 3 5
Input
5
1 1 0 3
10 1 2 1
2 2 1 1
10 1 1 2
3 1 3 0
Output
3
1 3 5 | ```python
n = int(input())
v = n*[-1]
c = n*[-1]
L = n*[-1]
R = n*[-1]
for i in range(n):
v[i], c[i], L[i], R[i] = map(int, input().split())
index = [i for i in range(n)]
index.sort(key = lambda i: (c[i]+L[i]+R[i], i))
prev = n*[-1]
best_res = 0
best_last = -1
ii = 0
while ii < n:
i = index[ii]
jj = ii
d = {0: (0, -1)}
while jj < n:
j = index[jj]
if c[i]+L[i]+R[i] != c[j]+L[j]+R[j]: break
x = d.get(L[j])
if x is not None:
cur = v[j]+x[0]
prev[j] = x[1]
if R[j] == 0 and cur > best_res:
best_res = cur
best_last = j
y = d.get(L[j]+c[j])
if y is None or cur > y[0]:
d[L[j]+c[j]] = (cur, j)
jj += 1
ii = jj
ans = []
while best_last != -1:
ans.append(best_last)
best_last = prev[best_last]
ans.reverse()
for i in range(len(ans)):
ans[i] += 1
print (len(ans))
if len(ans):
print (" ".join(map(str, ans)))
``` |
315_D. Sereja and Periods | Let's introduce the designation <image>, where x is a string, n is a positive integer and operation " + " is the string concatenation operation. For example, [abc, 2] = abcabc.
We'll say that string s can be obtained from string t, if we can remove some characters from string t and obtain string s. For example, strings ab and aсba can be obtained from string xacbac, and strings bx and aaa cannot be obtained from it.
Sereja has two strings, w = [a, b] and q = [c, d]. He wants to find such maximum integer p (p > 0), that [q, p] can be obtained from string w.
Input
The first line contains two integers b, d (1 ≤ b, d ≤ 107). The second line contains string a. The third line contains string c. The given strings are not empty and consist of lowercase English letters. Their lengths do not exceed 100.
Output
In a single line print an integer — the largest number p. If the required value of p doesn't exist, print 0.
Examples
Input
10 3
abab
bab
Output
3 | ```python
b, p = map(int, input().split())
s1 = input()
s2 = input()
cnt = [0] * len(s2)
nxt = [0] * len(s2)
for i in range(len(s2)):
pos = i
for j in range(len(s1)):
if s1[j] == s2[pos]:
pos += 1
if pos == len(s2):
cnt[i] += 1
pos = 0
nxt[i] = pos
ans = 0
poss = 0
for i in range(b):
ans += cnt[poss]
poss = nxt[poss]
print(ans // p)
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.