name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
774_J. Stepan's Series | Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not.
Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.
Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked.
The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.
Output
If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).
Examples
Input
5 2
NYNNY
Output
YES
Input
6 1
????NN
Output
NO
Note
In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.
In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive. | ```python
def process(S, k):
n = len(S)
if k > n:
return 'NO'
current = 0
for i in range(n):
if S[i]=='N':
current+=1
if current > k:
return 'NO'
else:
current = 0
start_work = True
for i in range(k):
if S[i]=='Y':
start_work = False
if start_work and (k==n or k < n and S[k] != 'N'):
return 'YES'
if n==1:
if k==1 and S[0] in ['?N']:
return 'YES'
if k==0 and S[0] in ['?Y']:
return 'YES'
return 'NO'
if k==n:
if 'Y' in S:
return 'NO'
return 'YES'
Y_count = 0
p1 = 0
for i in range(1, k+1):
if S[i]=='Y':
Y_count+=1
p2 = i
for i in range(k+1, n):
# print(p1, Y_count, p2)
if Y_count==0 and S[p1] != 'N' and (p2==n-1 or S[p2+1] != 'N'):
return 'YES'
p1+=1
p2+=1
if p2 < n and S[p2]=='Y':
Y_count+=1
if p1 < n and S[p1]=='Y':
Y_count-=1
# print(p1, Y_count, p2)
if Y_count==0 and p1 < n and S[p1] != 'N':
return 'YES'
return 'NO'
n, k = [int(x) for x in input().split()]
S = input()
print(process(S, k))
``` |
79_C. Beaver | After Fox Ciel got off a bus, she found that the bus she was on was a wrong bus and she lost her way in a strange town. However, she fortunately met her friend Beaver Taro and asked which way to go to her castle. Taro's response to her was a string s, and she tried to remember the string s correctly.
However, Ciel feels n strings b1, b2, ... , bn are really boring, and unfortunately she dislikes to remember a string that contains a boring substring. To make the thing worse, what she can remember is only the contiguous substring of s.
Determine the longest contiguous substring of s that does not contain any boring string, so that she can remember the longest part of Taro's response.
Input
In the first line there is a string s. The length of s will be between 1 and 105, inclusive.
In the second line there is a single integer n (1 ≤ n ≤ 10). Next n lines, there is a string bi (1 ≤ i ≤ n). Each length of bi will be between 1 and 10, inclusive.
Each character of the given strings will be either a English alphabet (both lowercase and uppercase) or a underscore ('_') or a digit. Assume that these strings are case-sensitive.
Output
Output in the first line two space-separated integers len and pos: the length of the longest contiguous substring of s that does not contain any bi, and the first position of the substring (0-indexed). The position pos must be between 0 and |s| - len inclusive, where |s| is the length of string s.
If there are several solutions, output any.
Examples
Input
Go_straight_along_this_street
5
str
long
tree
biginteger
ellipse
Output
12 4
Input
IhaveNoIdea
9
I
h
a
v
e
N
o
I
d
Output
0 0
Input
unagioisii
2
ioi
unagi
Output
5 5
Note
In the first sample, the solution is traight_alon.
In the second sample, the solution is an empty string, so the output can be «0 0», «0 1», «0 2», and so on.
In the third sample, the solution is either nagio or oisii. | ```python
s, n = input(), int(input())
t = [input() for i in range(n)]
def f(i):
global t
for j in range(n):
if i < j:
if len(t[j]) < len(t[i]) and t[j] in t[i]: return False
elif j < i and t[j] in t[i]: return False
return True
t = [t[i] for i in range(n) if f(i)]
n = len(s)
r = [0] * n
for p in t:
i, m = -1, len(p) - 1
while True:
i = s.find(p, i + 1)
if i == -1: break
r[i] += 1
r[i + m] += 2
d, j, q = 0, -1, [-1]
for i in range(n):
if r[i] & 1: q.append(i)
if r[i] & 2:
j = q.pop(0)
if i - j > d: d, k = i - j, j
j = q.pop(0)
if n - j > d: d, k = n - j, j
print(d - 1, k + 1)
``` |
846_A. Curriculum Vitae | Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1 | ```python
def main():
n = int(input())
games = list(map(int, input().split(' ')))
result = max([games[:i].count(0) + games[i:].count(1) for i in range(n+1)])
print(result)
if __name__ == "__main__":
main()
``` |
867_C. Ordering Pizza | It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74. | ```python
def cns(ts,s):
if ts/s==int(ts/s):
return ts
else:
return (int(ts/s)+1)*s
n,spp=[int(i) for i in input().split()]
tsr=0
da=[[] for i in range(100005)]
db=[[] for i in range(100005)]
sl=[]
for i in range(n):
sl.append([int(j) for j in input().split()])
tsr+=sl[i][0]
if sl[i][1]>sl[i][2]:
da[sl[i][1]-sl[i][2]].append(i)
else:
db[sl[i][2]-sl[i][1]].append(i)
tsa=cns(tsr,spp)
a1=0
c1=0
for i in range(100000,-1,-1):
for j in da[i]:
a1+=sl[j][0]*sl[j][1]
c1+=sl[j][0]
c1r=cns(c1,spp)-c1
c2r=tsa-cns(c1,spp)
for i in range(100000,-1,-1):
for j in db[i]:
if sl[j][0]>c2r:
a1+=c2r*sl[j][2]
a1+=(sl[j][0]-c2r)*sl[j][1]
c2r=0
else:
a1+=sl[j][0]*sl[j][2]
c2r-=sl[j][0]
a2=0
c2=0
for i in range(100000,-1,-1):
for j in db[i]:
a2+=sl[j][0]*sl[j][2]
c2+=sl[j][0]
c2r=cns(c2,spp)-c2
c1r=tsa-cns(c2,spp)
for i in range(100000,-1,-1):
for j in da[i]:
if sl[j][0]>c1r:
a2+=c1r*sl[j][1]
a2+=(sl[j][0]-c1r)*sl[j][2]
c1r=0
else:
a2+=sl[j][0]*sl[j][1]
c1r-=sl[j][0]
print(max(a1,a2))
``` |
914_E. Palindromes in a Tree | You are given a tree (a connected acyclic undirected graph) of n vertices. Vertices are numbered from 1 to n and each vertex is assigned a character from a to t.
A path in the tree is said to be palindromic if at least one permutation of the labels in the path is a palindrome.
For each vertex, output the number of palindromic paths passing through it.
Note: The path from vertex u to vertex v is considered to be the same as the path from vertex v to vertex u, and this path will be counted only once for each of the vertices it passes through.
Input
The first line contains an integer n (2 ≤ n ≤ 2·105) — the number of vertices in the tree.
The next n - 1 lines each contain two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting an edge connecting vertex u and vertex v. It is guaranteed that the given graph is a tree.
The next line contains a string consisting of n lowercase characters from a to t where the i-th (1 ≤ i ≤ n) character is the label of vertex i in the tree.
Output
Print n integers in a single line, the i-th of which is the number of palindromic paths passing through vertex i in the tree.
Examples
Input
5
1 2
2 3
3 4
3 5
abcbb
Output
1 3 4 3 3
Input
7
6 2
4 3
3 7
5 2
7 2
1 4
afefdfs
Output
1 4 1 1 2 4 2
Note
In the first sample case, the following paths are palindromic:
2 - 3 - 4
2 - 3 - 5
4 - 3 - 5
Additionally, all paths containing only one vertex are palindromic. Listed below are a few paths in the first sample that are not palindromic:
1 - 2 - 3
1 - 2 - 3 - 4
1 - 2 - 3 - 5 | ```python
import sys, os
def centroid_decomp(coupl):
n = len(coupl)
bfs = [n - 1]
for node in bfs:
bfs += coupl[node]
for nei in coupl[node]:
coupl[nei].remove(node)
size = [0] * n
for node in reversed(bfs):
size[node] = 1 + sum(size[child] for child in coupl[node])
def centroid_reroot(root):
while coupl[root]:
child = max(coupl[root], key = size.__getitem__)
if size[child] <= size[root] // 2:
break
size[root] -= size[child]
size[child] += size[root]
coupl[root].remove(child)
coupl[child].append(root)
root = child
return root
bfs = [n - 1]
for node in bfs:
centroid = centroid_reroot(node)
bfs += coupl[centroid]
yield centroid
inp = sys.stdin.buffer.read().split(); ii = 0
n = int(inp[ii]); ii += 1
coupl = [[] for _ in range(n)]
for _ in range(n - 1):
u = int(inp[ii]) - 1; ii += 1
v = int(inp[ii]) - 1; ii += 1
coupl[u].append(v)
coupl[v].append(u)
A = [1 << c - b'a'[0] for c in inp[ii]]; ii += 1
palistates = [0] + [1 << i for i in range(20)]
ans = [0.0] * n
dp = [0.0] * n
val = [0] * n
counter = [0] * (1 << 20)
for centroid in centroid_decomp(coupl):
bfss = []
for root in coupl[centroid]:
bfs = [root]
for node in bfs:
bfs += coupl[node]
bfss.append(bfs)
for node in bfs:
val[node] ^= A[node]
for child in coupl[node]:
val[child] = val[node]
entire_bfs = [centroid]
for bfs in bfss:
entire_bfs += bfs
for node in entire_bfs:
val[node] ^= A[centroid]
counter[val[node]] += 1
for bfs in bfss:
for node in bfs:
counter[val[node]] -= 1
for node in bfs:
v = val[node] ^ A[centroid]
for p in palistates:
dp[node] += counter[v ^ p]
for node in bfs:
counter[val[node]] += 1
for node in reversed(entire_bfs):
dp[node] += sum(dp[child] for child in coupl[node])
dp[centroid] += 1
for p in palistates:
dp[centroid] += counter[p]
dp[centroid] //= 2
for node in entire_bfs:
ans[node] += dp[node]
counter[val[node]] = val[node] = 0
dp[node] = 0.0
os.write(1, b' '.join(str(int(x)).encode('ascii') for x in ans))
``` |
937_C. Save Energy! | Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes. | ```python
k,d,t = map(int, input().split())
if k % d == 0:
print(t)
exit()
r = k % d
ot = (d-r) /2
ot += k
ct = k + (d-r)
cn = int(t // ot)
ans = cn*ct
rt = t - cn*ot
if rt < k:
ans += rt
else:
ans += k
rt -= k
ans += rt*2
ans = "%.10f" % float(ans)
print(ans)
``` |
962_E. Byteland, Berland and Disputed Cities | The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24. | ```python
def solve(length, cities):
result = 0
lastP = None
lastB = None
lastR = None
maxB = 0
maxR = 0
for idx, city in enumerate(cities):
i, code = city
if(code == 'B'):
if(lastB != None):
result += abs(i - lastB)
maxB = max(maxB, abs(i - lastB))
lastB = i
if(code == 'R'):
if(lastR != None):
result += abs(i - lastR)
maxR = max(maxR, abs(i - lastR))
lastR = i
if(code == 'P'):
# B case
if(lastB != None):
result += abs(i - lastB)
maxB = max(maxB, abs(i - lastB))
# R case
if(lastR != None):
result += abs(i - lastR)
maxR = max(maxR, abs(i - lastR))
if(lastP != None):
result += min(0, abs(i - lastP) - maxB - maxR)
maxB = 0
maxR = 0
lastB = i
lastR = i
lastP = i
return result
if __name__ == '__main__':
length = int(input())
cities = []
for i in range(length):
data = input().split(" ")
cities.append((int(data[0]), data[1]))
result = solve(length, cities)
print(result)
``` |
990_A. Commentary Boxes | Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes. | ```python
n, m, a, b = list(map(int, input().split()))
k = n%m
print(min(k*b, (m - k)*a))
``` |
p02609 AIsing Programming Contest 2020 - Anything Goes to Zero | Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3 | ```python
from sys import stdin
import sys
import itertools
import array
import textwrap
import math
N = int(input())
X = input()
temp = X.count("1")
t = [0, 0, 0]
t[0] = int(X, 2) % (temp-1) if temp != 1 else 0
t[2] = int(X, 2) % (temp+1)
cnt = 0
for i in range(N):
if X[i] == "1" and temp == 1:
print(0)
continue
if X[i] == "1":
# p = (1 << (N-i-1)) % (temp-1)
p = pow(2, N-1-i, temp-1)
a = (t[0]-p) % (temp-1)
elif X[i] == "0":
# m = (1 << (N-i-1)) % (temp+1)
m = pow(2, N-1-i, temp+1)
a = (t[2]+m) % (temp+1)
cnt = 1
while a > 0:
a = a % format(a, 'b').count("1")
cnt += 1
print(cnt)
``` |
p02875 AtCoder Grand Contest 040 - Neither AB nor BA | Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358 | ```python
N = int(input())
nn = N + 10
P = 998244353
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
ans = pow(3, N, P)
for i in range(N//2 + 1, N + 1):
ans = (ans - 2 * C(N, i) * pow(2, N - i, P)) % P
print(ans)
``` |
p03009 diverta 2019 Programming Contest 2 - Balanced Piles | There are N squares arranged in a row, numbered 1 to N from left to right. Takahashi will stack building blocks on these squares, on which there are no blocks yet.
He wants to stack blocks on the squares evenly, so he will repeat the following operation until there are H blocks on every square:
* Let M and m be the maximum and minimum numbers of blocks currently stacked on a square, respectively. Choose a square on which m blocks are stacked (if there are multiple such squares, choose any one of them), and add a positive number of blocks on that square so that there will be at least M and at most M + D blocks on that square.
Tell him how many ways there are to have H blocks on every square by repeating this operation. Since there can be extremely many ways, print the number modulo 10^9+7.
Constraints
* 2 \leq N \leq 10^6
* 1 \leq D \leq H \leq 10^6
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N H D
Output
Print the number of ways to have H blocks on every square, modulo 10^9+7.
Examples
Input
2 2 1
Output
6
Input
2 30 15
Output
94182806
Input
31415 9265 3589
Output
312069529 | ```python
n, h, d = map(int, input().split())
MOD = 10 ** 9 + 7
fact, fact_acc = 1, 1
for i in range(2, n + 1):
fact = fact * i % MOD
fact_acc = (fact_acc + fact) % MOD
dp = [0] * (h + 1)
dp[0] = base = fact
for i in range(1, h):
dp[i] = base * fact_acc % MOD
base = (base + dp[i]) % MOD
if i >= d:
base = (base - dp[i - d]) % MOD
print(base)
``` |
p03149 KEYENCE Programming Contest 2019 - Beginning | You are given four digits N_1, N_2, N_3 and N_4. Determine if these can be arranged into the sequence of digits "1974".
Constraints
* 0 \leq N_1, N_2, N_3, N_4 \leq 9
* N_1, N_2, N_3 and N_4 are integers.
Input
Input is given from Standard Input in the following format:
N_1 N_2 N_3 N_4
Output
If N_1, N_2, N_3 and N_4 can be arranged into the sequence of digits "1974", print `YES`; if they cannot, print `NO`.
Examples
Input
1 7 9 4
Output
YES
Input
1 9 7 4
Output
YES
Input
1 2 9 1
Output
NO
Input
4 9 0 8
Output
NO | ```python
n = input().split()
n.sort()
print("YES" if "".join(n) == "1479" else "NO")
``` |
p03293 AtCoder Beginner Contest 103 - String Rotation | You are given string S and T consisting of lowercase English letters.
Determine if S equals T after rotation.
That is, determine if S equals T after the following operation is performed some number of times:
Operation: Let S = S_1 S_2 ... S_{|S|}. Change S to S_{|S|} S_1 S_2 ... S_{|S|-1}.
Here, |X| denotes the length of the string X.
Constraints
* 2 \leq |S| \leq 100
* |S| = |T|
* S and T consist of lowercase English letters.
Input
Input is given from Standard Input in the following format:
S
T
Output
If S equals T after rotation, print `Yes`; if it does not, print `No`.
Examples
Input
kyoto
tokyo
Output
Yes
Input
abc
arc
Output
No
Input
aaaaaaaaaaaaaaab
aaaaaaaaaaaaaaab
Output
Yes | ```python
s=input()*100
t=input()
if t in s:
print("Yes")
else:
print("No")
``` |
p03449 AtCoder Beginner Contest 087 - Candies | We have a 2 \times N grid. We will denote the square at the i-th row and j-th column (1 \leq i \leq 2, 1 \leq j \leq N) as (i, j).
You are initially in the top-left square, (1, 1). You will travel to the bottom-right square, (2, N), by repeatedly moving right or down.
The square (i, j) contains A_{i, j} candies. You will collect all the candies you visit during the travel. The top-left and bottom-right squares also contain candies, and you will also collect them.
At most how many candies can you collect when you choose the best way to travel?
Constraints
* 1 \leq N \leq 100
* 1 \leq A_{i, j} \leq 100 (1 \leq i \leq 2, 1 \leq j \leq N)
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} ... A_{1, N}
A_{2, 1} A_{2, 2} ... A_{2, N}
Output
Print the maximum number of candies that can be collected.
Examples
Input
5
3 2 2 4 1
1 2 2 2 1
Output
14
Input
4
1 1 1 1
1 1 1 1
Output
5
Input
7
3 3 4 5 4 5 3
5 3 4 4 2 3 2
Output
29
Input
1
2
3
Output
5 | ```python
N=int(input())
L1=list(map(int,input().split()))
L2=list(map(int,input().split()))
C=[]
for n in range(N):
C.append(sum(L1[:n+1])+sum(L2[n:]))
print(max(C))
``` |
p03609 AtCoder Beginner Contest 072 - Sandglass2 | We have a sandglass that runs for X seconds. The sand drops from the upper bulb at a rate of 1 gram per second. That is, the upper bulb initially contains X grams of sand.
How many grams of sand will the upper bulb contains after t seconds?
Constraints
* 1≤X≤10^9
* 1≤t≤10^9
* X and t are integers.
Input
The input is given from Standard Input in the following format:
X t
Output
Print the number of sand in the upper bulb after t second.
Examples
Input
100 17
Output
83
Input
48 58
Output
0
Input
1000000000 1000000000
Output
0 | ```python
X,t = map(int, input().split())
print(X - t if X > t else 0)
``` |
p03770 AtCoder Grand Contest 012 - Colorful Balls | Snuke arranged N colorful balls in a row. The i-th ball from the left has color c_i and weight w_i.
He can rearrange the balls by performing the following two operations any number of times, in any order:
* Operation 1: Select two balls with the same color. If the total weight of these balls is at most X, swap the positions of these balls.
* Operation 2: Select two balls with different colors. If the total weight of these balls is at most Y, swap the positions of these balls.
How many different sequences of colors of balls can be obtained? Find the count modulo 10^9 + 7.
Constraints
* 1 ≤ N ≤ 2 × 10^5
* 1 ≤ X, Y ≤ 10^9
* 1 ≤ c_i ≤ N
* 1 ≤ w_i ≤ 10^9
* X, Y, c_i, w_i are all integers.
Input
Input is given from Standard Input in the following format:
N X Y
c_1 w_1
:
c_N w_N
Output
Print the answer.
Examples
Input
4 7 3
3 2
4 3
2 1
4 4
Output
2
Input
1 1 1
1 1
Output
1
Input
21 77 68
16 73
16 99
19 66
2 87
2 16
7 17
10 36
10 68
2 38
10 74
13 55
21 21
3 7
12 41
13 88
18 6
2 12
13 87
1 9
2 27
13 15
Output
129729600 | ```python
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
def calc_group_num(self):
N = len(self._parent)
ans = 0
for i in range(N):
if self.find_root(i) == i:
ans += 1
return ans
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
import sys,bisect
input=sys.stdin.buffer.readline
N,X,Y=map(int,input().split())
cball=[[] for i in range(N)]
ball=[]
color=[-1]*N
for i in range(N):
c,w=map(int,input().split())
ball.append((w,c-1,i))
cball[c-1].append((w,i))
color[i]=c-1
for i in range(N):
cball[i].sort()
ball.sort()
if N==1:
print(1)
exit()
cmin=[10**20 for i in range(N)]
for i in range(N):
if cball[i]:
cmin[i]=min(cball[i][j][0] for j in range(len(cball[i])))
_cmine1=[cmin[i] for i in range(N)]
_cmine2=[cmin[i] for i in range(N)]
for i in range(1,N):
_cmine1[i]=min(_cmine1[i],_cmine1[i-1])
for i in range(N-2,-1,-1):
_cmine2[i]=min(_cmine2[i],_cmine2[i+1])
cmine=[0]*N
cmine[0]=_cmine2[1]
cmine[-1]=_cmine1[N-2]
for i in range(1,N-1):
cmine[i]=min(_cmine1[i-1],_cmine2[i+1])
M=min(ball)
special=-1
for i in range(N):
if cmine[i]!=M[0]:
special=i
uf=UnionFindVerSize(N)
for i in range(N):
if i!=special:
for j in range(len(cball[i])):
if M[0]+cball[i][j][0]<=Y:
uf.unite(cball[i][j][1],M[2])
if j!=0 and cball[i][j][0]+cball[i][0][0]<=X:
uf.unite(cball[i][j][1],cball[i][0][1])
else:
for j in range(len(cball[special])):
if cmine[special]+cball[special][j][0]<=Y:
uf.unite(cball[special][j][1],M[2])
if M[0]+cball[special][j][0]<=X:
uf.unite(cball[special][j][1],M[2])
connect={}
for i in range(N):
root=uf.find_root(i)
if root not in connect:
connect[root]=[]
connect[root].append(i)
ans=1
for root in connect:
cc={}
for i in connect[root]:
if color[i] not in cc:
cc[color[i]]=0
cc[color[i]]+=1
size=len(connect[root])
for C in cc:
ans*=g2[cc[C]]
ans%=mod
ans*=g1[size]
ans%=mod
print(ans)
``` |
p03939 AtCoder Grand Contest 007 - Pushing Balls | There are N balls and N+1 holes in a line. Balls are numbered 1 through N from left to right. Holes are numbered 1 through N+1 from left to right. The i-th ball is located between the i-th hole and (i+1)-th hole. We denote the distance between neighboring items (one ball and one hole) from left to right as d_i (1 \leq i \leq 2 \times N). You are given two parameters d_1 and x. d_i - d_{i-1} is equal to x for all i (2 \leq i \leq 2 \times N).
We want to push all N balls into holes one by one. When a ball rolls over a hole, the ball will drop into the hole if there is no ball in the hole yet. Otherwise, the ball will pass this hole and continue to roll. (In any scenario considered in this problem, balls will never collide.)
In each step, we will choose one of the remaining balls uniformly at random and then choose a direction (either left or right) uniformly at random and push the ball in this direction. Please calculate the expected total distance rolled by all balls during this process.
For example, when N = 3, d_1 = 1, and x = 1, the following is one possible scenario:
c9264131788434ac062635a675a785e3.jpg
* first step: push the ball numbered 2 to its left, it will drop into the hole numbered 2. The distance rolled is 3.
* second step: push the ball numbered 1 to its right, it will pass the hole numbered 2 and drop into the hole numbered 3. The distance rolled is 9.
* third step: push the ball numbered 3 to its right, it will drop into the hole numbered 4. The distance rolled is 6.
So the total distance in this scenario is 18.
Note that in all scenarios every ball will drop into some hole and there will be a hole containing no ball in the end.
Constraints
* 1 \leq N \leq 200,000
* 1 \leq d_1 \leq 100
* 0 \leq x \leq 100
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N d_1 x
Output
Print a floating number denoting the answer. The relative or absolute error of your answer should not be higher than 10^{-9}.
Examples
Input
1 3 3
Output
4.500000000000000
Input
2 1 0
Output
2.500000000000000
Input
1000 100 100
Output
649620280.957660079002380 | ```python
def solve(n, d, x):
ans = 0
while n:
ans += d + (2 * n - 1) * x / 2
d = ((n + 1) * d + 5 * x / 2) / n
x *= (n + 2) / n
n -= 1
return ans
print('{:.10f}'.format(solve(*map(float, input().split()))))
``` |
p00031 Weight | <image>
My grandmother uses a balance. The balance will balance if you place the same size on both of the two dishes, otherwise it will tilt to the heavier side. The weights of the 10 weights are 1g, 2g, 4g, 8g, 16g, 32g, 64g, 128g, 256g, 512g in order of lightness.
My grandmother says, "Weigh up to about 1 kg in grams." "Then, try to weigh the juice here," and my grandmother put the juice on the left plate and the 8g, 64g, and 128g weights on the right plate to balance. Then he answered, "The total weight is 200g, so the juice is 200g. How is it correct?"
Since the weight of the item to be placed on the left plate is given, create a program that outputs the weight to be placed on the right plate in order of lightness when balancing with the item of the weight given by the balance. However, the weight of the item to be weighed shall be less than or equal to the total weight of all weights (= 1023g).
Hint
The weight of the weight is 2 to the nth power (n = 0, 1, .... 9) g.
Input
Given multiple datasets. For each dataset, the weight of the item to be placed on the left plate is given in one line. Please process until the end of the input. The number of datasets does not exceed 50.
Output
For each data set, separate the weights (ascending order) to be placed on the right plate with one blank and output them on one line.
Example
Input
5
7
127
Output
1 4
1 2 4
1 2 4 8 16 32 64 | ```python
import sys
l = [2 ** i for i in range(10)]
for line in sys.stdin:
blist = list(bin(int(line))[2:])
blist.reverse()
#print(blist)
anslist = []
for i in range(len(blist)):
if blist[i] == "1":
anslist.append(str(l[i]))
print(' '.join(anslist))
``` |
p00162 Hamming Numbers | The number obtained by multiplying 1 by 2, 3, 5 several times (0 or more times) is called the Hamming numbers. For example
* 1
* 1 x 2 x 2 = 4
* 1 x 2 x 2 x 3 x 5 x 5 = 300
Etc. are humming numbers, but 11, 13, 14 etc. are not humming numbers.
All humming numbers are divisible by a power of 60 (for example, 54 is divisible by 603 = 21600), so they have long been known as convenient numbers for sexagesimal calculations such as time. In just intonation, which is one of the scales used for tuning musical instruments, the ratio of the frequencies of the sounds is a sequence of humming numbers of 24, 27, 30, 32, 36, 40, 45, 48.
Create a program that takes integers m and n as inputs and outputs the number of humming numbers that are m or more and n or less.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros.
For each dataset, two integers m and n (1 ≤ m, n ≤ 1000000, m ≤ n) are given on one line, separated by blanks.
The number of datasets does not exceed 20.
Output
Outputs the number of humming numbers from m to n for each data set on one line.
Example
Input
3 8
1 27
1 86
0
Output
5
17
31 | ```python
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0162
"""
import sys
from sys import stdin
from bisect import bisect_right, bisect_left
from math import ceil, log
input = stdin.readline
def main(args):
hammings = []
temp = set()
for i in range(ceil(log(1e6, 2)) + 1):
for j in range(ceil(log(1e6, 3)) + 1):
for k in range(ceil(log(1e6, 5)) + 1):
ans = 2**i * 3**j * 5**k
temp.add(ans)
hammings = list(temp)
hammings.sort()
while True:
try:
m, n = map(int, input().split(' '))
except ValueError:
break
s = bisect_left(hammings, m)
t = bisect_right(hammings, n)
print(t - s)
if __name__ == '__main__':
main(sys.argv[1:])
``` |
p00489 Soccer | problem
Soccer is popular in JOI, and a league match called the JOI League is held every week.
There are N teams in the JOI league, numbered from 1 to N. All combinations of matches are played exactly once. In other words, N × (N -1) / 2 games are played. The outcome of each match is determined by the score of each team. The winning team has 3 points and the losing team has 0 points. In the case of a draw, both teams have one point. The ranking is determined by the total points earned by each team, and the difference in points is not considered. Teams with the same total points will be ranked higher.
As an example, consider a league match with four teams. 4 × (4-1) / 2 = 6 Matches will be played. Suppose those results are as shown in the table below. The left side of the hyphen is the score of the team next to it, and the right side is the score of the team vertically.
Team 1 | Team 2 | Team 3 | Team 4 | Wins | Loss | Draws | Points
--- | --- | --- | --- | --- | --- | --- | --- | ---
Team 1 | --- | 0 --1 | 2 --1 | 2 --2 | 1 | 1 | 1 | 4
Team 2 | 1 --0 | --- | 1 --1 | 3 --0 | 2 | 0 | 1 | 7
Team 3 | 1 --2 | 1 --1 | --- | 1 --3 | 0 | 2 | 1 | 1
Team 4 | 2 --2 | 0 --3 | 3 --1 | --- | 1 | 1 | 1 | 4
At this time, Team 2 with the most points is in first place. The teams with the next most points are Team 1 and Team 4, and both teams are in second place. Team 3 with the fewest points is in 4th place.
Create a program to find the ranking of each team given the results of all matches.
input
The number of teams N (2 ≤ N ≤ 100) is written on the first line of the input file. The following N × (N -1) / 2 lines describe the results of each match. The integers Ai, Bi, Ci, Di (1 ≤ Ai ≤ N, 1 ≤ Bi ≤ N, 0 ≤ Ci ≤ 100, 0) are in the first line (1 ≤ i ≤ N x (N-1) / 2). ≤ Di ≤ 100) is written with a blank as a delimiter, indicating that Team Ai and Team Bi played against each other, and Team Ai scored Ci points and Team Bi scored Di points. Ai ≠ Bi for all i, and the same combination of matches is never written.
output
The output consists of N lines. Each row consists of one integer, and the integer on the i-th row (1 ≤ i ≤ N) represents the rank of team i.
Input / output example
Input example 1
Four
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output example 1
2
1
Four
2
Input / output example 1 corresponds to the example in the problem statement.
Input example 2
Five
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1
Output example 2
2
Four
1
Four
3
The results of input / output example 2 are as follows.
| Wins | Loss | Draws | Points
--- | --- | --- | --- | ---
Team 1 | 2 | 1 | 1 | 7
Team 2 | 0 | 1 | 3 | 3
Team 3 | 3 | 0 | 1 | 10
Team 4 | 1 | 3 | 0 | 3
Team 5 | 1 | 2 | 1 | 4
The question text and the data used for the automatic referee are the question text and the test data for scoring, which are created and published by the Japan Committee for Information Olympics.
Example
Input
4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3
Output
2
1
4
2 | ```python
n = int(input())
score = [list(map(lambda x: int(x) - 1 , input().split())) for _ in range(int(n*(n-1)/2))]
points = [0 for _ in range(n)]
for a,b,c,d in score:
if c > d:
points[a] += 3
elif c < d:
points[b] += 3
else:
points[a] += 1
points[b] += 1
rank = sorted(points)
rank.reverse()
for p in points:
print(rank.index(p) + 1)
``` |
p00949 Hidden Anagrams | Example
Input
anagram
grandmother
Output
4 | ```python
s1 = input()
s2 = input()
cA = ord('a')
s1 = [ord(e) - cA for e in s1]
l1 = len(s1)
s2 = [ord(e) - cA for e in s2]
l2 = len(s2)
ans = 0
for l in range(1, min(l1, l2)+1):
s = set()
use = [0]*26
for i in range(l-1):
use[s1[i]] += 1
for i in range(l-1, l1):
use[s1[i]] += 1
s.add(tuple(use))
use[s1[i-l+1]] -= 1
cnt = [0]*26
for i in range(l-1):
cnt[s2[i]] += 1
for i in range(l-1, l2):
cnt[s2[i]] += 1
if tuple(cnt) in s:
ans = l
break
cnt[s2[i-l+1]] -= 1
print(ans)
``` |
p01352 Graph Construction | There are n rabbits, one in each of the huts numbered 0 through n − 1.
At one point, information came to the rabbits that a secret organization would be constructing an underground passage. The underground passage would allow the rabbits to visit other rabbits' huts. I'm happy.
The passages can go in both directions, and the passages do not intersect. Due to various circumstances, the passage once constructed may be destroyed. The construction and destruction of the passages are carried out one by one, and each construction It is assumed that the rabbit stays in his hut.
Rabbits want to know in advance if one rabbit and one rabbit can play at some stage of construction. Rabbits are good friends, so they are free to go through other rabbit huts when they go out to play. Rabbits who like programming tried to solve a similar problem in the past, thinking that it would be easy, but they couldn't write an efficient program. Solve this problem instead of the rabbit.
Input
The first line of input is given n and k separated by spaces. 2 ≤ n ≤ 40 000, 1 ≤ k ≤ 40 000
In the following k lines, construction information and questions are combined and given in chronological order.
* “1 u v” — A passage connecting huts u and v is constructed. Appears only when there is no passage connecting huts u and v.
* “2 u v” — The passage connecting huts u and v is destroyed. Appears only when there is a passage connecting huts u and v.
* “3 u v” — Determine if the rabbits in the hut u and v can be played.
0 ≤ u <v <n
Output
For each question that appears in the input, output "YES" if you can play, or "NO" if not.
Example
Input
4 10
1 0 1
1 0 2
3 1 2
2 0 1
1 2 3
3 0 1
1 0 1
2 0 2
1 1 3
3 0 2
Output
YES
NO
YES | ```python
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, K = map(int, readline().split())
ES = [list(map(int, readline().split())) for i in range(K)]
emp = {}
sq = int(K**.5) + 1
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
que = deque()
used = [0]*N
lb = 0
p = [0]*N
for i in range(sq):
s = set()
for j in range(i*sq, min(i*sq+sq, K)):
t, a, b = ES[j]
if t == 3:
continue
e = (a, b)
if emp.get(e, 0):
s.add(e)
emp[e] = 0
p[:] = range(N)
for (v, w), d in emp.items():
if d == 1:
unite(v, w)
G0 = [[] for i in range(N)]
emp0 = {}
for a, b in s:
pa = root(a); pb = root(b)
if pa == pb:
continue
e = (pa, pb) if pa < pb else (pb, pa)
if e in emp0:
e1, e2 = emp0[e]
e1[1] = e2[1] = e1[1] + 1
else:
e1 = [pb, 1]; e2 = [pa, 1]
G0[pa].append(e1)
G0[pb].append(e2)
emp0[e] = e1, e2
for j in range(i*sq, min(i*sq+sq, K)):
t, a, b = ES[j]
pa = root(a); pb = root(b)
e = (pa, pb) if pa < pb else (pb, pa)
if t == 1:
emp[a, b] = 1
if pa == pb:
continue
if e not in emp0:
e1 = [pb, 1]; e2 = [pa, 1]
G0[pa].append(e1)
G0[pb].append(e2)
emp0[e] = e1, e2
else:
e1, e2 = emp0[e]
e1[1] = e2[1] = e1[1] + 1
elif t == 2:
emp[a, b] = 0
if pa == pb:
continue
e1, e2 = emp0[e]
e1[1] = e2[1] = e1[1] - 1
elif t == 3:
if pa == pb:
write("YES\n")
else:
lb += 1
que.append(pa)
used[pa] = lb
while que:
v = que.popleft()
for w, d in G0[v]:
if d and used[w] != lb:
used[w] = lb
que.append(w)
if used[pb] == lb:
write("YES\n")
else:
write("NO\n")
solve()
``` |
p01534 Anipero 2012 | D: Anipero 2012
Anipero Summer Live, commonly known as Anipero, is the largest anime song live event in Japan where various anime song artists gather. 2D, who loves anime songs, decided to go to Anipero this year as well as last year.
He has already purchased m of psyllium to enjoy Anipero. Psyllium is a stick that glows in a chemical reaction when folded. By shaking the psyllium in time with the rhythm, you can liven up the live performance and increase your satisfaction. All the psylliums he purchased this time have the following properties.
* The psyllium becomes darker as time passes after it is folded, and loses its light in 10 minutes.
* Very bright for 5 minutes after folding (hereinafter referred to as "level 2").
* It will be a little dark 5 minutes after folding (hereinafter referred to as "level 1").
* The speed at which light is lost does not change whether it is shaken or not.
2D decided to consider the following problems as to how satisfied he would be with this year's Anipero by properly using the limited psyllium depending on the song.
He anticipates n songs that will be played during the live. The length of each song is 5 minutes. n songs continue to flow, and the interval between songs can be considered as 0 minutes. The following three parameters are given to each song.
* Satisfaction that increases when only one level 2 is shaken for a certain song
* Satisfaction that increases when only one level 1 is shaken for a certain song
* Satisfaction increases when no song is shaken in a certain song
Shaking the glow stick does not necessarily increase satisfaction. If you shake it, it may disturb the atmosphere of the venue and reduce your satisfaction. The same can be said when not shaking.
Psyllium must be used according to the following rules.
* You can fold only when the song starts, and you can fold as many as you like at one time. The time it takes to fold the psyllium can be ignored.
* Up to 8 songs can be played at the same time in one song.
* When shaking multiple psylliums, calculate the satisfaction level to be added by the following formula.
* (Number of Level 1) x (Satisfaction per level 1) + (Number of Level 2) x (Satisfaction per Level 2)
* If no psyllium is shaken, only the satisfaction level when no one is shaken is added.
* Once you decide to shake the psyllium, you cannot change it until the end of one song.
* The psyllium can be left unshaken. Also, it is not necessary to use up all the psyllium.
2D had finished predicting the live song, but he was tired of it and didn't feel like solving the problem. Your job is to write a program for him that seeks the maximum satisfaction you're likely to get at this year's live concert.
Input
Satisfaction information for the expected song list of the live is input.
On the first line, the number of songs n (1 <= n <= 50) sung live and the number m (0 <= m <= 50) of new psyllium that 2D has at the start of the live are separated by spaces. Is entered in. In the following n lines, the information of one song is input line by line. The i-th (1 <= i <= n) song information is
* Satisfaction level when one level 2 psyllium is shaken for song i ai
* Satisfaction level bi when swinging one level 1 psyllium for song i
* Satisfaction ci when no psyllium is shaken in song i
Are entered separated by spaces (-100 <= ai, bi, ci <= 100).
Output
Output the prediction of 2D's maximum satisfaction at the end of the live in one line. Please note that the maximum satisfaction level may be negative. Output a line break at the end of the line.
Sample Input 1
1 5
2 3 8
Sample Output 1
Ten
Sample Input 2
2 10
2 2 20
2 3 -10
Sample Output 2
44
Sample Input 3
3 10
5 1 9
-3 2 1
1 11 0
Sample Output 3
102
Example
Input
1 5
2 3 8
Output
10 | ```python
INF = 10 ** 20
n, m = map(int, input().split())
dp = [[[-INF] * 9 for _ in range(m + 1)] for _ in range(n + 1)]
dp[0][m][0] = 0
for i in range(n):
a, b, c = map(int, input().split())
for rest in range(m + 1):
for l1 in range(9):
for l2 in range(min(9, rest + 1)):
if l1 == 0 and l2 == 0:add = c
elif l2 == 0:
if b <= 0:add = max(b, c)
else:add = max(b * l1, c)
elif l1 == 0:
if a <= 0:add = max(a, c)
else:add = max(a * l2, c)
else:
if a <= 0 and b <= 0:add = max(a, b, c)
elif a <= 0:add = max(b * l1, c)
elif b <= 0:add = max(a * l2, c)
elif a <= b:add = max(b * l1 + a * min(l2, 8 - l1), c)
else:add = max(a * l2 + b * min(l1, 8 - l2), c)
dp[i + 1][rest - l2][l2] = max(dp[i + 1][rest - l2][l2], dp[i][rest][l1] + add)
ans = -INF
for y in range(m + 1):
for x in range(9):
ans = max(ans, dp[n][y][x])
print(ans)
``` |
p02116 nCm | Problem
Given the integer n, output the smallest m such that nCm (the number of combinations that choose m out of n different ones) is even.
Constraints
The input satisfies the following conditions.
* 1 ≤ n ≤ 1018
Input
The input is given in the following format.
n
Output
Output the minimum m such that nCm is an even number on one line.
Examples
Input
2
Output
1
Input
111
Output
16
Input
3
Output
4 | ```python
n = int(input())
print((n+1) &- (n+1))
``` |
p02256 Greatest Common Divisor | Write a program which finds the greatest common divisor of two natural numbers a and b
Hint
You can use the following observation:
For integers x and y, if x ≥ y, then gcd(x, y) = gcd(y, x%y)
Constrants
1 ≤ a, b ≤ 109
Input
a and b are given in a line sparated by a single space.
Output
Output the greatest common divisor of a and b.
Examples
Input
54 20
Output
2
Input
147 105
Output
21 | ```python
import math
x,y = [int(x) for x in input().split()]
print(math.gcd(x,y))
``` |
p02404 Print a Frame | Draw a frame which has a height of H cm and a width of W cm. For example, the following figure shows a frame which has a height of 6 cm and a width of 10 cm.
........#
........#
........#
........#
Constraints
* 3 ≤ H ≤ 300
* 3 ≤ W ≤ 300
Input
The input consists of multiple datasets. Each dataset consists of two integers H and W separated by a single space.
The input ends with two 0 (when both H and W are zero).
Output
For each dataset, print the frame made of '#' and '.'.
Print a blank line after each dataset.
Example
Input
3 4
5 6
3 3
0 0
Output
####
#..#
####
######
#....#
#....#
#....#
######
###
#.#
### | ```python
while True:
h, w = [int(i) for i in input().split()]
if w == h == 0:
break
print("#" * w, end="")
print(("\n#" + "." * (w - 2) + "#") * (h - 2))
print("#" * w, end="\n\n")
``` |
1043_C. Smallest Word | IA has so many colorful magnets on her fridge! Exactly one letter is written on each magnet, 'a' or 'b'. She loves to play with them, placing all magnets in a row. However, the girl is quickly bored and usually thinks how to make her entertainment more interesting.
Today, when IA looked at the fridge, she noticed that the word formed by magnets is really messy. "It would look much better when I'll swap some of them!" — thought the girl — "but how to do it?". After a while, she got an idea. IA will look at all prefixes with lengths from 1 to the length of the word and for each prefix she will either reverse this prefix or leave it as it is. She will consider the prefixes in the fixed order: from the shortest to the largest. She wants to get the lexicographically smallest possible word after she considers all prefixes. Can you help her, telling which prefixes should be chosen for reversing?
A string a is lexicographically smaller than a string b if and only if one of the following holds:
* a is a prefix of b, but a ≠ b;
* in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b.
Input
The first and the only line contains a string s (1 ≤ |s| ≤ 1000), describing the initial string formed by magnets. The string s consists only of characters 'a' and 'b'.
Output
Output exactly |s| integers. If IA should reverse the i-th prefix (that is, the substring from 1 to i), the i-th integer should be equal to 1, and it should be equal to 0 otherwise.
If there are multiple possible sequences leading to the optimal answer, print any of them.
Examples
Input
bbab
Output
0 1 1 0
Input
aaaaa
Output
1 0 0 0 1
Note
In the first example, IA can reverse the second and the third prefix and get a string "abbb". She cannot get better result, since it is also lexicographically smallest string obtainable by permuting characters of the initial string.
In the second example, she can reverse any subset of prefixes — all letters are 'a'. | ```python
s = input()
arr_ans = [0] * len(s)
for i in range(1, len(s)):
if s[i] == 'a':
arr_ans[i - 1] = (arr_ans[i - 1] + 1) % 2
arr_ans[i] += 1
print(*arr_ans)
``` |
1066_A. Vova and Train | Vova plans to go to the conference by train. Initially, the train is at the point 1 and the destination point of the path is the point L. The speed of the train is 1 length unit per minute (i.e. at the first minute the train is at the point 1, at the second minute — at the point 2 and so on).
There are lanterns on the path. They are placed at the points with coordinates divisible by v (i.e. the first lantern is at the point v, the second is at the point 2v and so on).
There is also exactly one standing train which occupies all the points from l to r inclusive.
Vova can see the lantern at the point p if p is divisible by v and there is no standing train at this position (p not∈ [l; r]). Thus, if the point with the lantern is one of the points covered by the standing train, Vova can't see this lantern.
Your problem is to say the number of lanterns Vova will see during the path. Vova plans to go to t different conferences, so you should answer t independent queries.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of queries.
Then t lines follow. The i-th line contains four integers L_i, v_i, l_i, r_i (1 ≤ L, v ≤ 10^9, 1 ≤ l ≤ r ≤ L) — destination point of the i-th path, the period of the lantern appearance and the segment occupied by the standing train.
Output
Print t lines. The i-th line should contain one integer — the answer for the i-th query.
Example
Input
4
10 2 3 7
100 51 51 51
1234 1 100 199
1000000000 1 1 1000000000
Output
3
0
1134
0
Note
For the first example query, the answer is 3. There are lanterns at positions 2, 4, 6, 8 and 10, but Vova didn't see the lanterns at positions 4 and 6 because of the standing train.
For the second example query, the answer is 0 because the only lantern is at the point 51 and there is also a standing train at this point.
For the third example query, the answer is 1134 because there are 1234 lanterns, but Vova didn't see the lanterns from the position 100 to the position 199 inclusive.
For the fourth example query, the answer is 0 because the standing train covers the whole path. | ```python
if __name__ == '__main__':
t = input()
t = int(t)
while t:
e, v, l, r = input().split()
e = int(e)
v = int(v)
l = int(l)
r = int(r)
res = e//v
if l % v != 0:
st = l//v + 1
else:
st = l//v
en = r//v
print(res-(en-st+1))
t=t-1
``` |
1107_F. Vasya and Endless Credits | Vasya wants to buy himself a nice new car. Unfortunately, he lacks some money. Currently he has exactly 0 burles.
However, the local bank has n credit offers. Each offer can be described with three numbers a_i, b_i and k_i. Offers are numbered from 1 to n. If Vasya takes the i-th offer, then the bank gives him a_i burles at the beginning of the month and then Vasya pays bank b_i burles at the end of each month for the next k_i months (including the month he activated the offer). Vasya can take the offers any order he wants.
Each month Vasya can take no more than one credit offer. Also each credit offer can not be used more than once. Several credits can be active at the same time. It implies that Vasya pays bank the sum of b_i over all the i of active credits at the end of each month.
Vasya wants to buy a car in the middle of some month. He just takes all the money he currently has and buys the car of that exact price.
Vasya don't really care what he'll have to pay the bank back after he buys a car. He just goes out of the country on his car so that the bank can't find him anymore.
What is the maximum price that car can have?
Input
The first line contains one integer n (1 ≤ n ≤ 500) — the number of credit offers.
Each of the next n lines contains three integers a_i, b_i and k_i (1 ≤ a_i, b_i, k_i ≤ 10^9).
Output
Print one integer — the maximum price of the car.
Examples
Input
4
10 9 2
20 33 1
30 115 1
5 3 2
Output
32
Input
3
40 1 2
1000 1100 5
300 2 1
Output
1337
Note
In the first example, the following sequence of offers taken is optimal: 4 → 3.
The amount of burles Vasya has changes the following way: 5 → 32 → -86 → .... He takes the money he has in the middle of the second month (32 burles) and buys the car.
The negative amount of money means that Vasya has to pay the bank that amount of burles.
In the second example, the following sequence of offers taken is optimal: 3 → 1 → 2.
The amount of burles Vasya has changes the following way: 0 → 300 → 338 → 1337 → 236 → -866 → .... | ```python
n = int(input())
a = [tuple(map(int, input().split())) for i in range(n)]
a = [(y, x, k) for x, y, k in a]
a.sort(reverse=True)
dp = [[-1] * (n + 1) for i in range(n)]
def f(i, j):
if i < 0 or j < -1: return 0
if dp[i][j] == -1:
y, x, k = a[i]
dp[i][j] = f(i - 1, j) + max(0, x - k * y)
if 0 <= j < k: dp[i][j] = max(dp[i][j], x - j * y + f(i - 1, j - 1))
return dp[i][j]
print(max(f(n - 1, j) for j in range(-1, n)))
``` |
1137_A. Skyscrapers | Dora loves adventures quite a lot. During some journey she encountered an amazing city, which is formed by n streets along the Eastern direction and m streets across the Southern direction. Naturally, this city has nm intersections. At any intersection of i-th Eastern street and j-th Southern street there is a monumental skyscraper. Dora instantly became curious and decided to explore the heights of the city buildings.
When Dora passes through the intersection of the i-th Eastern and j-th Southern street she examines those two streets. After Dora learns the heights of all the skyscrapers on those two streets she wonders: how one should reassign heights to the skyscrapers on those two streets, so that the maximum height would be as small as possible and the result of comparing the heights of any two skyscrapers on one street wouldn't change.
Formally, on every of nm intersections Dora solves an independent problem. She sees n + m - 1 skyscrapers and for each of them she knows its real height. Moreover, any two heights can be compared to get a result "greater", "smaller" or "equal". Now Dora wants to select some integer x and assign every skyscraper a height from 1 to x. When assigning heights, Dora wants to preserve the relative order of the skyscrapers in both streets. That is, the result of any comparison of heights of two skyscrapers in the current Eastern street shouldn't change and the result of any comparison of heights of two skyscrapers in current Southern street shouldn't change as well. Note that skyscrapers located on the Southern street are not compared with skyscrapers located on the Eastern street only. However, the skyscraper located at the streets intersection can be compared with both Southern and Eastern skyscrapers. For every intersection Dora wants to independently calculate the minimum possible x.
For example, if the intersection and the two streets corresponding to it look as follows:
<image>
Then it is optimal to replace the heights of the skyscrapers as follows (note that all comparisons "less", "equal", "greater" inside the Eastern street and inside the Southern street are preserved)
<image>
The largest used number is 5, hence the answer for this intersection would be 5.
Help Dora to compute the answers for each intersection.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of streets going in the Eastern direction and the number of the streets going in Southern direction.
Each of the following n lines contains m integers a_{i,1}, a_{i,2}, ..., a_{i,m} (1 ≤ a_{i,j} ≤ 10^9). The integer a_{i,j}, located on j-th position in the i-th line denotes the height of the skyscraper at the intersection of the i-th Eastern street and j-th Southern direction.
Output
Print n lines containing m integers each. The integer x_{i,j}, located on j-th position inside the i-th line is an answer for the problem at the intersection of i-th Eastern street and j-th Southern street.
Examples
Input
2 3
1 2 1
2 1 2
Output
2 2 2
2 2 2
Input
2 2
1 2
3 4
Output
2 3
3 2
Note
In the first example, it's not possible to decrease the maximum used height for the problem at any intersection, hence we don't have to change any heights.
In the second example, the answers are as follows:
* For the intersection of the first line and the first column <image>
* For the intersection of the first line and the second column <image>
* For the intersection of the second line and the first column <image>
* For the intersection of the second line and the second column <image> | ```python
import sys
input=sys.stdin.buffer.readline
from bisect import bisect_left
n,m=map(int,input().split())
arr=[]
for i in range(n):
arr.append(list(map(int,input().split())))
arr_maxi=[[0 for i in range(m)] for j in range(n)]
arr_mini=[[0 for i in range(m)] for j in range(n)]
for i in range(n):
s=sorted(set(arr[i]))
for j in range(m):
indx=bisect_left(s,arr[i][j])
arr_maxi[i][j]=len(s)-indx-1
arr_mini[i][j]=indx
for j in range(m):
s=sorted(set([arr[i][j] for i in range(n)]))
for i in range(n):
indx=bisect_left(s,arr[i][j])
arr_maxi[i][j]=max(arr_maxi[i][j],len(s)-indx-1)
arr_mini[i][j] = max(arr_mini[i][j], indx)
for i in range(n):
for j in range(m):
print(arr_maxi[i][j] +arr_mini[i][j] +1,end=' ')
print()
``` |
1155_C. Alarm Clocks Everywhere | Ivan is going to sleep now and wants to set his alarm clock. There will be many necessary events tomorrow, the i-th of them will start during the x_i-th minute. Ivan doesn't want to skip any of the events, so he has to set his alarm clock in such a way that it rings during minutes x_1, x_2, ..., x_n, so he will be awake during each of these minutes (note that it does not matter if his alarm clock will ring during any other minute).
Ivan can choose two properties for the alarm clock — the first minute it will ring (let's denote it as y) and the interval between two consecutive signals (let's denote it by p). After the clock is set, it will ring during minutes y, y + p, y + 2p, y + 3p and so on.
Ivan can choose any minute as the first one, but he cannot choose any arbitrary value of p. He has to pick it among the given values p_1, p_2, ..., p_m (his phone does not support any other options for this setting).
So Ivan has to choose the first minute y when the alarm clock should start ringing and the interval between two consecutive signals p_j in such a way that it will ring during all given minutes x_1, x_2, ..., x_n (and it does not matter if his alarm clock will ring in any other minutes).
Your task is to tell the first minute y and the index j such that if Ivan sets his alarm clock with properties y and p_j it will ring during all given minutes x_1, x_2, ..., x_n or say that it is impossible to choose such values of the given properties. If there are multiple answers, you can print any.
Input
The first line of the input contains two integers n and m (2 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ m ≤ 3 ⋅ 10^5) — the number of events and the number of possible settings for the interval between signals.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^{18}), where x_i is the minute when i-th event starts. It is guaranteed that all x_i are given in increasing order (i. e. the condition x_1 < x_2 < ... < x_n holds).
The third line of the input contains m integers p_1, p_2, ..., p_m (1 ≤ p_j ≤ 10^{18}), where p_j is the j-th option for the interval between two consecutive signals.
Output
If it's impossible to choose such values y and j so all constraints are satisfied, print "NO" in the first line.
Otherwise print "YES" in the first line. Then print two integers y (1 ≤ y ≤ 10^{18}) and j (1 ≤ j ≤ m) in the second line, where y is the first minute Ivan's alarm clock should start ringing and j is the index of the option for the interval between two consecutive signals (options are numbered from 1 to m in the order they are given input). These values should be chosen in such a way that the alarm clock will ring during all given minutes x_1, x_2, ..., x_n. If there are multiple answers, you can print any.
Examples
Input
3 5
3 12 18
2 6 5 3 3
Output
YES
3 4
Input
4 2
1 5 17 19
4 5
Output
NO
Input
4 2
1 5 17 19
2 1
Output
YES
1 1 | ```python
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
n, m = map(int, input().split(' '))
x = list(map(int, input().split(' ')))
p = list(map(int, input().split(' ')))
dx = [x[i+1]-x[i] for i in range(n-1)]
d = dx[0]
for i in dx:
d = gcd(i, d)
for i in range(m):
if d % p[i] == 0:
print('YES')
print(x[0], i+1)
exit()
print('NO')
``` |
1177_B. Digits Sequence (Hard Edition) | Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10^{12}) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5 | ```python
#import sys
#digit = int(sys.argv[1])
digit = int(input())
if int(digit) <= 9:
print(digit)
exit()
start_range = 1
end_range = 9
power = 1
digit_count = 2
while not (start_range <= digit and digit <= end_range):
start_range = end_range + 1
end_range = 9 * 10**power * digit_count + start_range - 1
power += 1
digit_count += 1
offset_number = (digit - start_range) // (digit_count - 1)
#print(f"{digit} - {start_range} mod {digit_count-1} = {offset_number}")
number = str(10**(power - 1) + offset_number)
#print(f"10^ {power - 1} + {offset_number} = {number}")
offset_digit = (digit - start_range) % (digit_count - 1)
#print(f"{digit} - {start_range} mod {digit_count - 1 } = {offset_digit}")
#print(f"{number} {number[-offset_digit]}")
print(f"{number[offset_digit]}")
``` |
1213_B. Bad Prices | Polycarp analyzes the prices of the new berPhone. At his disposal are the prices for n last days: a_1, a_2, ..., a_n, where a_i is the price of berPhone on the day i.
Polycarp considers the price on the day i to be bad if later (that is, a day with a greater number) berPhone was sold at a lower price. For example, if n=6 and a=[3, 9, 4, 6, 7, 5], then the number of days with a bad price is 3 — these are days 2 (a_2=9), 4 (a_4=6) and 5 (a_5=7).
Print the number of days with a bad price.
You have to answer t independent data sets.
Input
The first line contains an integer t (1 ≤ t ≤ 10000) — the number of sets of input data in the test. Input data sets must be processed independently, one after another.
Each input data set consists of two lines. The first line contains an integer n (1 ≤ n ≤ 150000) — the number of days. The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6), where a_i is the price on the i-th day.
It is guaranteed that the sum of n over all data sets in the test does not exceed 150000.
Output
Print t integers, the j-th of which should be equal to the number of days with a bad price in the j-th input data set.
Example
Input
5
6
3 9 4 6 7 5
1
1000000
2
2 1
10
31 41 59 26 53 58 97 93 23 84
7
3 2 1 2 3 4 5
Output
3
0
1
8
2 | ```python
for _ in range(int(input())):
n = int(input())
lst = list(map(int, input().split()))
cnt = 0
x = lst[-1]
for i in lst[:-1][::-1]:
x = min((x, i))
if x < i:
cnt += 1
print(cnt)
``` |
1236_C. Labs | In order to do some research, n^2 labs are built on different heights of a mountain. Let's enumerate them with integers from 1 to n^2, such that the lab with the number 1 is at the lowest place, the lab with the number 2 is at the second-lowest place, …, the lab with the number n^2 is at the highest place.
To transport water between the labs, pipes are built between every pair of labs. A pipe can transport at most one unit of water at a time from the lab with the number u to the lab with the number v if u > v.
Now the labs need to be divided into n groups, each group should contain exactly n labs. The labs from different groups can transport water to each other. The sum of units of water that can be sent from a group A to a group B is equal to the number of pairs of labs (u, v) such that the lab with the number u is from the group A, the lab with the number v is from the group B and u > v. Let's denote this value as f(A,B) (i.e. f(A,B) is the sum of units of water that can be sent from a group A to a group B).
For example, if n=3 and there are 3 groups X, Y and Z: X = \{1, 5, 6\}, Y = \{2, 4, 9\} and Z = \{3, 7, 8\}. In this case, the values of f are equal to:
* f(X,Y)=4 because of 5 → 2, 5 → 4, 6 → 2, 6 → 4,
* f(X,Z)=2 because of 5 → 3, 6 → 3,
* f(Y,X)=5 because of 2 → 1, 4 → 1, 9 → 1, 9 → 5, 9 → 6,
* f(Y,Z)=4 because of 4 → 3, 9 → 3, 9 → 7, 9 → 8,
* f(Z,X)=7 because of 3 → 1, 7 → 1, 7 → 5, 7 → 6, 8 → 1, 8 → 5, 8 → 6,
* f(Z,Y)=5 because of 3 → 2, 7 → 2, 7 → 4, 8 → 2, 8 → 4.
Please, divide labs into n groups with size n, such that the value min f(A,B) over all possible pairs of groups A and B (A ≠ B) is maximal.
In other words, divide labs into n groups with size n, such that minimum number of the sum of units of water that can be transported from a group A to a group B for every pair of different groups A and B (A ≠ B) as big as possible.
Note, that the example above doesn't demonstrate an optimal division, but it demonstrates how to calculate the values f for some division.
If there are many optimal divisions, you can find any.
Input
The only line contains one number n (2 ≤ n ≤ 300).
Output
Output n lines:
In the i-th line print n numbers, the numbers of labs of the i-th group, in any order you want.
If there are multiple answers, that maximize the minimum number of the sum of units of water that can be transported from one group the another, you can print any.
Example
Input
3
Output
2 8 5
9 3 4
7 6 1
Note
In the first test we can divide 9 labs into groups \{2, 8, 5\}, \{9, 3, 4\}, \{7, 6, 1\}.
From the first group to the second group we can transport 4 units of water (8 → 3, 8 → 4, 5 → 3, 5 → 4).
From the first group to the third group we can transport 5 units of water (2 → 1, 8 → 7, 8 → 6, 8 → 1, 5 → 1).
From the second group to the first group we can transport 5 units of water (9 → 2, 9 → 8, 9 → 5, 3 → 2, 4 → 2).
From the second group to the third group we can transport 5 units of water (9 → 7, 9 → 6, 9 → 1, 3 → 1, 4 → 1).
From the third group to the first group we can transport 4 units of water (7 → 2, 7 → 5, 6 → 2, 6 → 5).
From the third group to the second group we can transport 4 units of water (7 → 3, 7 → 4, 6 → 3, 6 → 4).
The minimal number of the sum of units of water, that can be transported from one group to another is equal to 4. It can be proved, that it is impossible to make a better division. | ```python
n = int(input())
a = [[] for i in range(n)]
j = 0
k = 1
cnt = 0
for i in range(n):
for j in range(n):
cnt += 1
if (i % 2 == 0):
a[j].append(cnt)
else:
a[-j-1].append(cnt)
for i in range(n):
print(*a[i])
``` |
1254_B1. Send Boxes to Alice (Easy Version) | This is the easier version of the problem. In this version, 1 ≤ n ≤ 10^5 and 0 ≤ a_i ≤ 1. You can hack this problem only if you solve and lock both problems.
Christmas is coming, and our protagonist, Bob, is preparing a spectacular present for his long-time best friend Alice. This year, he decides to prepare n boxes of chocolate, numbered from 1 to n. Initially, the i-th box contains a_i chocolate pieces.
Since Bob is a typical nice guy, he will not send Alice n empty boxes. In other words, at least one of a_1, a_2, …, a_n is positive. Since Alice dislikes coprime sets, she will be happy only if there exists some integer k > 1 such that the number of pieces in each box is divisible by k. Note that Alice won't mind if there exists some empty boxes.
Charlie, Alice's boyfriend, also is Bob's second best friend, so he decides to help Bob by rearranging the chocolate pieces. In one second, Charlie can pick up a piece in box i and put it into either box i-1 or box i+1 (if such boxes exist). Of course, he wants to help his friend as quickly as possible. Therefore, he asks you to calculate the minimum number of seconds he would need to make Alice happy.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of chocolate boxes.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 1) — the number of chocolate pieces in the i-th box.
It is guaranteed that at least one of a_1, a_2, …, a_n is positive.
Output
If there is no way for Charlie to make Alice happy, print -1.
Otherwise, print a single integer x — the minimum number of seconds for Charlie to help Bob make Alice happy.
Examples
Input
3
1 0 1
Output
2
Input
1
1
Output
-1 | ```python
from sys import stdin,stdout
from math import gcd,sqrt,factorial,pi,inf
from collections import deque,defaultdict
from bisect import bisect,bisect_left
from time import time
from itertools import permutations as per
from heapq import heapify,heappush,heappop,heappushpop
input=stdin.readline
R=lambda:map(int,input().split())
I=lambda:int(input())
S=lambda:input().rstrip('\r\n')
L=lambda:list(R())
P=lambda x:stdout.write(str(x)+'\n')
lcm=lambda x,y:(x*y)//gcd(x,y)
nCr=lambda x,y:(f[x]*inv((f[y]*f[x-y])%N))%N
inv=lambda x:pow(x,N-2,N)
sm=lambda x:(x**2+x)//2
N=10**9+7
def get_ans(x):
ans=0
for i in range(p):
#print(i+(x-(i+1)%x)%x-x//2)
ans+=abs(ind[i+(x-(i+1)%x)%x-x//2]-ind[i])
return ans
n=I()
a=L()
p=cnt=a.count(1)
if cnt==1:exit(print(-1))
ans=inf
ind=[i for i in range(n) if a[i]]
for i in range(2,int(sqrt(cnt))+1):
if not cnt%i:
ans=min(ans,get_ans(i))
while not cnt%i:
cnt//=i
if cnt!=1:ans=min(ans,get_ans(cnt))
print(ans)
``` |
1278_A. Shuffle Hashing | Polycarp has built his own web service. Being a modern web service it includes login feature. And that always implies password security problems.
Polycarp decided to store the hash of the password, generated by the following algorithm:
1. take the password p, consisting of lowercase Latin letters, and shuffle the letters randomly in it to obtain p' (p' can still be equal to p);
2. generate two random strings, consisting of lowercase Latin letters, s_1 and s_2 (any of these strings can be empty);
3. the resulting hash h = s_1 + p' + s_2, where addition is string concatenation.
For example, let the password p = "abacaba". Then p' can be equal to "aabcaab". Random strings s1 = "zyx" and s2 = "kjh". Then h = "zyxaabcaabkjh".
Note that no letters could be deleted or added to p to obtain p', only the order could be changed.
Now Polycarp asks you to help him to implement the password check module. Given the password p and the hash h, check that h can be the hash for the password p.
Your program should answer t independent test cases.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases.
The first line of each test case contains a non-empty string p, consisting of lowercase Latin letters. The length of p does not exceed 100.
The second line of each test case contains a non-empty string h, consisting of lowercase Latin letters. The length of h does not exceed 100.
Output
For each test case print the answer to it — "YES" if the given hash h could be obtained from the given password p or "NO" otherwise.
Example
Input
5
abacaba
zyxaabcaabkjh
onetwothree
threetwoone
one
zzonneyy
one
none
twenty
ten
Output
YES
YES
NO
YES
NO
Note
The first test case is explained in the statement.
In the second test case both s_1 and s_2 are empty and p'= "threetwoone" is p shuffled.
In the third test case the hash could not be obtained from the password.
In the fourth test case s_1= "n", s_2 is empty and p'= "one" is p shuffled (even thought it stayed the same).
In the fifth test case the hash could not be obtained from the password. | ```python
t = int(input())
for _ in range(t):
s = input()
t = input()
ok = False
s = ''.join(sorted(s))
for i in range(len(t) - len(s) + 1):
temp = ''.join(sorted(t[i:i+len(s)]))
if temp == s:
ok = True
break
if ok:
print("YES")
else:
print("NO")
``` |
1321_B. 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
from sys import stdin, gettrace
if not gettrace():
def input():
return next(stdin)[:-1]
def main():
n = int(input())
bb = [int(a) for a in input().split()]
seq = {}
for i, b in enumerate(bb):
if b - i in seq:
seq[b-i] += b
else:
seq[b-i] = b
print(max(seq.values()))
if __name__ == "__main__":
main()
``` |
1340_A. Nastya and Strange Generator | Denis was very sad after Nastya rejected him. So he decided to walk through the gateways to have some fun. And luck smiled at him! When he entered the first courtyard, he met a strange man who was selling something.
Denis bought a mysterious item and it was... Random permutation generator! Denis could not believed his luck.
When he arrived home, he began to study how his generator works and learned the algorithm. The process of generating a permutation consists of n steps. At the i-th step, a place is chosen for the number i (1 ≤ i ≤ n). The position for the number i is defined as follows:
* For all j from 1 to n, we calculate r_j — the minimum index such that j ≤ r_j ≤ n, and the position r_j is not yet occupied in the permutation. If there are no such positions, then we assume that the value of r_j is not defined.
* For all t from 1 to n, we calculate count_t — the number of positions 1 ≤ j ≤ n such that r_j is defined and r_j = t.
* Consider the positions that are still not occupied by permutation and among those we consider the positions for which the value in the count array is maximum.
* The generator selects one of these positions for the number i. The generator can choose any position.
Let's have a look at the operation of the algorithm in the following example:
<image>
Let n = 5 and the algorithm has already arranged the numbers 1, 2, 3 in the permutation. Consider how the generator will choose a position for the number 4:
* The values of r will be r = [3, 3, 3, 4, ×], where × means an indefinite value.
* Then the count values will be count = [0, 0, 3, 1, 0].
* There are only two unoccupied positions in the permutation: 3 and 4. The value in the count array for position 3 is 3, for position 4 it is 1.
* The maximum value is reached only for position 3, so the algorithm will uniquely select this position for number 4.
Satisfied with his purchase, Denis went home. For several days without a break, he generated permutations. He believes that he can come up with random permutations no worse than a generator. After that, he wrote out the first permutation that came to mind p_1, p_2, …, p_n and decided to find out if it could be obtained as a result of the generator.
Unfortunately, this task was too difficult for him, and he asked you for help. It is necessary to define whether the written permutation could be obtained using the described algorithm if the generator always selects the position Denis needs.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases. Then the descriptions of the test cases follow.
The first line of the test case contains a single integer n (1 ≤ n ≤ 10^5) — the size of the permutation.
The second line of the test case contains n different integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n) — the permutation written by Denis.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
Print "Yes" if this permutation could be obtained as a result of the generator. Otherwise, print "No".
All letters can be displayed in any case.
Example
Input
5
5
2 3 4 5 1
1
1
3
1 3 2
4
4 2 3 1
5
1 5 2 4 3
Output
Yes
Yes
No
Yes
No
Note
Let's simulate the operation of the generator in the first test.
At the 1 step, r = [1, 2, 3, 4, 5], count = [1, 1, 1, 1, 1]. The maximum value is reached in any free position, so the generator can choose a random position from 1 to 5. In our example, it chose 5.
At the 2 step, r = [1, 2, 3, 4, ×], count = [1, 1, 1, 1, 0]. The maximum value is reached in positions from 1 to 4, so the generator can choose a random position among them. In our example, it chose 1.
At the 3 step, r = [2, 2, 3, 4, ×], count = [0, 2, 1, 1, 0]. The maximum value is 2 and is reached only at the 2 position, so the generator will choose this position.
At the 4 step, r = [3, 3, 3, 4, ×], count = [0, 0, 3, 1, 0]. The maximum value is 3 and is reached only at the 3 position, so the generator will choose this position.
At the 5 step, r = [4, 4, 4, 4, ×], count = [0, 0, 0, 4, 0]. The maximum value is 4 and is reached only at the 4 position, so the generator will choose this position.
In total, we got a permutation of 2, 3, 4, 5, 1, that is, a generator could generate it. | ```python
t=int(input())
for pp in range(0,t):
n=int(input())
arr=list(map(int,input().split()))
arr.append(-1)
pt1=0
pt2=0
while(pt1!=n):
ele=arr[pt1]
if(ele==-1):
break
for i in range(pt1+1,n+1):
if(arr[i]-ele==1):
pt2=i
ele=arr[i]
else:
for j in range(pt1,pt2+1):
arr[j]=ele
break
pt1=pt2+1
pt2=pt1
ip=[]
dct={}
for i in arr:
if(i!=-1):
if i not in dct:
ip.append(i)
dct[i]=1
pi=[]
for i in ip:
pi.append(i)
pi.sort(reverse=True)
if(pi==ip):
print("Yes")
else:
print("No")
``` |
1362_A. Johnny and Ancient Computer | Johnny has recently found an ancient, broken computer. The machine has only one register, which allows one to put in there one variable. Then in one operation, you can shift its bits left or right by at most three positions. The right shift is forbidden if it cuts off some ones. So, in fact, in one operation, you can multiply or divide your number by 2, 4 or 8, and division is only allowed if the number is divisible by the chosen divisor.
Formally, if the register contains a positive integer x, in one operation it can be replaced by one of the following:
* x ⋅ 2
* x ⋅ 4
* x ⋅ 8
* x / 2, if x is divisible by 2
* x / 4, if x is divisible by 4
* x / 8, if x is divisible by 8
For example, if x = 6, in one operation it can be replaced by 12, 24, 48 or 3. Value 6 isn't divisible by 4 or 8, so there're only four variants of replacement.
Now Johnny wonders how many operations he needs to perform if he puts a in the register and wants to get b at the end.
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. The following t lines contain a description of test cases.
The first and only line in each test case contains integers a and b (1 ≤ a, b ≤ 10^{18}) — the initial and target value of the variable, respectively.
Output
Output t lines, each line should contain one integer denoting the minimum number of operations Johnny needs to perform. If Johnny cannot get b at the end, then write -1.
Example
Input
10
10 5
11 44
17 21
1 1
96 3
2 128
1001 1100611139403776
1000000000000000000 1000000000000000000
7 1
10 8
Output
1
1
-1
0
2
2
14
0
-1
-1
Note
In the first test case, Johnny can reach 5 from 10 by using the shift to the right by one (i.e. divide by 2).
In the second test case, Johnny can reach 44 from 11 by using the shift to the left by two (i.e. multiply by 4).
In the third test case, it is impossible for Johnny to reach 21 from 17.
In the fourth test case, initial and target values are equal, so Johnny has to do 0 operations.
In the fifth test case, Johnny can reach 3 from 96 by using two shifts to the right: one by 2, and another by 3 (i.e. divide by 4 and by 8). | ```python
# from debug import debug
import math
t = int(input())
for ii in range(t):
a, b = map(int, input().split())
if a == b:
print(0)
else:
b, a = min(a,b), max(a,b)
if a%b:
print(-1)
else:
aa = int(math.log2(a//b))
if pow(2, aa) == a//b:
c = 0
c += aa//3
aa = aa%3
c += aa//2
aa = aa%2
c += aa//1
aa = aa%1
print(c)
else:
print(-1)
``` |
1382_C1. Prefix Flip (Easy Version) | This is the easy 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 3n 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≤ 1000) — 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 1000.
Output
For each test case, output an integer k (0≤ k≤ 3n), 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
from collections import defaultdict as dd
import sys
input=sys.stdin.readline
t=int(input())
while t:
n=int(input())
#d=dd(int)
#n,m=map(int,input().split())
#l=list(map(int,input().split()))
a=list(map(int,input().strip()))
b=list(map(int,input().strip()))
j=n-1
ans=[]
while j>=0:
#print(j,a)
while j>=0 and b[j]==a[j]:
j-=1
if(j>=0 and a[0]==b[j]):
a[0]=1-a[0]
ans.append(1)
if(j%2==1):
k=j//2+1
else:
k=j//2
if(j>=0 and j%2==0):
a[j//2]=1-a[j//2]
for i in range(k):
a[i],a[j-i]=1-a[j-i],1-a[i]
if(j>=0):
ans.append(j+1)
j-=1
#print(a)
print(len(ans),*ans)
t-=1
``` |
1471_A. Strange Partition | You are given an array a of length n, and an integer x. You can perform the following operation as many times as you would like (possibly zero): replace two adjacent elements of the array by their sum. For example, if the initial array was [3, 6, 9], in a single operation one can replace the last two elements by their sum, yielding an array [3, 15], or replace the first two elements to get an array [9, 9]. Note that the size of the array decreases after each operation.
The beauty of an array b=[b_1, …, b_k] is defined as ∑_{i=1}^k \left⌈ (b_i)/(x) \right⌉, which means that we divide each element by x, round it up to the nearest integer, and sum up the resulting values. For example, if x = 3, and the array is [4, 11, 6], the beauty of the array is equal to \left⌈ 4/3 \right⌉ + \left⌈ 11/3 \right⌉ + \left⌈ 6/3 \right⌉ = 2 + 4 + 2 = 8.
Please determine the minimum and the maximum beauty you can get by performing some operations on the original array.
Input
The first input line contains a single integer t — the number of test cases (1 ≤ t ≤ 1000).
The first line of each test case contains two integers n and x (1 ≤ n ≤ 10^5, 1 ≤ x ≤ 10^9).
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9), the elements of the array a.
It is guaranteed that the sum of values of n over all test cases does not exceed 10^5.
Output
For each test case output two integers — the minimal and the maximal possible beauty.
Example
Input
2
3 3
3 6 9
3 3
6 4 11
Output
6 6
7 8
Note
In the first test case the beauty of the array does not change if we perform any operations.
In the second example we can leave the array unchanged to attain the maximum beauty, and to get the minimum beauty one can replace two elements 4 and 11 with their sum, yielding an array [6, 15], which has its beauty equal to 7. | ```python
from math import ceil
t = int(input())
for _ in range(t):
n,x = map(int,input().split())
a = list(map(int,input().split()))
mx = 0
mn = 0
for y in a:
mx += ceil(y/x)
mn += y
mn = ceil(mn/x)
print(mn,mx)
``` |
1498_A. GCD Sum | The \text{gcdSum} of a positive integer is the gcd of that integer with its sum of digits. Formally, \text{gcdSum}(x) = gcd(x, sum of digits of x) for a positive integer x. gcd(a, b) denotes the greatest common divisor of a and b — the largest integer d such that both integers a and b are divisible by d.
For example: \text{gcdSum}(762) = gcd(762, 7 + 6 + 2)=gcd(762,15) = 3.
Given an integer n, find the smallest integer x ≥ n such that \text{gcdSum}(x) > 1.
Input
The first line of input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
Then t lines follow, each containing a single integer n (1 ≤ n ≤ 10^{18}).
All test cases in one test are different.
Output
Output t lines, where the i-th line is a single integer containing the answer to the i-th test case.
Example
Input
3
11
31
75
Output
12
33
75
Note
Let us explain the three test cases in the sample.
Test case 1: n = 11:
\text{gcdSum}(11) = gcd(11, 1 + 1) = gcd(11,\ 2) = 1.
\text{gcdSum}(12) = gcd(12, 1 + 2) = gcd(12,\ 3) = 3.
So the smallest number ≥ 11 whose gcdSum > 1 is 12.
Test case 2: n = 31:
\text{gcdSum}(31) = gcd(31, 3 + 1) = gcd(31,\ 4) = 1.
\text{gcdSum}(32) = gcd(32, 3 + 2) = gcd(32,\ 5) = 1.
\text{gcdSum}(33) = gcd(33, 3 + 3) = gcd(33,\ 6) = 3.
So the smallest number ≥ 31 whose gcdSum > 1 is 33.
Test case 3: \ n = 75:
\text{gcdSum}(75) = gcd(75, 7 + 5) = gcd(75,\ 12) = 3.
The \text{gcdSum} of 75 is already > 1. Hence, it is the answer. | ```python
def gcd(a,b):
# Everything divides 0
if (b == 0):
return a
return gcd(b, a%b)
for i in range(int(input())):
n=int(input())
while(True):
l=list(str(n))
sum1=0
for i in l:
sum1+=int(i)
if(gcd(n,sum1)>1):
print(n)
break
n+=1
``` |
1547_E. Air Conditioners | On a strip of land of length n there are k air conditioners: the i-th air conditioner is placed in cell a_i (1 ≤ a_i ≤ n). Two or more air conditioners cannot be placed in the same cell (i.e. all a_i are distinct).
Each air conditioner is characterized by one parameter: temperature. The i-th air conditioner is set to the temperature t_i.
<image> Example of strip of length n=6, where k=2, a=[2,5] and t=[14,16].
For each cell i (1 ≤ i ≤ n) find it's temperature, that can be calculated by the formula $$$min_{1 ≤ j ≤ k}(t_j + |a_j - i|),$$$
where |a_j - i| denotes absolute value of the difference a_j - i.
In other words, the temperature in cell i is equal to the minimum among the temperatures of air conditioners, increased by the distance from it to the cell i.
Let's look at an example. Consider that n=6, k=2, the first air conditioner is placed in cell a_1=2 and is set to the temperature t_1=14 and the second air conditioner is placed in cell a_2=5 and is set to the temperature t_2=16. In that case temperatures in cells are:
1. temperature in cell 1 is: min(14 + |2 - 1|, 16 + |5 - 1|)=min(14 + 1, 16 + 4)=min(15, 20)=15;
2. temperature in cell 2 is: min(14 + |2 - 2|, 16 + |5 - 2|)=min(14 + 0, 16 + 3)=min(14, 19)=14;
3. temperature in cell 3 is: min(14 + |2 - 3|, 16 + |5 - 3|)=min(14 + 1, 16 + 2)=min(15, 18)=15;
4. temperature in cell 4 is: min(14 + |2 - 4|, 16 + |5 - 4|)=min(14 + 2, 16 + 1)=min(16, 17)=16;
5. temperature in cell 5 is: min(14 + |2 - 5|, 16 + |5 - 5|)=min(14 + 3, 16 + 0)=min(17, 16)=16;
6. temperature in cell 6 is: min(14 + |2 - 6|, 16 + |5 - 6|)=min(14 + 4, 16 + 1)=min(18, 17)=17.
For each cell from 1 to n find the temperature in it.
Input
The first line contains one integer q (1 ≤ q ≤ 10^4) — the number of test cases in the input. Then test cases follow. Before each test case, there is an empty line.
Each test case contains three lines. The first line contains two integers n (1 ≤ n ≤ 3 ⋅ 10^5) and k (1 ≤ k ≤ n) — the length of the strip of land and the number of air conditioners respectively.
The second line contains k integers a_1, a_2, …, a_k (1 ≤ a_i ≤ n) — positions of air conditioners on the strip of land.
The third line contains k integers t_1, t_2, …, t_k (1 ≤ t_i ≤ 10^9) — temperatures of air conditioners.
It is guaranteed that the sum of n over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output n integers separated by space: temperatures of air in cells.
Example
Input
5
6 2
2 5
14 16
10 1
7
30
5 5
3 1 4 2 5
3 1 4 2 5
7 1
1
1000000000
6 3
6 1 3
5 5 5
Output
15 14 15 16 16 17
36 35 34 33 32 31 30 31 32 33
1 2 3 4 5
1000000000 1000000001 1000000002 1000000003 1000000004 1000000005 1000000006
5 6 5 6 6 5 | ```python
def ii(): return int(input())
def si(): return input()
def mi(): return map(int,input().split())
def msi(): return map(str,input().split())
def li(): return list(mi())
t=ii()
for _ in range(t):
s=si()
n,k=mi()
a=li()
temp=li()
ac=[]
for i in range(k):
ac.append([a[i],temp[i]])
ac.sort()
btemp=temp.copy()
ldp,rdp=[0]*n,[0]*n
dp=[0]*n
#a.sort()
b=ac.copy()
ind=0;bind=k-1
mini=10**11;maxi=10**11
for i in range(n):
if ind<k:
if i+1==ac[ind][0]:
if ac[ind][1]-ac[ind][0]<mini:
mini=ac[ind][1]-ac[ind][0]
ind+=1
#ac.pop(0)
#temp.pop(0)
ldp[i]=mini+i+1
else:
ldp[i]=mini+i+1
else:
ldp[i]=mini+i+1
for i in range(n-1,-1,-1):
if bind>-1:
if i+1==b[bind][0]:
if b[bind][1]+b[bind][0]<maxi:
maxi=b[bind][1]+b[bind][0]
bind-=1
#b.pop()
#btemp.pop()
rdp[i]=maxi-i-1
else:
rdp[i]=maxi-i-1
else:
rdp[i]=maxi-i-1
for i in range(n):
dp[i]=min(ldp[i],rdp[i])
print(*dp)
``` |
175_B. Plane of Tanks: Pro | Vasya has been playing Plane of Tanks with his friends the whole year. Now it is time to divide the participants into several categories depending on their results.
A player is given a non-negative integer number of points in each round of the Plane of Tanks. Vasya wrote results for each round of the last year. He has n records in total.
In order to determine a player's category consider the best result obtained by the player and the best results of other players. The player belongs to category:
* "noob" — if more than 50% of players have better results;
* "random" — if his result is not worse than the result that 50% of players have, but more than 20% of players have better results;
* "average" — if his result is not worse than the result that 80% of players have, but more than 10% of players have better results;
* "hardcore" — if his result is not worse than the result that 90% of players have, but more than 1% of players have better results;
* "pro" — if his result is not worse than the result that 99% of players have.
When the percentage is calculated the player himself is taken into account. That means that if two players played the game and the first one gained 100 points and the second one 1000 points, then the first player's result is not worse than the result that 50% of players have, and the second one is not worse than the result that 100% of players have.
Vasya gave you the last year Plane of Tanks results. Help Vasya determine each player's category.
Input
The first line contains the only integer number n (1 ≤ n ≤ 1000) — a number of records with the players' results.
Each of the next n lines contains a player's name and the amount of points, obtained by the player for the round, separated with a space. The name contains not less than 1 and no more than 10 characters. The name consists of lowercase Latin letters only. It is guaranteed that any two different players have different names. The amount of points, obtained by the player for the round, is a non-negative integer number and does not exceed 1000.
Output
Print on the first line the number m — the number of players, who participated in one round at least.
Each one of the next m lines should contain a player name and a category he belongs to, separated with space. Category can be one of the following: "noob", "random", "average", "hardcore" or "pro" (without quotes). The name of each player should be printed only once. Player names with respective categories can be printed in an arbitrary order.
Examples
Input
5
vasya 100
vasya 200
artem 100
kolya 200
igor 250
Output
4
artem noob
igor pro
kolya random
vasya random
Input
3
vasya 200
kolya 1000
vasya 1000
Output
2
kolya pro
vasya pro
Note
In the first example the best result, obtained by artem is not worse than the result that 25% of players have (his own result), so he belongs to category "noob". vasya and kolya have best results not worse than the results that 75% players have (both of them and artem), so they belong to category "random". igor has best result not worse than the result that 100% of players have (all other players and himself), so he belongs to category "pro".
In the second example both players have the same amount of points, so they have results not worse than 100% players have, so they belong to category "pro". | ```python
from collections import defaultdict
from bisect import bisect_left
p, n = defaultdict(int), int(input())
for i in range(n):
a, b = input().split()
p[a] = max(p[a], int(b))
p, n = sorted((b, a) for a, b in p.items()), len(p)
t = [0] + [bisect_left(p, (p[n - 1 - n // k][0], '')) for k in [2, 5, 10, 100]] + [n]
s = ['noob', 'random', 'average', 'hardcore', 'pro']
for i in range(1, len(t)):
d = s[i - 1]
for j in range(t[i - 1], t[i]): p[j] = p[j][1] + ' ' + d
print(n)
print('\n'.join(p))
``` |
195_C. Try and Catch | Vasya is developing his own programming language VPL (Vasya Programming Language). Right now he is busy making the system of exceptions. He thinks that the system of exceptions must function like that.
The exceptions are processed by try-catch-blocks. There are two operators that work with the blocks:
1. The try operator. It opens a new try-catch-block.
2. The catch(<exception_type>, <message>) operator. It closes the try-catch-block that was started last and haven't yet been closed. This block can be activated only via exception of type <exception_type>. When we activate this block, the screen displays the <message>. If at the given moment there is no open try-catch-block, then we can't use the catch operator.
The exceptions can occur in the program in only one case: when we use the throw operator. The throw(<exception_type>) operator creates the exception of the given type.
Let's suggest that as a result of using some throw operator the program created an exception of type a. In this case a try-catch-block is activated, such that this block's try operator was described in the program earlier than the used throw operator. Also, this block's catch operator was given an exception type a as a parameter and this block's catch operator is described later that the used throw operator. If there are several such try-catch-blocks, then the system activates the block whose catch operator occurs earlier than others. If no try-catch-block was activated, then the screen displays message "Unhandled Exception".
To test the system, Vasya wrote a program that contains only try, catch and throw operators, one line contains no more than one operator, the whole program contains exactly one throw operator.
Your task is: given a program in VPL, determine, what message will be displayed on the screen.
Input
The first line contains a single integer: n (1 ≤ n ≤ 105) the number of lines in the program. Next n lines contain the program in language VPL. Each line contains no more than one operator. It means that input file can contain empty lines and lines, consisting only of spaces.
The program contains only operators try, catch and throw. It is guaranteed that the program is correct. It means that each started try-catch-block was closed, the catch operators aren't used unless there is an open try-catch-block. The program has exactly one throw operator. The program may have spaces at the beginning of a line, at the end of a line, before and after a bracket, a comma or a quote mark.
The exception type is a nonempty string, that consists only of upper and lower case english letters. The length of the string does not exceed 20 symbols. Message is a nonempty string, that consists only of upper and lower case english letters, digits and spaces. Message is surrounded with quote marks. Quote marks shouldn't be printed. The length of the string does not exceed 20 symbols.
Length of any line in the input file does not exceed 50 symbols.
Output
Print the message the screen will show after the given program is executed.
Examples
Input
8
try
try
throw ( AE )
catch ( BE, "BE in line 3")
try
catch(AE, "AE in line 5")
catch(AE,"AE somewhere")
Output
AE somewhere
Input
8
try
try
throw ( AE )
catch ( AE, "AE in line 3")
try
catch(BE, "BE in line 5")
catch(AE,"AE somewhere")
Output
AE in line 3
Input
8
try
try
throw ( CE )
catch ( BE, "BE in line 3")
try
catch(AE, "AE in line 5")
catch(AE,"AE somewhere")
Output
Unhandled Exception
Note
In the first sample there are 2 try-catch-blocks such that try operator is described earlier than throw operator and catch operator is described later than throw operator: try-catch(BE,"BE in line 3") and try-catch(AE,"AE somewhere"). Exception type is AE, so the second block will be activated, because operator catch(AE,"AE somewhere") has exception type AE as parameter and operator catch(BE,"BE in line 3") has exception type BE.
In the second sample there are 2 try-catch-blocks such that try operator is described earlier than throw operator and catch operator is described later than throw operator: try-catch(AE,"AE in line 3") and try-catch(AE,"AE somewhere"). Exception type is AE, so both blocks can be activated, but only the first one will be activated, because operator catch(AE,"AE in line 3") is described earlier than catch(AE,"AE somewhere")
In the third sample there is no blocks that can be activated by an exception of type CE. | ```python
import sys
import math
MAXNUM = math.inf
MINNUM = -1 * math.inf
ASCIILOWER = 97
ASCIIUPPER = 65
def getInt():
return int(sys.stdin.readline().rstrip())
def getInts():
return map(int, sys.stdin.readline().rstrip().split(" "))
def getString():
return sys.stdin.readline().rstrip()
def printOutput(ans):
sys.stdout.write()
pass
def solve(parsedprog):
stack = []
for op in parsedprog:
# print(stack)
# print(op)
if op and op[0] in ("try", "throw"):
stack.append(op)
elif op and op[0] == "catch":
k = stack.pop()
if k[0] == "throw":
if op[1] == k[1]:
return op[2]
else:
stack.append(k)
return "Unhandled Exception"
def multisplit(string):
"""splits at a bracket, comma, quote, or text"""
"""does not split within quotes."""
parsedstring = []
curstring = []
insidequotes = False
for i in string:
if insidequotes:
if i == '"':
insidequotes = False
parsedstring.append("".join(curstring))
curstring = []
else:
curstring.append(i)
elif i in ("(", ")", ",", " "):
if curstring:
parsedstring.append("".join(curstring))
curstring = []
elif i == '"':
insidequotes = True
if curstring:
parsedstring.append("".join(curstring))
curstring = []
else:
curstring.append(i)
if curstring:
parsedstring.append("".join(curstring))
return parsedstring
def readinput():
proglen = getInt()
parsedprog = []
for _ in range(proglen):
parsedprog.append(multisplit(getString()))
print(solve(parsedprog))
readinput()
``` |
219_C. Color Stripe | A colored stripe is represented by a horizontal row of n square cells, each cell is pained one of k colors. Your task is to repaint the minimum number of cells so that no two neighbouring cells are of the same color. You can use any color from 1 to k to repaint the cells.
Input
The first input line contains two integers n and k (1 ≤ n ≤ 5·105; 2 ≤ k ≤ 26). The second line contains n uppercase English letters. Letter "A" stands for the first color, letter "B" stands for the second color and so on. The first k English letters may be used. Each letter represents the color of the corresponding cell of the stripe.
Output
Print a single integer — the required minimum number of repaintings. In the second line print any possible variant of the repainted stripe.
Examples
Input
6 3
ABBACC
Output
2
ABCACA
Input
3 2
BBB
Output
1
BAB | ```python
n,k=map(int,input().split())
s=input()
if(k==2):
#A
sol1=[s[i] for i in range(n)]
ans1=0
for i in range(n):
if(i%2==0 and sol1[i]=="B"):
ans1+=1
sol1[i]="A"
elif(i%2!=0 and sol1[i]=="A"):
ans1+=1
sol1[i]="B"
#B
sol2=[s[i] for i in range(n)]
ans2=0
for i in range(n):
if(i%2==0 and sol2[i]=="A"):
ans2+=1
sol2[i]="B"
elif(i%2!=0 and sol2[i]=="B"):
ans2+=1
sol2[i]="A"
if(ans1<=ans2):
print(ans1)
print("".join(str(x) for x in sol1))
else:
print(ans2)
print("".join(str(x) for x in sol2))
else:
s=[s[i] for i in range(n)]
ans=0
for i in range(1,n):
if(s[i]==s[i-1]):
ans+=1
x=chr((ord(s[i-1])-65+1)%k+65)
if(i==n-1 or s[i+1]!=x):s[i]=x
else:
y=chr((ord(s[i-1])-65+1+1)%k+65)
s[i]=y
print(ans)
print("".join(str(x) for x in s))
``` |
268_C. Beautiful Sets of Points | Manao has invented a new mathematical term — a beautiful set of points. He calls a set of points on a plane beautiful if it meets the following conditions:
1. The coordinates of each point in the set are integers.
2. For any two points from the set, the distance between them is a non-integer.
Consider all points (x, y) which satisfy the inequations: 0 ≤ x ≤ n; 0 ≤ y ≤ m; x + y > 0. Choose their subset of maximum size such that it is also a beautiful set of points.
Input
The single line contains two space-separated integers n and m (1 ≤ n, m ≤ 100).
Output
In the first line print a single integer — the size k of the found beautiful set. In each of the next k lines print a pair of space-separated integers — the x- and y- coordinates, respectively, of a point from the set.
If there are several optimal solutions, you may print any of them.
Examples
Input
2 2
Output
3
0 1
1 2
2 0
Input
4 3
Output
4
0 3
2 1
3 0
4 2
Note
Consider the first sample. The distance between points (0, 1) and (1, 2) equals <image>, between (0, 1) and (2, 0) — <image>, between (1, 2) and (2, 0) — <image>. Thus, these points form a beautiful set. You cannot form a beautiful set with more than three points out of the given points. Note that this is not the only solution. | ```python
if __name__ == '__main__':
nums = input().split()
n = int(nums[0])
m = int(nums[1])
k = min(m, n) + 1
print(k)
for i in range(k):
print(str(i) + " " + str(k-1-i))
``` |
339_C. Xenia and Weights | Xenia has a set of weights and pan scales. Each weight has an integer weight from 1 to 10 kilos. Xenia is going to play with scales and weights a little. For this, she puts weights on the scalepans, one by one. The first weight goes on the left scalepan, the second weight goes on the right scalepan, the third one goes on the left scalepan, the fourth one goes on the right scalepan and so on. Xenia wants to put the total of m weights on the scalepans.
Simply putting weights on the scales is not interesting, so Xenia has set some rules. First, she does not put on the scales two consecutive weights of the same weight. That is, the weight that goes i-th should be different from the (i + 1)-th weight for any i (1 ≤ i < m). Second, every time Xenia puts a weight on some scalepan, she wants this scalepan to outweigh the other one. That is, the sum of the weights on the corresponding scalepan must be strictly greater than the sum on the other pan.
You are given all types of weights available for Xenia. You can assume that the girl has an infinite number of weights of each specified type. Your task is to help Xenia lay m weights on the scales or to say that it can't be done.
Input
The first line contains a string consisting of exactly ten zeroes and ones: the i-th (i ≥ 1) character in the line equals "1" if Xenia has i kilo weights, otherwise the character equals "0". The second line contains integer m (1 ≤ m ≤ 1000).
Output
In the first line print "YES", if there is a way to put m weights on the scales by all rules. Otherwise, print in the first line "NO". If you can put m weights on the scales, then print in the next line m integers — the weights' weights in the order you put them on the scales.
If there are multiple solutions, you can print any of them.
Examples
Input
0000000101
3
Output
YES
8 10 8
Input
1000000000
2
Output
NO | ```python
__author__ = 'ratnesh.mishra'
weights = map(int, input())
weights = [cnt for cnt, x in enumerate(weights, 1) if x]
m = int(input())
state = [(0, 0, 0, [])]
res = "NO"
while state:
w, b, k, l = state.pop()
if k == m:
res = 'YES\n' + ' '.join(map(str, l))
break
for wt in weights:
if wt != w and wt > b:
state.append((wt, wt-b, k+1, l+[wt]))
print(res)
``` |
385_C. Bear and Prime Numbers | Recently, the bear started studying data structures and faced the following problem.
You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: <image>, where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).
Help the bear cope with the problem.
Input
The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.
The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri (2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.
Output
Print m integers — the answers to the queries on the order the queries appear in the input.
Examples
Input
6
5 5 7 10 14 15
3
2 11
3 12
4 4
Output
9
7
0
Input
7
2 3 5 7 11 4 8
2
8 10
2 123
Output
0
7
Note
Consider the first sample. Overall, the first sample has 3 queries.
1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0. | ```python
import math, sys
input = sys.stdin.buffer.readline
def ints():
return map(int, input().split())
n = int(input())
x = list(ints())
MAX = max(x) + 1
freq = [0] * MAX
for i in x:
freq[i] += 1
sieve = [False] * MAX
f = [0] * MAX
for i in range(2, MAX):
if sieve[i]:
continue
for j in range(i, MAX, i):
sieve[j] = True
f[i] += freq[j]
for i in range(2, MAX):
f[i] += f[i-1]
m = int(input())
for i in range(m):
l, r = ints()
if l >= MAX:
print(0)
elif r >= MAX:
print(f[-1] - f[l-1])
else:
print(f[r] - f[l-1])
``` |
406_B. Toy Sum | Little Chris is very keen on his toy blocks. His teacher, however, wants Chris to solve more problems, so he decided to play a trick on Chris.
There are exactly s blocks in Chris's set, each block has a unique number from 1 to s. Chris's teacher picks a subset of blocks X and keeps it to himself. He will give them back only if Chris can pick such a non-empty subset Y from the remaining blocks, that the equality holds:
<image> "Are you kidding me?", asks Chris.
For example, consider a case where s = 8 and Chris's teacher took the blocks with numbers 1, 4 and 5. One way for Chris to choose a set is to pick the blocks with numbers 3 and 6, see figure. Then the required sums would be equal: (1 - 1) + (4 - 1) + (5 - 1) = (8 - 3) + (8 - 6) = 7.
<image>
However, now Chris has exactly s = 106 blocks. Given the set X of blocks his teacher chooses, help Chris to find the required set Y!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 5·105), the number of blocks in the set X. The next line contains n distinct space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 106), the numbers of the blocks in X.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
In the first line of output print a single integer m (1 ≤ m ≤ 106 - n), the number of blocks in the set Y. In the next line output m distinct space-separated integers y1, y2, ..., ym (1 ≤ yi ≤ 106), such that the required equality holds. The sets X and Y should not intersect, i.e. xi ≠ yj for all i, j (1 ≤ i ≤ n; 1 ≤ j ≤ m). It is guaranteed that at least one solution always exists. If there are multiple solutions, output any of them.
Examples
Input
3
1 4 5
Output
2
999993 1000000
Input
1
1
Output
1
1000000 | ```python
import sys
INF = 10**20
MOD = 10**9 + 7
I = lambda:list(map(int,input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
"""
Facts and Data representation
Constructive? Top bottom up down
"""
n, = I()
a = I()
M = 10 ** 6 + 1
take = [0] * M
for i in a:
take[i] = 1
ans = []
ok = []
cnt = 0
for i in range(1, M // 2 + 1):
if take[i] and take[M - i]:
cnt += 1
elif not take[i] and not take[M - i]:
ok.append((i, M - i))
elif take[i]:
ans.append(M - i)
else:
ans.append(i)
for i in range(cnt):
ans.append(ok[i][0])
ans.append(ok[i][1])
print(len(ans))
print(*ans)
``` |
433_C. Ryouko's Memory Note | Ryouko is an extremely forgetful girl, she could even forget something that has just happened. So in order to remember, she takes a notebook with her, called Ryouko's Memory Note. She writes what she sees and what she hears on the notebook, and the notebook became her memory.
Though Ryouko is forgetful, she is also born with superb analyzing abilities. However, analyzing depends greatly on gathered information, in other words, memory. So she has to shuffle through her notebook whenever she needs to analyze, which is tough work.
Ryouko's notebook consists of n pages, numbered from 1 to n. To make life (and this problem) easier, we consider that to turn from page x to page y, |x - y| pages should be turned. During analyzing, Ryouko needs m pieces of information, the i-th piece of information is on page ai. Information must be read from the notebook in order, so the total number of pages that Ryouko needs to turn is <image>.
Ryouko wants to decrease the number of pages that need to be turned. In order to achieve this, she can merge two pages of her notebook. If Ryouko merges page x to page y, she would copy all the information on page x to y (1 ≤ x, y ≤ n), and consequently, all elements in sequence a that was x would become y. Note that x can be equal to y, in which case no changes take place.
Please tell Ryouko the minimum number of pages that she needs to turn. Note she can apply the described operation at most once before the reading. Note that the answer can exceed 32-bit integers.
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 105).
The next line contains m integers separated by spaces: a1, a2, ..., am (1 ≤ ai ≤ n).
Output
Print a single integer — the minimum number of pages Ryouko needs to turn.
Examples
Input
4 6
1 2 3 4 3 2
Output
3
Input
10 5
9 4 3 8 8
Output
6
Note
In the first sample, the optimal solution is to merge page 4 to 3, after merging sequence a becomes {1, 2, 3, 3, 3, 2}, so the number of pages Ryouko needs to turn is |1 - 2| + |2 - 3| + |3 - 3| + |3 - 3| + |3 - 2| = 3.
In the second sample, optimal solution is achieved by merging page 9 to 4. | ```python
def median(a):
if len(a) == 0:
return 0
if len(a) % 2 == 1:
return a[len(a) // 2]
else:
return (a[len(a) // 2] + a[(len(a) // 2) - 1]) // 2
def profit(a, old_val):
a.sort()
med = median(a)
sum_old = 0
sum_new = 0
for i in a:
sum_old += abs(i - old_val)
sum_new += abs(i - med)
return sum_old - sum_new
n, m = [int(c) for c in input().split()]
pages = [int(c) for c in input().split()]
count = {pages[0]: []}
current_page_switches = 0
for i in range(1, len(pages)):
cur_i = pages[i]
prev_i = pages[i - 1]
if not(cur_i in count):
count[cur_i] = []
if cur_i != prev_i:
count[cur_i].append(prev_i)
count[prev_i].append(cur_i)
current_page_switches += abs(cur_i - prev_i)
max_profit = 0
for i in count:
if len(count[i]) > 0:
tmp = profit(count[i], i)
if tmp > max_profit:
max_profit = tmp
print(current_page_switches - max_profit)
``` |
478_C. Table Decorations | You have r red, g green and b blue balloons. To decorate a single table for the banquet you need exactly three balloons. Three balloons attached to some table shouldn't have the same color. What maximum number t of tables can be decorated if we know number of balloons of each color?
Your task is to write a program that for given values r, g and b will find the maximum number t of tables, that can be decorated in the required manner.
Input
The single line contains three integers r, g and b (0 ≤ r, g, b ≤ 2·109) — the number of red, green and blue baloons respectively. The numbers are separated by exactly one space.
Output
Print a single integer t — the maximum number of tables that can be decorated in the required manner.
Examples
Input
5 4 3
Output
4
Input
1 1 1
Output
1
Input
2 3 3
Output
2
Note
In the first sample you can decorate the tables with the following balloon sets: "rgg", "gbb", "brr", "rrg", where "r", "g" and "b" represent the red, green and blue balls, respectively. | ```python
a = sorted(list(map(int, input().split())))
a[2] = min(a[2], 2 * (a[0] + a[1]))
print(sum(a) // 3)
``` |
500_E. New Year Domino | Celebrating the new year, many people post videos of falling dominoes; Here's a list of them: https://www.youtube.com/results?search_query=New+Years+Dominos
User ainta, who lives in a 2D world, is going to post a video as well.
There are n dominoes on a 2D Cartesian plane. i-th domino (1 ≤ i ≤ n) can be represented as a line segment which is parallel to the y-axis and whose length is li. The lower point of the domino is on the x-axis. Let's denote the x-coordinate of the i-th domino as pi. Dominoes are placed one after another, so p1 < p2 < ... < pn - 1 < pn holds.
User ainta wants to take a video of falling dominoes. To make dominoes fall, he can push a single domino to the right. Then, the domino will fall down drawing a circle-shaped orbit until the line segment totally overlaps with the x-axis.
<image>
Also, if the s-th domino touches the t-th domino while falling down, the t-th domino will also fall down towards the right, following the same procedure above. Domino s touches domino t if and only if the segment representing s and t intersects.
<image>
See the picture above. If he pushes the leftmost domino to the right, it falls down, touching dominoes (A), (B) and (C). As a result, dominoes (A), (B), (C) will also fall towards the right. However, domino (D) won't be affected by pushing the leftmost domino, but eventually it will fall because it is touched by domino (C) for the first time.
<image>
The picture above is an example of falling dominoes. Each red circle denotes a touch of two dominoes.
User ainta has q plans of posting the video. j-th of them starts with pushing the xj-th domino, and lasts until the yj-th domino falls. But sometimes, it could be impossible to achieve such plan, so he has to lengthen some dominoes. It costs one dollar to increase the length of a single domino by 1. User ainta wants to know, for each plan, the minimum cost needed to achieve it. Plans are processed independently, i. e. if domino's length is increased in some plan, it doesn't affect its length in other plans. Set of dominos that will fall except xj-th domino and yj-th domino doesn't matter, but the initial push should be on domino xj.
Input
The first line contains an integer n (2 ≤ n ≤ 2 × 105)— the number of dominoes.
Next n lines describe the dominoes. The i-th line (1 ≤ i ≤ n) contains two space-separated integers pi, li (1 ≤ pi, li ≤ 109)— the x-coordinate and the length of the i-th domino. It is guaranteed that p1 < p2 < ... < pn - 1 < pn.
The next line contains an integer q (1 ≤ q ≤ 2 × 105) — the number of plans.
Next q lines describe the plans. The j-th line (1 ≤ j ≤ q) contains two space-separated integers xj, yj (1 ≤ xj < yj ≤ n). It means the j-th plan is, to push the xj-th domino, and shoot a video until the yj-th domino falls.
Output
For each plan, print a line containing the minimum cost needed to achieve it. If no cost is needed, print 0.
Examples
Input
6
1 5
3 3
4 4
9 2
10 1
12 1
4
1 2
2 4
2 5
2 6
Output
0
1
1
2
Note
Consider the example. The dominoes are set like the picture below.
<image>
Let's take a look at the 4th plan. To make the 6th domino fall by pushing the 2nd domino, the length of the 3rd domino (whose x-coordinate is 4) should be increased by 1, and the 5th domino (whose x-coordinate is 9) should be increased by 1 (other option is to increase 4th domino instead of 5th also by 1). Then, the dominoes will fall like in the picture below. Each cross denotes a touch between two dominoes.
<image> <image> <image> <image> <image> | ```python
'''
from bisect import bisect,bisect_left
from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *'''
#------------------------------------------------------------------------
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().rstrip("\r\n")
#------------------------------------------------------------------------
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 A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d={}
d[s]=0
heap=[(0,s)]
seen=set()
while heap:
dis,u=heappop(heap)
if u in seen:
continue
seen.add(u)
for v,w in graph[u]:
if v not in d or d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect.bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
class SMT:
def __init__(self,n,query_fn,I):
self.h = 1
while 1 << self.h < n:
self.h += 1
self.n=1<<self.h
self.qf=query_fn
self.tree = [I] * (self.n<<1)
self.lazy = [0] * self.n
def build(self, v):
for k in range(len(v)):
self.tree[k + self.n] = v[k]
for k in range(self.n - 1, 0, -1):
self.tree[k] = self.qf(self.tree[2*k],self.tree[2 * k + 1])
def apply(self, x, val):
self.tree[x] = val
if x < self.n:
self.lazy[x] = 1
def pushup(self, x):
self.tree[x]=self.qf(self.tree[2*x],self.tree[2*x+1])
def push(self, x):#pushdown
if self.lazy[x]:
self.apply(x * 2,0)
self.apply(x * 2+ 1,0)
self.lazy[x] = 0
def set(self,p,x):
p+=self.n
for i in range(self.h,0,-1):self.push(p>>i)
self.tree[p]=x
for i in range(1,self.h+1):self.pushup(p>>i)
def get(self,p):
p+=self.n
for i in range(self.h,0,-1):self.push(p>>i)
return self.tree[p]
def update(self, l, r, h):#左闭右闭
l += self.n
r += self.n
l0=l
r0=r
for i in range(self.h,0,-1):
if (((l>>i)<<i)!=l):self.push(l>>i)
if ((((r+1)>>i)<<i)!=r+1):self.push(r>>i)
while l <= r:
if l & 1:
self.apply(l, h)
l += 1
if not r & 1:
self.apply(r, h)
r -= 1
l>>=1
r>>=1
for i in range(1,self.h+1):
if (((l0>>i)<<i)!=l0):self.pushup(l0>>i)
if ((((r0+1)>>i)<<i)!=r0+1):
self.pushup(r0>>i)
def query(self, l, r):
l += self.n
r += self.n
for i in range(self.h,0,-1):
if (((l>>i)<<i)!=l):self.push(l>>i)
if ((((r+1)>>i)<<i)!=r+1):self.push(r>>i)
ans = 0
while l <= r:
if l & 1:
ans = self.qf(ans, self.tree[l])
l += 1
if not r & 1:
ans = self.qf(ans, self.tree[r])
r -= 1
l >>= 1; r >>= 1
return ans
def add(x,y):
return x+y
t=1
for i in range(t):
n=N()
s=set()
x=A(n)
y=A(n)
for i in range(n):
p,l=RL()
x[i]=p
y[i]=p+l
s.add(p)
s.add(y[i])
s=sorted(s)
d={x:i for i,x in enumerate(s)}
k=len(s)-1
arr=[s[i]-s[i-1] for i in range(1,k+1)]
smt=SMT(k,add,0)
smt.build(arr)
g=G(n)
q=N()
ans=A(q)
for i in range(q):
a,b=RL()
a-=1
b-=1
g[a].append((i,b))
for i in range(n-1,-1,-1):
l=d[x[i]]
r=d[y[i]]
smt.update(l,r-1,0)
for j,cur in g[i]:
cur=d[x[cur]]
ans[j]=smt.query(l,cur-1)
for x in ans:
print(x)
'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
'''
``` |
526_C. Om Nom and Candies | A sweet little monster Om Nom loves candies very much. One day he found himself in a rather tricky situation that required him to think a bit in order to enjoy candies the most. Would you succeed with the same task if you were on his place?
<image>
One day, when he came to his friend Evan, Om Nom didn't find him at home but he found two bags with candies. The first was full of blue candies and the second bag was full of red candies. Om Nom knows that each red candy weighs Wr grams and each blue candy weighs Wb grams. Eating a single red candy gives Om Nom Hr joy units and eating a single blue candy gives Om Nom Hb joy units.
Candies are the most important thing in the world, but on the other hand overeating is not good. Om Nom knows if he eats more than C grams of candies, he will get sick. Om Nom thinks that it isn't proper to leave candy leftovers, so he can only eat a whole candy. Om Nom is a great mathematician and he quickly determined how many candies of what type he should eat in order to get the maximum number of joy units. Can you repeat his achievement? You can assume that each bag contains more candies that Om Nom can eat.
Input
The single line contains five integers C, Hr, Hb, Wr, Wb (1 ≤ C, Hr, Hb, Wr, Wb ≤ 109).
Output
Print a single integer — the maximum number of joy units that Om Nom can get.
Examples
Input
10 3 5 2 3
Output
16
Note
In the sample test Om Nom can eat two candies of each type and thus get 16 joy units. | ```python
C, Hr, Hb, Wr, Wb = map(int, input().split())
ans = 0
for i in range(10 ** 5):
if Wr * i <= C:
ans = max(ans, Hr * i + (C - Wr * i) // Wb * Hb)
for i in range(10 ** 5):
if Wb * i <= C:
ans = max(ans, Hb * i + (C - Wb * i) // Wr * Hr)
print(ans)
``` |
551_D. GukiZ and Binary Operations | We all know that GukiZ often plays with arrays.
Now he is thinking about this problem: how many arrays a, of length n, with non-negative elements strictly less then 2l meet the following condition: <image>? Here operation <image> means bitwise AND (in Pascal it is equivalent to and, in C/C++/Java/Python it is equivalent to &), operation <image> means bitwise OR (in Pascal it is equivalent to <image>, in C/C++/Java/Python it is equivalent to |).
Because the answer can be quite large, calculate it modulo m. This time GukiZ hasn't come up with solution, and needs you to help him!
Input
First and the only line of input contains four integers n, k, l, m (2 ≤ n ≤ 1018, 0 ≤ k ≤ 1018, 0 ≤ l ≤ 64, 1 ≤ m ≤ 109 + 7).
Output
In the single line print the number of arrays satisfying the condition above modulo m.
Examples
Input
2 1 2 10
Output
3
Input
2 1 1 3
Output
1
Input
3 3 2 10
Output
9
Note
In the first sample, satisfying arrays are {1, 1}, {3, 1}, {1, 3}.
In the second sample, only satisfying array is {1, 1}.
In the third sample, satisfying arrays are {0, 3, 3}, {1, 3, 2}, {1, 3, 3}, {2, 3, 1}, {2, 3, 3}, {3, 3, 0}, {3, 3, 1}, {3, 3, 2}, {3, 3, 3}. | ```python
# -*- coding: utf-8 -*-
from collections import deque
def calc(n, m):
if n == 1:
return [[1, 0], [0, 1]]
a = calc(n // 2, m)
if n % 2 == 0:
res00 = (a[0][0] * a[0][0]) % m
res00 = (res00 + a[0][0] * a[1][0]) % m
res00 = (res00 + a[0][1] * a[0][0]) % m
res01 = (a[0][0] * a[0][1]) % m
res01 = (res01 + a[0][0] * a[1][1]) % m
res01 = (res01 + a[0][1] * a[0][1]) % m
res10 = (a[1][0] * a[0][0]) % m
res10 = (res10 + a[1][0] * a[1][0]) % m
res10 = (res10 + a[1][1] * a[0][0]) % m
res11 = (a[1][0] * a[0][1]) % m
res11 = (res11 + a[1][0] * a[1][1]) % m
res11 = (res11 + a[1][1] * a[0][1]) % m
return [[res00, res01], [res10, res11]]
else:
res00 = (a[0][0] * a[0][0] * 2) % m
res00 = (res00 + a[0][0] * a[1][0]) % m
res00 = (res00 + a[0][1] * a[0][0]) % m
res00 = (res00 + a[0][1] * a[1][0]) % m
res01 = (a[0][0] * a[0][1] * 2) % m
res01 = (res01 + a[0][0] * a[1][1]) % m
res01 = (res01 + a[0][1] * a[0][1]) % m
res01 = (res01 + a[0][1] * a[1][1]) % m
res10 = (a[1][0] * a[0][0] * 2) % m
res10 = (res10 + a[1][0] * a[1][0]) % m
res10 = (res10 + a[1][1] * a[0][0]) % m
res10 = (res10 + a[1][1] * a[1][0]) % m
res11 = (a[1][0] * a[0][1] * 2) % m
res11 = (res11 + a[1][0] * a[1][1]) % m
res11 = (res11 + a[1][1] * a[0][1]) % m
res11 = (res11 + a[1][1] * a[1][1]) % m
return [[res00, res01], [res10, res11]]
def binpow(a, p, m):
if p == 0:
return 1 % m
if p == 1:
return a % m
ans = binpow(a, p // 2, m)
ans = (ans * ans) % m
if p % 2 == 1:
ans = (ans * a) % m
return ans
n, k, l, m = map(int, input().split())
ans = [0, 0]
x = calc(n, m)
ans[0] = (x[0][0] + x[0][1] + x[1][0] + x[1][1]) % m
ans[1] = ((binpow(2, n, m) - ans[0]) % m + m) % m
res = 1
for i in range(l):
res = (res * ans[k & 1]) % m
k >>= 1
if k > 0:
res = 0
print(res % m)
``` |
5_C. Longest Regular Bracket Sequence | This is yet another problem dealing with regular bracket sequences.
We should remind you that a bracket sequence is called regular, if by inserting «+» and «1» into it we can get a correct mathematical expression. For example, sequences «(())()», «()» and «(()(()))» are regular, while «)(», «(()» and «(()))(» are not.
You are given a string of «(» and «)» characters. You are to find its longest substring that is a regular bracket sequence. You are to find the number of such substrings as well.
Input
The first line of the input file contains a non-empty string, consisting of «(» and «)» characters. Its length does not exceed 106.
Output
Print the length of the longest substring that is a regular bracket sequence, and the number of such substrings. If there are no such substrings, write the only line containing "0 1".
Examples
Input
)((())))(()())
Output
6 2
Input
))(
Output
0 1 | ```python
string = input()
n = len(string)
stack = []
mapping = [0]*n
# First we create an array where the array called mapping where the index of array
# gives the index of start of opening bracket in string and the value at that index
# gives the index of closing bracket for corresponding opening bracket.
for idx, char in enumerate(string):
if char == '(':
# We add idx of ( to stack which will be used as idx in mapping
stack.append(idx)
# Map only those ')' which have an opening brace, empty stack signifies
# closing brace has no opening brace.
elif char == ')' and stack:
mapping[stack.pop()] = idx
# Once we have generated the mapping we scan the array the difference between the index and its
# value gives us the len of current regular expression. Now we take the value at that index and
# icrement it to see if there is some non zero value at that location signifing that the regular
# expression can be expanded. We continue this till no more expansion or we have some current length
# more than previous expansions.
i = 0
mx = 0
cnt = 1
tmp_max = 0
prev_join_idx = 0
while i < n:
# If value present at mapping
if mapping[i]:
curr_len = mapping[i] - i + 1
# if we have some previous regx
if i == prev_join_idx + 1:
tmp_max += curr_len
else:
tmp_max = curr_len
# We have found new regx whose len is more than all prev scanned regx
if tmp_max > mx:
mx = tmp_max
cnt = 1
elif tmp_max == mx:
cnt += 1
prev_join_idx = mapping[i]
i = mapping[i] + 1
else:
i +=1
print(mx, cnt)
``` |
622_A. Infinite Sequence | Consider the infinite sequence of integers: 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5.... The sequence is built in the following way: at first the number 1 is written out, then the numbers from 1 to 2, then the numbers from 1 to 3, then the numbers from 1 to 4 and so on. Note that the sequence contains numbers, not digits. For example number 10 first appears in the sequence in position 55 (the elements are numerated from one).
Find the number on the n-th position of the sequence.
Input
The only line contains integer n (1 ≤ n ≤ 1014) — the position of the number to find.
Note that the given number is too large, so you should use 64-bit integer type to store it. In C++ you can use the long long integer type and in Java you can use long integer type.
Output
Print the element in the n-th position of the sequence (the elements are numerated from one).
Examples
Input
3
Output
2
Input
5
Output
2
Input
10
Output
4
Input
55
Output
10
Input
56
Output
1 | ```python
n = int(input())
from math import sqrt
# Find max m such that m(m+1)/2 <= n
m = int((-1 + sqrt(1 + 8*n))/2)
# l is the previous range
l = m * (m + 1) // 2
print(m if n == l else n - l)
``` |
670_D1. Magic Powder - 1 | This problem is given in two versions that differ only by constraints. If you can solve this problem in large constraints, then you can just write a single solution to the both versions. If you find the problem too difficult in large constraints, you can write solution to the simplified version only.
Waking up in the morning, Apollinaria decided to bake cookies. To bake one cookie, she needs n ingredients, and for each ingredient she knows the value ai — how many grams of this ingredient one needs to bake a cookie. To prepare one cookie Apollinaria needs to use all n ingredients.
Apollinaria has bi gram of the i-th ingredient. Also she has k grams of a magic powder. Each gram of magic powder can be turned to exactly 1 gram of any of the n ingredients and can be used for baking cookies.
Your task is to determine the maximum number of cookies, which Apollinaria is able to bake using the ingredients that she has and the magic powder.
Input
The first line of the input contains two positive integers n and k (1 ≤ n, k ≤ 1000) — the number of ingredients and the number of grams of the magic powder.
The second line contains the sequence a1, a2, ..., an (1 ≤ ai ≤ 1000), where the i-th number is equal to the number of grams of the i-th ingredient, needed to bake one cookie.
The third line contains the sequence b1, b2, ..., bn (1 ≤ bi ≤ 1000), where the i-th number is equal to the number of grams of the i-th ingredient, which Apollinaria has.
Output
Print the maximum number of cookies, which Apollinaria will be able to bake using the ingredients that she has and the magic powder.
Examples
Input
3 1
2 1 4
11 3 16
Output
4
Input
4 3
4 3 5 6
11 12 14 20
Output
3
Note
In the first sample it is profitably for Apollinaria to make the existing 1 gram of her magic powder to ingredient with the index 2, then Apollinaria will be able to bake 4 cookies.
In the second sample Apollinaria should turn 1 gram of magic powder to ingredient with the index 1 and 1 gram of magic powder to ingredient with the index 3. Then Apollinaria will be able to bake 3 cookies. The remaining 1 gram of the magic powder can be left, because it can't be used to increase the answer. | ```python
n, k = input().split(" ")
n, k = [int(n), int(k)]
list1 = list(map(int, input().split(" ")))
list2 = list(map(int, input().split(" ")))
low = 0
high = 2*(10**9)
while low < high:
if high - low % 2 != 0:
mid = low + (high - low) // 2 + 1
else:
mid = low + (high - low)//2
d = k
list6 = []
for i in range(n):
if list1[i]*mid <= list2[i]:
continue
else:
c = list1[i] * mid - list2[i]
if d >= c:
d = d - c
continue
else:
high = mid -1
break
if high != mid - 1:
low = mid
print(low)
``` |
737_C. Subordinates | There are n workers in a company, each of them has a unique id from 1 to n. Exaclty one of them is a chief, his id is s. Each worker except the chief has exactly one immediate superior.
There was a request to each of the workers to tell how how many superiors (not only immediate). Worker's superiors are his immediate superior, the immediate superior of the his immediate superior, and so on. For example, if there are three workers in the company, from which the first is the chief, the second worker's immediate superior is the first, the third worker's immediate superior is the second, then the third worker has two superiors, one of them is immediate and one not immediate. The chief is a superior to all the workers except himself.
Some of the workers were in a hurry and made a mistake. You are to find the minimum number of workers that could make a mistake.
Input
The first line contains two positive integers n and s (1 ≤ n ≤ 2·105, 1 ≤ s ≤ n) — the number of workers and the id of the chief.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n - 1), where ai is the number of superiors (not only immediate) the worker with id i reported about.
Output
Print the minimum number of workers that could make a mistake.
Examples
Input
3 2
2 0 2
Output
1
Input
5 3
1 0 0 4 1
Output
2
Note
In the first example it is possible that only the first worker made a mistake. Then:
* the immediate superior of the first worker is the second worker,
* the immediate superior of the third worker is the first worker,
* the second worker is the chief. | ```python
f = lambda: map(int, input().split())
n, s = f()
c = [0] * n
t = list(f())
for i in t: c[i] += 1
k = t[s - 1]
c[k] -= 1
d = c[0]
c += [d]
d += k > 0
i, j = 1, n
while i < j:
if c[i]: i += 1
elif c[j]:
c[j] -= 1
i += 1
d += j < n
else: j -= 1
print(d)
``` |
761_B. Dasha and friends | Running with barriers on the circle track is very popular in the country where Dasha lives, so no wonder that on her way to classes she saw the following situation:
The track is the circle with length L, in distinct points of which there are n barriers. Athlete always run the track in counterclockwise direction if you look on him from above. All barriers are located at integer distance from each other along the track.
Her friends the parrot Kefa and the leopard Sasha participated in competitions and each of them ran one lap. Each of the friends started from some integral point on the track. Both friends wrote the distance from their start along the track to each of the n barriers. Thus, each of them wrote n integers in the ascending order, each of them was between 0 and L - 1, inclusively.
<image> Consider an example. Let L = 8, blue points are barriers, and green points are Kefa's start (A) and Sasha's start (B). Then Kefa writes down the sequence [2, 4, 6], and Sasha writes down [1, 5, 7].
There are several tracks in the country, all of them have same length and same number of barriers, but the positions of the barriers can differ among different tracks. Now Dasha is interested if it is possible that Kefa and Sasha ran the same track or they participated on different tracks.
Write the program which will check that Kefa's and Sasha's tracks coincide (it means that one can be obtained from the other by changing the start position). Note that they always run the track in one direction — counterclockwise, if you look on a track from above.
Input
The first line contains two integers n and L (1 ≤ n ≤ 50, n ≤ L ≤ 100) — the number of barriers on a track and its length.
The second line contains n distinct integers in the ascending order — the distance from Kefa's start to each barrier in the order of its appearance. All integers are in the range from 0 to L - 1 inclusively.
The second line contains n distinct integers in the ascending order — the distance from Sasha's start to each barrier in the order of its overcoming. All integers are in the range from 0 to L - 1 inclusively.
Output
Print "YES" (without quotes), if Kefa and Sasha ran the coinciding tracks (it means that the position of all barriers coincides, if they start running from the same points on the track). Otherwise print "NO" (without quotes).
Examples
Input
3 8
2 4 6
1 5 7
Output
YES
Input
4 9
2 3 5 8
0 1 3 6
Output
YES
Input
2 4
1 3
1 2
Output
NO
Note
The first test is analyzed in the statement. | ```python
n,l = map(int,input().split())
kefa = list(map(int,input().split()))
sasha = list(map(int,input().split()))
diff1 = [kefa[i+1] - kefa[i] if i != n - 1 else l - kefa[-1] + kefa[0] for i in range(n) ]
diff2 = [sasha[i+1] - sasha[i] if i != n - 1 else l - sasha[-1] + sasha[0] for i in range(n) ]
def rotation(pos):
for i in range(n):
if diff2[(i+pos)%n] != diff1[i]:
return False
return True
for i in range(n):
if(rotation(i)):
print("YES")
exit()
print("NO")
``` |
784_D. Touchy-Feely Palindromes |
Input
The only line of the input contains a string of digits. The length of the string is between 1 and 10, inclusive.
Output
Output "Yes" or "No".
Examples
Input
373
Output
Yes
Input
121
Output
No
Input
436
Output
Yes | ```python
# ⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚
# 1234567890
R = [
("1", "' "),
("2", ": "),
("3", "''"),
("4", "':"),
("5", "'."),
("6", ":'"),
("7", "::"),
("8", ":."),
("9", ".'"),
("0", ".:"),
]
s = input()
for a,b in R:
s = s.replace(a,b)
print("Yes" if s==s[::-1] else "No")
``` |
805_C. Find Amir | A few years ago Sajjad left his school and register to another one due to security reasons. Now he wishes to find Amir, one of his schoolmates and good friends.
There are n schools numerated from 1 to n. One can travel between each pair of them, to do so, he needs to buy a ticket. The ticker between schools i and j costs <image> and can be used multiple times. Help Sajjad to find the minimum cost he needs to pay for tickets to visit all schools. He can start and finish in any school.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of schools.
Output
Print single integer: the minimum cost of tickets needed to visit all schools.
Examples
Input
2
Output
0
Input
10
Output
4
Note
In the first example we can buy a ticket between the schools that costs <image>. | ```python
print(max((int(input()) + 1) // 2 - 1, 0))
``` |
830_C. Bamboo Partition | Vladimir wants to modernize partitions in his office. To make the office more comfortable he decided to remove a partition and plant several bamboos in a row. He thinks it would be nice if there are n bamboos in a row, and the i-th from the left is ai meters high.
Vladimir has just planted n bamboos in a row, each of which has height 0 meters right now, but they grow 1 meter each day. In order to make the partition nice Vladimir can cut each bamboo once at any height (no greater that the height of the bamboo), and then the bamboo will stop growing.
Vladimir wants to check the bamboos each d days (i.e. d days after he planted, then after 2d days and so on), and cut the bamboos that reached the required height. Vladimir wants the total length of bamboo parts he will cut off to be no greater than k meters.
What is the maximum value d he can choose so that he can achieve what he wants without cutting off more than k meters of bamboo?
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1011) — the number of bamboos and the maximum total length of cut parts, in meters.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109) — the required heights of bamboos, in meters.
Output
Print a single integer — the maximum value of d such that Vladimir can reach his goal.
Examples
Input
3 4
1 3 5
Output
3
Input
3 40
10 30 50
Output
32
Note
In the first example Vladimir can check bamboos each 3 days. Then he will cut the first and the second bamboos after 3 days, and the third bamboo after 6 days. The total length of cut parts is 2 + 0 + 1 = 3 meters. | ```python
import itertools
unfold = itertools.chain.from_iterable
def jumps(a):
d = speedup
while d < a - 1:
c = (a + d - 1) // d
d = (a + c - 2) // (c - 1)
yield d
def calc(d):
return sum(d - 1 - (i - 1) % d for i in a)
def ans():
for d, pd in zip(D, D[1:]):
d -= 1
cd = calc(d)
if cd <= k:
return d
if d == pd:
continue
cpd = calc(pd)
if d - pd >= (cd - k) * (d - pd) / (cd - cpd):
return d - (cd - k) * (d - pd) / (cd - cpd)
return 1
n, k = map(int, input().split())
a = list(map(int, input().split()))
speedup = int(max(a) ** 0.5)
D = sorted(set(range(1, speedup + 1)).union([max(a) + k + 1]).union(set(
unfold(map(jumps, a)))), reverse=True)
print('%d' % ans())
``` |
89_E. Fire and Ice | The Fire Lord attacked the Frost Kingdom. He has already got to the Ice Fortress, where the Snow Queen dwells. He arranged his army on a segment n in length not far from the city walls. And only the frost magician Solomon can save the Frost Kingdom.
<image>
The n-long segment is located at a distance equal exactly to 1 from the castle walls. It can be imaginarily divided into unit segments. On some of the unit segments fire demons are located — no more than one demon per position. Each demon is characterised by his strength - by some positive integer. We can regard the fire demons being idle.
Initially Solomon is positioned on the fortress wall. He can perform the following actions several times in a row:
* "L" — Solomon shifts one unit to the left. This movement cannot be performed on the castle wall.
* "R" — Solomon shifts one unit to the left. This movement cannot be performed if there's no ice block to the right.
* "A" — If there's nothing to the right of Solomon, then Solomon creates an ice block that immediately freezes to the block that Solomon is currently standing on. If there already is an ice block, then Solomon destroys it. At that the ice blocks to the right of the destroyed one can remain but they are left unsupported. Those ice blocks fall down.
Solomon spends exactly a second on each of these actions.
As the result of Solomon's actions, ice blocks' segments fall down. When an ice block falls on a fire demon, the block evaporates and the demon's strength is reduced by 1. When the demons' strength is equal to 0, the fire demon vanishes. The picture below shows how it happens. The ice block that falls on the position with no demon, breaks into lots of tiny pieces and vanishes without hurting anybody.
<image>
Help Solomon destroy all the Fire Lord's army in minimum time.
Input
The first line contains an integer n (1 ≤ n ≤ 1000). The next line contains n numbers, the i-th of them represents the strength of the fire demon standing of the i-th position, an integer from 1 to 100. If there's no demon on the i-th position, then the i-th number equals to 0. It is guaranteed that the input data have at least one fire demon.
Output
Print a string of minimum length, containing characters "L", "R" and "A" — the succession of actions leading to the required result.
If there are several possible answers, print any of them.
Examples
Input
3
1 0 1
Output
ARARARALLLA
Input
3
0 2 0
Output
ARARALAARALA | ```python
n = int(input())
a = [0] * 1010
b = [0] * 2010
S = 1000000007
W=0
b = list(map(int,input().strip().split()))[:n]
for i in range(0,n):
a.insert(i,b[i])
while(not a[n-1]):
n-=1
for w in range(0,n+1):
for i in range(0,n):
b[i]=a[i]
for i in range(w,n):
if(b[i]):
b[i]-=1
w0=0
w1=0
la=0
for i in range(0,n):
w0+=max(0,b[i]-la)
w1 += b[i]
la = b[i]
T = 2*n+2+(n-w)+3*w1+2*w0
for i in range(0,n):
if(T<S):
S=T
W=w
for i in range(W,n):
if(a[i]):
a[i]-=1
for i in range(0,n):
while(a[i]):
j=i
while(a[j]):
a[j]-=1
j+=1
l = j - i
for k in range(0,l):
print("AR",end="")
print("A",end="")
for k in range(0,l):
print("L",end="")
print("A",end="")
print("AR",end="")
print("A",end="")
for i in range(W,n):
print("L",end="")
print("A",end="")
``` |
977_D. Divide by three, multiply by two | Polycarp likes to play with numbers. He takes some integer number x, writes it down on the board, and then performs with it n - 1 operations of the two kinds:
* divide the number x by 3 (x must be divisible by 3);
* multiply the number x by 2.
After each operation, Polycarp writes down the result on the board and replaces x by the result. So there will be n numbers on the board after all.
You are given a sequence of length n — the numbers that Polycarp wrote down. This sequence is given in arbitrary order, i.e. the order of the sequence can mismatch the order of the numbers written on the board.
Your problem is to rearrange (reorder) elements of this sequence in such a way that it can match possible Polycarp's game in the order of the numbers written on the board. I.e. each next number will be exactly two times of the previous number or exactly one third of previous number.
It is guaranteed that the answer exists.
Input
The first line of the input contatins an integer number n (2 ≤ n ≤ 100) — the number of the elements in the sequence. The second line of the input contains n integer numbers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 3 ⋅ 10^{18}) — rearranged (reordered) sequence that Polycarp can wrote down on the board.
Output
Print n integer numbers — rearranged (reordered) input sequence that can be the sequence that Polycarp could write down on the board.
It is guaranteed that the answer exists.
Examples
Input
6
4 8 6 3 12 9
Output
9 3 6 12 4 8
Input
4
42 28 84 126
Output
126 42 84 28
Input
2
1000000000000000000 3000000000000000000
Output
3000000000000000000 1000000000000000000
Note
In the first example the given sequence can be rearranged in the following way: [9, 3, 6, 12, 4, 8]. It can match possible Polycarp's game which started with x = 9. | ```python
n = int(input())
li = list(map(int, input().split()))
g = {}
def dfs(e, v, order):
if e not in v:
v[e] = 1
if e % 3 == 0:
if (e // 3) in g:
order.append(e // 3)
dfs(e // 3, v, order)
if e * 2 in g:
order.append(e * 2)
dfs(e * 2, v, order)
for i in li:
g[i] = 0
for i in li:
vis = {}
Aorder = []
Aorder.append(i)
dfs(i, vis, Aorder)
if len(Aorder) == n:
print(*Aorder)
break
``` |
997_B. Roman Digits | Let's introduce a number system which is based on a roman digits. There are digits I, V, X, L which correspond to the numbers 1, 5, 10 and 50 respectively. The use of other roman digits is not allowed.
Numbers in this system are written as a sequence of one or more digits. We define the value of the sequence simply as the sum of digits in it.
For example, the number XXXV evaluates to 35 and the number IXI — to 12.
Pay attention to the difference to the traditional roman system — in our system any sequence of digits is valid, moreover the order of digits doesn't matter, for example IX means 11, not 9.
One can notice that this system is ambiguous, and some numbers can be written in many different ways. Your goal is to determine how many distinct integers can be represented by exactly n roman digits I, V, X, L.
Input
The only line of the input file contains a single integer n (1 ≤ n ≤ 10^9) — the number of roman digits to use.
Output
Output a single integer — the number of distinct integers which can be represented using n roman digits exactly.
Examples
Input
1
Output
4
Input
2
Output
10
Input
10
Output
244
Note
In the first sample there are exactly 4 integers which can be represented — I, V, X and L.
In the second sample it is possible to represent integers 2 (II), 6 (VI), 10 (VV), 11 (XI), 15 (XV), 20 (XX), 51 (IL), 55 (VL), 60 (XL) and 100 (LL). | ```python
def solve(n):
s = set()
for i in range(0, n + 1):
for v in range(0, n - i + 1):
for x in range(0, n - i - v + 1):
l = n - i - v - x
s.add(i + v * 5 + x * 10 + l * 50)
return len(s)
n = int(input())
if n < 11:
print(solve(n))
else:
print(49 * n - 247)
``` |
p02654 AtCoder Grand Contest 045 - Lamps and Buttons | We have N lamps numbered 1 to N, and N buttons numbered 1 to N. Initially, Lamp 1, 2, \cdots, A are on, and the other lamps are off.
Snuke and Ringo will play the following game.
* First, Ringo generates a permutation (p_1,p_2,\cdots,p_N) of (1,2,\cdots,N). The permutation is chosen from all N! possible permutations with equal probability, without being informed to Snuke.
* Then, Snuke does the following operation any number of times he likes:
* Choose a lamp that is on at the moment. (The operation cannot be done if there is no such lamp.) Let Lamp i be the chosen lamp. Press Button i, which switches the state of Lamp p_i. That is, Lamp p_i will be turned off if it is on, and vice versa.
At every moment, Snuke knows which lamps are on. Snuke wins if all the lamps are on, and he will surrender when it turns out that he cannot win. What is the probability of winning when Snuke plays optimally?
Let w be the probability of winning. Then, w \times N! will be an integer. Compute w \times N! modulo (10^9+7).
Constraints
* 2 \leq N \leq 10^7
* 1 \leq A \leq \min(N-1,5000)
Input
Input is given from Standard Input in the following format:
N A
Output
Print w \times N! modulo (10^9+7), where w is the probability of Snuke's winning.
Examples
Input
3 1
Output
2
Input
3 2
Output
3
Input
8 4
Output
16776
Input
9999999 4999
Output
90395416 | ```python
def prepare(n, MOD):
factorials = [1] * (n + 1)
for i in range(2, n + 1):
factorials[i] = factorials[i - 1] * i % MOD
finvs = [1] * (n + 1)
finvs[n] = pow(factorials[n], MOD - 2, MOD)
for i in range(n, 1, -1):
finvs[i - 1] = finvs[i] * i % MOD
return factorials, finvs
def solve(n, a):
MOD = 10 ** 9 + 7
facts, finvs = prepare(n, MOD)
invs = [facts[i - 1] * finvs[i] % MOD for i in range(n + 1)] # invs[0]: undefined
r = n - a
ans = 0
# a個がいずれも自己ループを持たないパターン
for l in range(a):
tmp1 = facts[a] * finvs[l] % MOD * finvs[a - l] % MOD
tmp2 = facts[n - l - 1] * (a - l) % MOD
ans = (ans + (-1) ** (l & 1) * tmp1 * tmp2) % MOD
# a個中k+1個目ではじめて自己ループを持つが、それまでのk個で全点灯できるパターン
for k in range(1, a):
for l in range(k):
tmp1 = facts[k] * finvs[l] % MOD * finvs[k - l] % MOD
tmp2 = facts[n - l - 1] * (k - l) % MOD * invs[r + k - l] % MOD
ans = (ans + (-1) ** (l & 1) * tmp1 * tmp2) % MOD
return ans
n, a = map(int, input().split())
print(solve(n, a))
``` |
p02783 AtCoder Beginner Contest 153 - Serval vs Monster | Serval is fighting with a monster.
The health of the monster is H.
In one attack, Serval can decrease the monster's health by A. There is no other way to decrease the monster's health.
Serval wins when the monster's health becomes 0 or below.
Find the number of attacks Serval needs to make before winning.
Constraints
* 1 \leq H \leq 10^4
* 1 \leq A \leq 10^4
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
H A
Output
Print the number of attacks Serval needs to make before winning.
Examples
Input
10 4
Output
3
Input
1 10000
Output
1
Input
10000 1
Output
10000 | ```python
import math
A,B=map(int,input().split())
print(math.ceil(A/B))
``` |
p02918 AtCoder Beginner Contest 140 - Face Produces Unhappiness | There are N people standing in a queue from west to east.
Given is a string S of length N representing the directions of the people. The i-th person from the west is facing west if the i-th character of S is `L`, and east if that character of S is `R`.
A person is happy if the person in front of him/her is facing the same direction. If no person is standing in front of a person, however, he/she is not happy.
You can perform the following operation any number of times between 0 and K (inclusive):
Operation: Choose integers l and r such that 1 \leq l \leq r \leq N, and rotate by 180 degrees the part of the queue: the l-th, (l+1)-th, ..., r-th persons. That is, for each i = 0, 1, ..., r-l, the (l + i)-th person from the west will stand the (r - i)-th from the west after the operation, facing east if he/she is facing west now, and vice versa.
What is the maximum possible number of happy people you can have?
Constraints
* N is an integer satisfying 1 \leq N \leq 10^5.
* K is an integer satisfying 1 \leq K \leq 10^5.
* |S| = N
* Each character of S is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N K
S
Output
Print the maximum possible number of happy people after at most K operations.
Examples
Input
6 1
LRLRRL
Output
3
Input
13 3
LRRLRLRRLRLLR
Output
9
Input
10 1
LLLLLRRRRR
Output
9
Input
9 2
RRRLRLRLL
Output
7 | ```python
n, k = map(int, input().split())
s = input()
h = sum(1 for i in range(n-1) if s[i] == s[i+1])
print(min(n-1, h+k*2))
``` |
p03054 AtCoder Grand Contest 033 - LRUD Game | We have a rectangular grid of squares with H horizontal rows and W vertical columns. Let (i,j) denote the square at the i-th row from the top and the j-th column from the left. On this grid, there is a piece, which is initially placed at square (s_r,s_c).
Takahashi and Aoki will play a game, where each player has a string of length N. Takahashi's string is S, and Aoki's string is T. S and T both consist of four kinds of letters: `L`, `R`, `U` and `D`.
The game consists of N steps. The i-th step proceeds as follows:
* First, Takahashi performs a move. He either moves the piece in the direction of S_i, or does not move the piece.
* Second, Aoki performs a move. He either moves the piece in the direction of T_i, or does not move the piece.
Here, to move the piece in the direction of `L`, `R`, `U` and `D`, is to move the piece from square (r,c) to square (r,c-1), (r,c+1), (r-1,c) and (r+1,c), respectively. If the destination square does not exist, the piece is removed from the grid, and the game ends, even if less than N steps are done.
Takahashi wants to remove the piece from the grid in one of the N steps. Aoki, on the other hand, wants to finish the N steps with the piece remaining on the grid. Determine if the piece will remain on the grid at the end of the game when both players play optimally.
Constraints
* 2 \leq H,W \leq 2 \times 10^5
* 2 \leq N \leq 2 \times 10^5
* 1 \leq s_r \leq H
* 1 \leq s_c \leq W
* |S|=|T|=N
* S and T consists of the four kinds of letters `L`, `R`, `U` and `D`.
Input
Input is given from Standard Input in the following format:
H W N
s_r s_c
S
T
Output
If the piece will remain on the grid at the end of the game, print `YES`; otherwise, print `NO`.
Examples
Input
2 3 3
2 2
RRL
LUD
Output
YES
Input
4 3 5
2 2
UDRRR
LLDUD
Output
NO
Input
5 6 11
2 1
RLDRRUDDLRL
URRDRLLDLRD
Output
NO | ```python
H, W, N = map(int, input().split())
sr, sc = map(int, input().split())
S = input()
T = input()
B = [1, W, 1, H]
for i in range(N - 1, -1, -1):
if T[i] == 'L': B[1] = min(B[1] + 1, W)
if T[i] == 'R': B[0] = max(B[0] - 1, 1)
if T[i] == 'U': B[3] = min(B[3] + 1, H)
if T[i] == 'D': B[2] = max(B[2] - 1, 1)
if S[i] == 'L': B[0] += 1
if S[i] == 'R': B[1] -= 1
if S[i] == 'U': B[2] += 1
if S[i] == 'D': B[3] -= 1
if B[1] < B[0] or B[3] < B[2]:
print('NO')
break
else:
print('YES' if B[0] <= sc <= B[1] and B[2] <= sr <= B[3] else 'NO')
``` |
p03198 CADDi 2018 - Negative Doubling | There are N positive integers A_1, A_2, ..., A_N. Takahashi can perform the following operation on these integers any number of times:
* Choose 1 \leq i \leq N and multiply the value of A_i by -2.
Notice that he multiplies it by minus two.
He would like to make A_1 \leq A_2 \leq ... \leq A_N holds. Find the minimum number of operations required. If it is impossible, print `-1`.
Constraints
* 1 \leq N \leq 200000
* 1 \leq A_i \leq 10^9
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
4
3 1 4 1
Output
3
Input
5
1 2 3 4 5
Output
0
Input
8
657312726 129662684 181537270 324043958 468214806 916875077 825989291 319670097
Output
7 | ```python
n = int(input())
a = list(map(int,input().split()))
def d4(x,y):
ret = 0
while x > y:
y *= 4
ret += 1
return ret
def cost(ls):
l = len(ls)
ret = [0]*l
stack = [(l-1,10**18)]
for i in range(l-1)[::-1]:
ret[i] = ret[i+1]
if ls[i] <= ls[i+1]:
d = d4(ls[i+1],ls[i])-1
if d > 0:
stack.append((i,d))
else:
d = d4(ls[i],ls[i+1])
while d:
idx,num = stack.pop()
if d > num:
ret[i] += (idx-i)*num
d -= num
else:
ret[i] += (idx-i)*d
num -= d
d = 0
if num:
stack.append((idx,num))
return ret
cp = cost(a)
cn = cost(a[::-1])
for i in range(n):
cp[i] *= 2
cn[i] *= 2
cn[i] += n-i
ansls = [cp[0],cn[0]]
for i in range(1,n):
ansls.append(cp[i]+cn[n-i])
print(min(ansls))
``` |
p03345 AtCoder Grand Contest 024 - Fairness | Takahashi, Nakahashi and Hikuhashi have integers A, B and C, respectively. After repeating the following operation K times, find the integer Takahashi will get minus the integer Nakahashi will get:
* Each of them simultaneously calculate the sum of the integers that the other two people have, then replace his own integer with the result.
However, if the absolute value of the answer exceeds 10^{18}, print `Unfair` instead.
Constraints
* 1 \leq A,B,C \leq 10^9
* 0 \leq K \leq 10^{18}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B C K
Output
Print the integer Takahashi will get minus the integer Nakahashi will get, after repeating the following operation K times. If the absolute value of the answer exceeds 10^{18}, print `Unfair` instead.
Examples
Input
1 2 3 1
Output
1
Input
2 3 2 0
Output
-1
Input
1000000000 1000000000 1000000000 1000000000000000000
Output
0 | ```python
a, b, c, k = list(map(int, input().split()))
ans = b-a if k%2 else a-b
print(ans)
``` |
p03505 Code Festival Team Relay (Parallel) - Kaiden | ButCoder Inc. runs a programming competition site called ButCoder. In this site, a user is given an integer value called rating that represents his/her skill, which changes each time he/she participates in a contest. The initial value of a new user's rating is 0, and a user whose rating reaches K or higher is called Kaiden ("total transmission"). Note that a user's rating may become negative.
Hikuhashi is a new user in ButCoder. It is estimated that, his rating increases by A in each of his odd-numbered contests (first, third, fifth, ...), and decreases by B in each of his even-numbered contests (second, fourth, sixth, ...).
According to this estimate, after how many contests will he become Kaiden for the first time, or will he never become Kaiden?
Constraints
* 1 ≤ K, A, B ≤ 10^{18}
* All input values are integers.
Input
Input is given from Standard Input in the following format:
K A B
Output
If it is estimated that Hikuhashi will never become Kaiden, print `-1`. Otherwise, print the estimated number of contests before he become Kaiden for the first time.
Examples
Input
4000 2000 500
Output
5
Input
4000 500 2000
Output
-1
Input
1000000000000000000 2 1
Output
1999999999999999997 | ```python
from decimal import *
import math
K,A,B=map(int,input().split())
if A>=K:
print(1)
elif A-B>0:
print(1+math.ceil(Decimal(K-A)/Decimal(A-B))*2)
else:
print(-1)
``` |
p03666 AtCoder Grand Contest 017 - Moderate Differences | There are N squares in a row. The leftmost square contains the integer A, and the rightmost contains the integer B. The other squares are empty.
Aohashi would like to fill the empty squares with integers so that the following condition is satisfied:
* For any two adjacent squares, the (absolute) difference of the two integers in those squares is between C and D (inclusive).
As long as the condition is satisfied, it is allowed to use arbitrarily large or small integers to fill the squares. Determine whether it is possible to fill the squares under the condition.
Constraints
* 3 \leq N \leq 500000
* 0 \leq A \leq 10^9
* 0 \leq B \leq 10^9
* 0 \leq C \leq D \leq 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N A B C D
Output
Print `YES` if it is possible to fill the squares under the condition; print `NO` otherwise.
Examples
Input
5 1 5 2 4
Output
YES
Input
4 7 6 4 5
Output
NO
Input
48792 105960835 681218449 90629745 90632170
Output
NO
Input
491995 412925347 825318103 59999126 59999339
Output
YES | ```python
def ascending_range(i):
return (a+c*i, a+d*i)
def descendable_range(i, m, M):
j = n-1-i
floor = b+c*j
ceil = b+d*j
return not (m > ceil or M < floor)
def solve_local(i):
return descendable_range(i, *ascending_range(i))
n, a, b, c, d = map(int, input().split())
print("YES" if any(solve_local(i) for i in range(n)) else "NO")
``` |
p03821 AtCoder Grand Contest 009 - Multiple Array | There are an integer sequence A_1,...,A_N consisting of N terms, and N buttons. When the i-th (1 ≦ i ≦ N) button is pressed, the values of the i terms from the first through the i-th are all incremented by 1.
There is also another integer sequence B_1,...,B_N. Takahashi will push the buttons some number of times so that for every i, A_i will be a multiple of B_i.
Find the minimum number of times Takahashi will press the buttons.
Constraints
* All input values are integers.
* 1 ≦ N ≦ 10^5
* 0 ≦ A_i ≦ 10^9(1 ≦ i ≦ N)
* 1 ≦ B_i ≦ 10^9(1 ≦ i ≦ N)
Input
The input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Output
Print an integer representing the minimum number of times Takahashi will press the buttons.
Examples
Input
3
3 5
2 7
9 4
Output
7
Input
7
3 1
4 1
5 9
2 6
5 3
5 8
9 7
Output
22 | ```python
N = int(input())
AB = [[int(i) for i in input().split()] for _ in range(N)]
s = 0
for A, B in AB[::-1] :
x = (A + s + B - 1) // B
s += x * B - (A + s)
print(s)
``` |
p03988 AtCoder Grand Contest 005 - Tree Restoring | Aoki loves numerical sequences and trees.
One day, Takahashi gave him an integer sequence of length N, a_1, a_2, ..., a_N, which made him want to construct a tree.
Aoki wants to construct a tree with N vertices numbered 1 through N, such that for each i = 1,2,...,N, the distance between vertex i and the farthest vertex from it is a_i, assuming that the length of each edge is 1.
Determine whether such a tree exists.
Constraints
* 2 ≦ N ≦ 100
* 1 ≦ a_i ≦ N-1
Input
The input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
If there exists a tree that satisfies the condition, print `Possible`. Otherwise, print `Impossible`.
Examples
Input
5
3 2 2 3 3
Output
Possible
Input
3
1 1 2
Output
Impossible
Input
10
1 2 2 2 2 2 2 2 2 2
Output
Possible
Input
10
1 1 2 2 2 2 2 2 2 2
Output
Impossible
Input
6
1 1 1 1 1 5
Output
Impossible
Input
5
4 3 2 3 4
Output
Possible | ```python
from collections import defaultdict
def getlist():
return list(map(int, input().split()))
#処理内容
def main():
N = int(input())
D = defaultdict(int)
a = sorted(getlist())
if N == 2:
if a[0] != 1 or a[1] != 1:
print("Impossible")
else:
print("Possible")
else:
for i in range(N):
D[a[i]] += 1
if a[-1] % 2 != 0:
if a[0] * 2 - 1 != a[-1]:
print("Impossible")
else:
judge = "Possible"
if D[a[0]] != 2:
judge = "Impossible"
for i in range(a[0], a[-1] + 1):
if D[i] < 2:
judge = "Impossible"
break
print(judge)
else:
judge = "Possible"
if a[0] * 2 != a[-1]:
print("Impossible")
else:
judge = "Possible"
if D[a[0]] != 1:
judge = "Impossible"
for i in range(a[0] + 1, a[-1] + 1):
if D[i] < 2:
judge = "Impossible"
break
print(judge)
if __name__ == '__main__':
main()
``` |
p00076 Treasure Hunt II | As I was cleaning up the warehouse, I found an old document that describes how to get to the treasures of my ancestors. The following was written in this ancient document.
1. First, stand 1m east of the well on the outskirts of the town and turn straight toward the well.
2. Turn clockwise 90 degrees, go straight for 1m, and turn straight toward the well.
3. Turn clockwise 90 degrees, go straight for 1m, and turn straight toward the well.
Four. 〃
Five. 〃
6::
From the second line onward, exactly the same thing was written. You wanted to find the treasure, but found it awkward. Unlike in the past, the building is in the way, and you can't see the well even if you go straight in the direction of the well, or you can't go straight even if you try to go straight for 1m. In addition, this ancient document has nearly 1000 lines, and it takes a considerable amount of time and physical strength to work according to the ancient document. Fortunately, however, you can take advantage of your computer.
Enter the number of lines n written in the old document and create a program that outputs the location of the treasure. However, n is a positive integer between 2 and 1,000.
input
Given multiple datasets. For each dataset, one integer n, which represents the number of lines in the old document, is given on each line.
The input ends with -1. The number of datasets does not exceed 50.
output
Assuming that there is a treasure at the position x (m) to the east and y (m) to the north from the well on the outskirts of the town, output each data set in the following format.
x
y
The output is a real number and may contain an error of 0.01 or less.
Example
Input
3
6
-1
Output
0.29
1.71
-2.31
0.80 | ```python
# AOJ 0076 Treasure Hunt II
# Python3 2018.6.15 bal4u
import math
MAX = 1005
r, d = [0.0]*MAX, [0.0]*MAX
r[1] = 1.0
for i in range(2, MAX):
d[i] = d[i-1] + math.atan(1 / r[i-1])
r[i] = math.sqrt(r[i-1]**2 + 1)
while True:
i = int(input())
if i < 0: break
print(r[i]*math.cos(d[i]), r[i]*math.sin(d[i]), sep='\n')
``` |
p00208 Room Numbers of a Hospital | An architect, Devunky, who lives in Water Deven, has been asked to renovate an old large hospital.
In some countries, people don't want to use numbers that are disliked as numerophobia (4 and 9 are famous in Japan). However, the room numbers in this hospital were numbered from 1 regardless of the number of numerophobia.
Mr. Devunky, who was worried about it, renumbered the room with the numbers excluding "4" and "6", which are the numerophobia of Water Devon, before all the equipment and beds were replaced. However, since the replacement work was planned with the old room number, it is necessary to convert the old room number to the new room number to ensure that the rest of the work is done. Mr. Devunky, who is not good at calculations, is surprised to notice this.
For such Mr. Devunky, please create a program that inputs the old room number and outputs the corresponding new room number.
The correspondence table of room numbers up to the 15th is as follows.
Old room number | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15
--- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |- -| --- | --- | ---
New room number | 1 | 2 | 3 | 5 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 15 | 17 | 18 | 19
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. For each dataset, the integer n (1 ≤ n ≤ 1,000,000,000) representing the old room number is given on one line.
The number of datasets does not exceed 30000.
Output
Outputs the new room number on one line for each input dataset.
Example
Input
15
100
1000000000
3
0
Output
19
155
9358757000
3 | ```python
from sys import stdin
l=stdin.readlines()
for i in l[:-1]:print(oct(int(i))[2:].translate(str.maketrans("4567","5789")))
``` |
p00368 Checkered Pattern | You have a cross-section paper with W x H squares, and each of them is painted either in white or black. You want to re-arrange the squares into a neat checkered pattern, in which black and white squares are arranged alternately both in horizontal and vertical directions (the figure shown below is a checkered patter with W = 5 and H = 5). To achieve this goal, you can perform the following two operations as many times you like in an arbitrary sequence: swapping of two arbitrarily chosen columns, and swapping of two arbitrarily chosen rows.
<image>
Create a program to determine, starting from the given cross-section paper, if you can re-arrange them into a checkered pattern.
Input
The input is given in the following format.
W H
c1,1 c1,2 ... c1,W
c2,1 c2,2 ... c2,W
:
cH,1 cH,2 ... cH,W
The first line provides the number of squares in horizontal direction W (2≤W≤1000) and those in vertical direction H(2≤H≤1000). Each of subsequent H lines provides an array of W integers ci,j corresponding to a square of i-th row and j-th column. The color of the square is white if ci,j is 0, and black if it is 1.
Output
Output "yes" if the goal is achievable and "no" otherwise.
Examples
Input
3 2
1 1 0
0 0 1
Output
yes
Input
2 2
0 0
1 1
Output
no | ```python
is_ok = True
W, H = [int(i) for i in input().split()]
matrix = list()
for _ in range(H):
matrix.append([i for i in input().split()])
up = matrix[0]
not_up = [str(int(not int(i))) for i in up]
if abs(up.count("0") * 2 - W) >= 2:
is_ok = False
same = 1
for line in matrix[1:]:
if up[0] == line[0]:
same += 1
if up != line:
is_ok = False
break
elif not_up[0] == line[0] and not_up != line:
is_ok = False
break
if abs(same * 2 - H) >= 2:
is_ok = False
if is_ok:
print("yes")
else:
print("no")
``` |
p00575 Social Game | Problem statement
JOI decided to start a new social game from tomorrow.
In this social game, you can log in up to once a day, and you will get A coins each time you log in.
Also, if you log in for 7 consecutive days from Monday to Sunday, you will get an additional B coins each time.
No other coins will be given.
Tomorrow is Monday. Find the minimum number of times JOI must log in to get at least C coins.
Constraint
* 1 ≤ A ≤ 1000
* 0 ≤ B ≤ 1000
* 1 ≤ C ≤ 1000000 (= 10 ^ 6)
Input Output
input
Input is given from standard input in the following format.
A B C
output
Output the minimum number of times JOI must log in to get at least C coins.
<!-
Subtask
1. (40 points) B = 0
2. (60 points) There are no additional restrictions.
->
Input / output example
Input example 1
3 0 10
Output example 1
Four
* I want to get 3 coins per login and collect 10 coins.
* JOI can get 12 coins by logging in for 4 consecutive days from Monday.
* Since you cannot get more than 10 coins by logging in 3 times or less, the minimum number of times JOI must log in is 4. Therefore, 4 is output.
Input example 2
1 2 10
Output example 2
8
* You can get 1 coin for each login. Apart from that, you can get 2 coins by logging in for a week in a row. I want to collect 10 coins.
* If you log in consecutively from Monday to Sunday, you will get 2 coins in addition to 7 daily coins, so you will get a total of 9 coins. Therefore, if you log in one more time, you will get 10 coins.
* Since you cannot get more than 10 coins by logging in 7 times or less, the minimum number of times JOI must log in is 8. Therefore, 8 is output.
Creative Commons License
Information Olympics Japan Committee work "18th Japan Information Olympics JOI 2018/2019 Qualifying Competition Tasks"
Example
Input
3 0 10
Output
4 | ```python
n = [0 for i in range(3)]
n = input().split()
coin = int(n[2])
total = 0
count = 0
day = 0
while(total < coin):
total += int(n[0])
count += 1
if(count == 7):
total += int(n[1])
count = 0
day += 1
print(day)
``` |
p00722 Dirichlet's Theorem on Arithmetic Progressions | Good evening, contestants.
If a and d are relatively prime positive integers, the arithmetic sequence beginning with a and increasing by d, i.e., a, a + d, a + 2d, a + 3d, a + 4d, ..., contains infinitely many prime numbers. This fact is known as Dirichlet's Theorem on Arithmetic Progressions, which had been conjectured by Johann Carl Friedrich Gauss (1777 - 1855) and was proved by Johann Peter Gustav Lejeune Dirichlet (1805 - 1859) in 1837.
For example, the arithmetic sequence beginning with 2 and increasing by 3, i.e.,
> 2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95, 98, ... ,
contains infinitely many prime numbers
> 2, 5, 11, 17, 23, 29, 41, 47, 53, 59, 71, 83, 89, ... .
Your mission, should you decide to accept it, is to write a program to find the nth prime number in this arithmetic sequence for given positive integers a, d, and n.
As always, should you or any of your team be tired or confused, the secretary disavow any knowledge of your actions. This judge system will self-terminate in three hours. Good luck!
Input
The input is a sequence of datasets. A dataset is a line containing three positive integers a, d, and n separated by a space. a and d are relatively prime. You may assume a <= 9307, d <= 346, and n <= 210.
The end of the input is indicated by a line containing three zeros separated by a space. It is not a dataset.
Output
The output should be composed of as many lines as the number of the input datasets. Each line should contain a single integer and should never contain extra characters.
The output integer corresponding to a dataset a, d, n should be the nth prime number among those contained in the arithmetic sequence beginning with a and increasing by d.
FYI, it is known that the result is always less than 106 (one million) under this input condition.
Example
Input
367 186 151
179 10 203
271 37 39
103 230 1
27 104 185
253 50 85
1 1 1
9075 337 210
307 24 79
331 221 177
259 170 40
269 58 102
0 0 0
Output
92809
6709
12037
103
93523
14503
2
899429
5107
412717
22699
25673 | ```python
MAXN = 10**6
sieve = [0]*2 + [1]*MAXN
n = 2
while n*n <= MAXN:
if sieve[n]:
for i in range(2*n,MAXN+1,n):
sieve[i] = 0
n += 1
while True:
a,d,n = map(int,input().split())
if n == 0: break
cnt = 0
for i in range(a,MAXN+1,d):
if sieve[i]:
cnt += 1
if cnt == n:
print(i)
break
``` |
p00993 Numbers | Given n, find n consecutive positive integers. However, all numbers must have divisors other than 1 and the number itself.
Hint
In Sample Output 2, 8, 9 and 10 are selected as three consecutive integers.
The second and third lines output 3, as a divisor of 9, and the fourth line outputs 5, as a divisor of 10.
Input
The input is given in the following format.
n
The input meets the following constraints.
1 ≤ n ≤ 1,500
Output
Print the smallest of the n consecutive positive integers you choose on the first line.
Output the divisor for each value from the 2nd line to the n + 1 line.
Any value may be output unless the divisor is 1 or the number itself.
Let x be the number output on the first line, and output the divisor of x + i-2 on the i line.
The output value must not exceed 5,000 digits.
Examples
Input
2
Output
8
2
3
Input
3
Output
8
2
3
5 | ```python
# AOJ 1503: Numbers
# Python3 2018.7.13 bal4u
import sys
n = int(input())
if n == 1: print(4, 2, sep='\n'); sys.exit(0)
ans = 1
for i in range(2, n+2): ans *= i
print(ans+2)
for i in range(2, n+2): print(i)
``` |
p01125 Misterious Gems | From 1603 to 1867, people call that era the EDO era. EDO stands for Enhanced Driving Operation, the most advanced space navigation technology at the time, and was developed by Dr. Izy in 1603.
You are a space adventurer, flying around the universe and adventuring on various planets. During that adventure, you discovered a very mysterious planet. There were mysterious jewels shining in seven colors everywhere on the planet. You thought of trying to descend to that planet, but it turned out to be impossible due to serious problems. The planet's air contained highly toxic components that would kill them instantly when touched by humans.
So you came up with the idea of using a robot to collect the gems. You wait in the orbit of the planet. Then, the jewels are collected by remotely controlling the lowered robot. You remotely control the robot by means of a sequence of commands consisting of a set of "direction of movement" and "distance to move". When the robot finds jewels on the movement path (including the destination), it collects all of them.
Your job is to write a program that determines if the robot was able to retrieve all the gems when it finished executing all the given commands.
The range in which the robot collects mysterious gems is not so wide. Therefore, the range in which the robot moves can be represented by a two-dimensional plane. The range of movement of the robot is the inside of the square (including the boundary line) with (0,0) and (20,20) as the lower left corner and the upper right corner, respectively. The robot always descends to the center of the range, that is, the coordinates (10,10). Also, all gems are guaranteed to be on grid points other than the center.
Input
The input consists of multiple datasets.
The first row of each dataset contains a single positive integer N (1 <= N <= 20). This represents the number of mysterious gems within the range that the robot can move. The next N lines contain xi and yi (0 <= xi, yi <= 20), respectively, which represent the falling coordinates of the i-th mysterious gem. There are no multiple gems in one place.
The next line contains a single integer M (1 <= M <= 30), which represents the number of instructions given to the robot. Subsequent M lines contain dj and one positive integer lj, respectively. This represents the direction and the amount of movement in the jth instruction. However, the direction is one of the letters N, E, S, W, which represents north, east, south, and west in that order (north is the positive direction of the y-axis, east is the positive direction of the x-axis). It is guaranteed that commands that exceed the range in which the robot can move are not given.
The input ends when N = 0, which is not included in the dataset.
Output
For each dataset, print "Yes" if the robot can collect all the gems, and "No" otherwise.
Sample Input
2
10 11
11 12
2
N 2
E 1
2
10 11
11 12
2
N 2
W 1
3
0 15
5 10
5 15
Five
W 10
S 10
N 20
E 10
S 10
0
Output for the Sample Input
Yes
No
No
Example
Input
2
10 11
11 12
2
N 2
E 1
2
10 11
11 12
2
N 2
W 1
3
0 15
5 10
5 15
5
W 10
S 10
N 20
E 10
S 10
0
Output
Yes
No
No | ```python
#coding: utf-8
if __name__ == '__main__':
while True:
n = int(input())
if n == 0:
break
flag = []
for i in range(21):
flag.append([0 for j in range(21)])
for i in range(n):
x,y = map(int,input().split())
flag[x][y] = 1;
m = int(input())
nx,ny = 10,10
for i in range(m):
dre,num = input().split()
num = int(num)
if dre == 'N':
for i in range(num):
ny += 1
if flag[nx][ny] == 1:
flag[nx][ny] = 0
elif dre == 'W':
for i in range(num):
nx -= 1
if flag[nx][ny] == 1:
flag[nx][ny] = 0
elif dre == 'E':
for i in range(num):
nx += 1
if flag[nx][ny] == 1:
flag[nx][ny] = 0
else:
for i in range(num):
ny -= 1
if flag[nx][ny] == 1:
flag[nx][ny] = 0
ans = True
for i in range(21):
for j in range(21):
if flag[i][j] == 1:
ans = False
if ans:
print('Yes')
else:
print('No')
``` |
p01880 Best Matched Pair | Example
Input
2
1 2
Output
2 | ```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
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 = I()
a = LI()
r = -1
for i in range(n):
b = a[i]
for c in a[i+1:]:
t = b*c
if r >= t:
continue
s = str(t)
if all([int(s[k]) == int(s[k+1])-1 for k in range(len(s)-1)]):
r = t
rr.append(r)
break
return '\n'.join(map(str, rr))
print(main())
``` |
p02017 Pray | C: Prayer (Pray)
Some twins are famous for praying before the contest.
There are four integers $ H, W, X, Y $, and it seems unlucky if $ H \ times W $ and $ x + y $ are both odd numbers.
input
Four integers $ H, W, X, Y $ are given, separated by spaces.
output
Output "No" if you are unlucky, or "Yes" if not. But don't forget the last line break.
Constraint
* $ H, W, X, Y $ are integers greater than or equal to $ 1 $ and less than or equal to $ 100 $
Input example 1
3 5 1 4
Output example 1
No
$ 3 \ times 5 = 15 $, $ 1 + 4 = 5 $, both odd numbers, so it's unlucky.
Input example 2
3 5 2 4
Output example 2
Yes
$ 3 \ times 5 = 15 $ is odd, but $ 2 + 4 = 6 $ is even, so good luck isn't bad.
Example
Input
3 5 1 4
Output
No | ```python
a,b,c,d=map(int,input().split())
print("No" if ((a*b)%2)*((c+d)%2)==1 else "Yes")
``` |
p02300 Convex Hull | Find the convex hull of a given set of points P. In other words, find the smallest convex polygon containing all the points of P. Here, in a convex polygon, all interior angles are less than or equal to 180 degrees.
Please note that you should find all the points of P on both corner and boundary of the convex polygon.
Constraints
* 3 ≤ n ≤ 100000
* -10000 ≤ xi, yi ≤ 10000
* No point in the P will occur more than once.
Input
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points in P. The coordinate of the i-th point pi is given by two integers xi and yi.
Output
In the first line, print the number of points on the corner/boundary of the convex polygon. In the following lines, print x y coordinates of the set of points. The coordinates should be given in the order of counter-clockwise visit of them starting from the point in P with the minimum y-coordinate, or the leftmost such point in case of a tie.
Examples
Input
7
2 1
0 0
1 2
2 2
4 2
1 3
3 3
Output
5
0 0
2 1
4 2
3 3
1 3
Input
4
0 0
2 2
0 2
0 1
Output
4
0 0
2 2
0 2
0 1 | ```python
import math
EPS = 1e-10
class Vector2():
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, v):
return Vector2(self.x+v.x, self.y+v.y)
def __sub__(self, v):
return Vector2(self.x-v.x, self.y-v.y)
def __mul__(self, v):
return Vector2(self.x*v, self.y*v)
def __truediv__(self, v):
return Vector2(self.x/v, self.y/v)
def __abs__(self):
return math.sqrt(float(self.x*self.x+self.y*self.y))
def __str__(self):
return f"({self.x},{self.y})"
def __lt__(self, v):
if math.isclose(self.x, v.x):
return self.y < v.y
return self.x < v.x
def dot(self, v):
return self.x*v.x+self.y*v.y
def cross(self, v):
return self.x*v.y-self.y*v.x
def norm(self):
d = abs(self)
return Vector2(self.x/d, self.y/d)
def projection(v1, v2, p):
v12 = (v2-v1).norm()
v1p = p-v1
d = v12.dot(v1p)
return v1+v12*d
def distanceLP(v1, v2, p):
'''
v1 -> v2の直線とpとの距離
'''
return abs((v2-v1).cross(p-v1))/abs(v2-v1)
def distanceSP(v1, v2, p):
'''
v1 -> v2の線分とpとの距離
'''
if (v2-v1).dot(p-v1) < 0.0:
return abs(p-v1)
if (v1-v2).dot(p-v2) < 0.0:
return abs(p-v2)
return distanceLP(v1, v2, p)
def ccw(p0, p1, p2):
c = (p1-p0).cross(p2-p0)
if math.isclose(c, 0.0, abs_tol=EPS):
d = (p1-p0).dot(p2-p0)
if d < 0.0:
return 2
else:
d1 = abs(p1-p0)
d2 = abs(p2-p0)
if d1 < d2:
return -2
else:
return 0
elif c < 0.0:
return -1
else:
return 1
def intersect(p1, p2, p3, p4):
'''
p1p2とp3p4の交差判定
'''
# t1 = (p1.x-p2.x)*(p3.y-p1.y)+(p1.y-p2.y)*(p1.x-p3.x)
# t2 = (p1.x-p2.x)*(p4.y-p1.y)+(p1.y-p2.y)*(p1.x-p4.x)
# t3 = (p3.x-p4.x)*(p1.y-p3.y)+(p3.y-p4.y)*(p3.x-p1.x)
# t4 = (p3.x-p4.x)*(p2.y-p3.y)+(p3.y-p4.y)*(p3.x-p2.x)
# return (t1*t2) <= 0.0 and (t3*t4) <= 0.0
c1 = ccw(p1, p2, p3)*ccw(p1, p2, p4)
c2 = ccw(p3, p4, p1)*ccw(p3, p4, p2)
return c1 <= 0.0 and c2 <= 0.0
def distance(a1, a2, b1, b2):
'''
線分a1a2とb1b2の距離
'''
if intersect(a1, a2, b1, b2):
return 0.0
return min([
min([distanceSP(a1, a2, b1), distanceSP(a1, a2, b2)]),
min([distanceSP(b1, b2, a1), distanceSP(b1, b2, a2)])
])
n = int(input())
p = [list(map(int, input().split())) for _ in range(n)]
'''
凸包を求める
アンドリューのアルゴリズム
'''
u, l = [], []
p.sort()
# 凸部上方
u.append(p[0])
u.append(p[1])
for i in range(2, n):
pv = Vector2(p[i][0], p[i][1])
while len(u) > 1:
p1 = Vector2(u[-1][0], u[-1][1])
p2 = Vector2(u[-2][0], u[-2][1])
if ccw(p2, p1, pv) == 1.0:
u.pop(-1)
else:
break
u.append(p[i])
# 凸部下方
l.append(p[-1])
l.append(p[-2])
for i in range(n-3, -1, -1):
pv = Vector2(p[i][0], p[i][1])
while len(l) > 1:
p1 = Vector2(l[-1][0], l[-1][1])
p2 = Vector2(l[-2][0], l[-2][1])
if ccw(p2, p1, pv) == 1.0:
l.pop(-1)
else:
break
l.append(p[i])
l.reverse()
ans = l+list(reversed(u[1:-1]))
print(len(ans))
si = 0
for i, v in enumerate(ans):
if v[1] < ans[si][1]:
si = i
for i in range(len(ans)):
print(f"{ans[(i+si)%len(ans)][0]} {ans[(i+si)%len(ans)][1]}")
``` |
p02447 Sorting Pairs | Write a program which print coordinates $(x_i, y_i)$ of given $n$ points on the plane by the following criteria.
1. first by $x$-coordinate
2. in case of a tie, by $y$-coordinate
Constraints
* $1 \leq n \leq 100,000$
* $-1,000,000,000 \leq x_i, y_i \leq 1,000,000,000$
Input
The input is given in the following format.
$n$
$x_0 \; y_0$
$x_1 \; y_1$
:
$x_{n-1} \; y_{n-1}$
In the first line, the number of points $n$ is given. In the following $n$ lines, coordinates of each point are given.
Output
Print coordinate of given points in order.
Example
Input
5
4 7
5 5
2 3
6 8
2 1
Output
2 1
2 3
4 7
5 5
6 8 | ```python
from sys import stdin
n = int(stdin.readline())
l = []
for i in range(n):
a,b = map(int,stdin.readline().split())
l.append([a,b])
l.sort()
for i in range(n):
print(f'{l[i][0]} {l[i][1]}')
``` |
1056_D. Decorate Apple Tree | There is one apple tree in Arkady's garden. It can be represented as a set of junctions connected with branches so that there is only one way to reach any junctions from any other one using branches. The junctions are enumerated from 1 to n, the junction 1 is called the root.
A subtree of a junction v is a set of junctions u such that the path from u to the root must pass through v. Note that v itself is included in a subtree of v.
A leaf is such a junction that its subtree contains exactly one junction.
The New Year is coming, so Arkady wants to decorate the tree. He will put a light bulb of some color on each leaf junction and then count the number happy junctions. A happy junction is such a junction t that all light bulbs in the subtree of t have different colors.
Arkady is interested in the following question: for each k from 1 to n, what is the minimum number of different colors needed to make the number of happy junctions be greater than or equal to k?
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of junctions in the tree.
The second line contains n - 1 integers p_2, p_3, ..., p_n (1 ≤ p_i < i), where p_i means there is a branch between junctions i and p_i. It is guaranteed that this set of branches forms a tree.
Output
Output n integers. The i-th of them should be the minimum number of colors needed to make the number of happy junctions be at least i.
Examples
Input
3
1 1
Output
1 1 2
Input
5
1 1 3 3
Output
1 1 1 2 3
Note
In the first example for k = 1 and k = 2 we can use only one color: the junctions 2 and 3 will be happy. For k = 3 you have to put the bulbs of different colors to make all the junctions happy.
In the second example for k = 4 you can, for example, put the bulbs of color 1 in junctions 2 and 4, and a bulb of color 2 into junction 5. The happy junctions are the ones with indices 2, 3, 4 and 5 then. | ```python
n=int(input())
p=[0,0]+list(map(int,input().split()))#tomamos la entrada
d=[0]*(n+1)#aki vamos a contar la cantidad d colores q necesita cada union
for i in range(n,1,-1):#empezamos x las hojas hasta llegar a la raiz
if d[i]==0:#si no estas visitado eres una hoja => solo necesitas un color
d[i]=1
d[p[i]]+=d[i]#si no necesitas tantos colores como la cantidad q necesitan tus hijos
if n==1:#si la entrada es 1 solo necesitas un color
d[1]=1
d=d[1:]#quitamos el vertice 0(al final todo empieza en 1-n)
d.sort()#ordenamos para dar la cantidad d colores en orden d los vertices(o sea, de k)
print(*d)
``` |
1078_E. Negative Time Summation | Everyone knows that computers become faster and faster. Recently Berland scientists have built a machine that can move itself back in time!
More specifically, it works as follows. It has an infinite grid and a robot which stands on one of the cells. Each cell of the grid can either be empty or contain 0 or 1. The machine also has a program which consists of instructions, which are being handled one by one. Each instruction is represented by exactly one symbol (letter or digit) and takes exactly one unit of time (say, second) to be performed, except the last type of operation (it's described below). Here they are:
* 0 or 1: the robot places this number into the cell he is currently at. If this cell wasn't empty before the operation, its previous number is replaced anyway.
* e: the robot erases the number into the cell he is at.
* l, r, u or d: the robot goes one cell to the left/right/up/down.
* s: the robot stays where he is for a unit of time.
* t: let x be 0, if the cell with the robot is empty, otherwise let x be one more than the digit in this cell (that is, x = 1 if the digit in this cell is 0, and x = 2 if the digit is 1). Then the machine travels x seconds back in time. Note that this doesn't change the instructions order, but it changes the position of the robot and the numbers in the grid as they were x units of time ago. You can consider this instruction to be equivalent to a Ctrl-Z pressed x times.
For example, let the board be completely empty, and the program be sr1t0. Let the robot initially be at (0, 0).
* [now is the moment 0, the command is s]: we do nothing.
* [now is the moment 1, the command is r]: we are now at (1, 0).
* [now is the moment 2, the command is 1]: we are at (1, 0), and this cell contains 1.
* [now is the moment 3, the command is t]: we travel 1 + 1 = 2 moments back, that is, to the moment 1.
* [now is the moment 1, the command is 0]: we are again at (0, 0), and the board is clear again, but after we follow this instruction, this cell has 0 in it. We've just rewritten the history. The consequences of the third instruction have never happened.
Now Berland scientists want to use their machine in practice. For example, they want to be able to add two integers.
Assume that the initial state of the machine is as follows:
* One positive integer is written in binary on the grid in such a way that its right bit is at the cell (0, 1), from left to right from the highest bit to the lowest bit.
* The other positive integer is written in binary on the grid in such a way that its right bit is at the cell (0, 0), from left to right from the highest bit to the lowest bit.
* All the other cells are empty.
* The robot is at (0, 0).
* We consider this state to be always in the past; that is, if you manage to travel to any negative moment, the board was always as described above, and the robot was at (0, 0) for eternity.
You are asked to write a program after which
* The robot stands on a non-empty cell,
* If we read the number starting from the cell with the robot and moving to the right until the first empty cell, this will be a + b in binary, from the highest bit to the lowest bit.
Note that there are no restrictions on other cells. In particular, there may be a digit just to the left to the robot after all instructions.
In each test you are given up to 1000 pairs (a, b), and your program must work for all these pairs. Also since the machine's memory is not very big, your program must consist of no more than 10^5 instructions.
Input
The first line contains the only integer t (1≤ t≤ 1000) standing for the number of testcases. Each of the next t lines consists of two positive integers a and b (1≤ a, b < 2^{30}) in decimal.
Output
Output the only line consisting of no more than 10^5 symbols from 01eslrudt standing for your program.
Note that formally you may output different programs for different tests.
Example
Input
2
123456789 987654321
555555555 555555555
Output
0l1l1l0l0l0l1l1l1l0l1l0l1l1l0l0l0l1l0l1l1l1l0l0l0l1l0l0l0l0l1l0lr | ```python
def C(x, y):
return x + '10' + y + 't' + y
def CBF(x, y):
return x + '01' + y + 't' + y
Cr = C('r', 'l')
Cl = C('l', 'r')
Cu = C('u', 'd')
Cd = C('d', 'u')
CBFr = CBF('r', 'l')
CBFl = CBF('l', 'r')
CBFu = CBF('u', 'd')
CBFd = CBF('d', 'u')
def CE(x, y):
return x+x+'0'+x+'1'+y+y+'10'+y+'t'+x+x+'t'+y+x+x+'e'+x+'e'+y+y+y
def MNE(x, y):
return CE(x, y) + x + C(y, x) + 'e' + y
def MNEall(n):
return (MNE('d', 'u') + 'l') * n + 'r' * n + 'u' + (MNE('u', 'd') + 'l') * n + 'r' * n + 'd'
def ADD():
return 'u' + Cu + 'u' + Cu + 'dd' + Cu + 'u' + Cu + 'u' + Cl + '010ltut' + Cd + 'dd'
def ADDc():
return ADD() + '0ulrtd' + ADD() + 'lltr'
def ADDbit():
return 'u' + Cu + 'u' + Cl + 'll0l1rrr' + ADDc() + 'dd' + Cu + 'u' + Cu + 'u' + Cl + ADDc() + 'dd'
def full(n):
return MNEall(n) + 'uuu' + '0l' * (n+1) + 'r' * (n+1) + 'ddd' + (ADDbit() + 'l') * n + 'uuu'
print(full(30))
``` |
111_D. Petya and Coloring | Little Petya loves counting. He wants to count the number of ways to paint a rectangular checkered board of size n × m (n rows, m columns) in k colors. Besides, the coloring should have the following property: for any vertical line that passes along the grid lines and divides the board in two non-empty parts the number of distinct colors in both these parts should be the same. Help Petya to count these colorings.
Input
The first line contains space-separated integers n, m and k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 106) — the board's vertical and horizontal sizes and the number of colors respectively.
Output
Print the answer to the problem. As the answer can be quite a large number, you should print it modulo 109 + 7 (1000000007).
Examples
Input
2 2 1
Output
1
Input
2 2 2
Output
8
Input
3 2 2
Output
40 | ```python
n, m, k = [int(x) for x in input().split()]
mod = int(10**9 + 7)
if m == 1:
print(pow(k, n, mod))
exit()
ans = 0
fac = [1]
ifac = [1]
tav = [0]
for i in range(1, max(k + 1, n + 1)):
fac.append((fac[i - 1] * i) % mod)
for i in range(1, min(k + 1, n + 1)):
ifac.append((ifac[i - 1] * pow(i, mod - 2, mod)) % mod)
tav.append(pow(i, n * (m - 2), mod))
if m == 2:
tav[0] = 1
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n + 1):
for j in range(i, 1, -1):
dp[j] = (j * dp[j] + dp[j - 1]) % mod
for i in range(1, min(k + 1, n + 1)):
for j in range(0, i + 1):
if 2 * i - j > k:
continue
ans = (ans + ((((dp[i] * dp[i] * fac[i] * fac[i]) % mod) * tav[j] * ifac[i - j] * fac[k]) % mod) * pow(fac[k - 2 * i + j], mod - 2, mod) * ifac[i - j] * ifac[j]) % mod
print(ans)
``` |
1147_A. Hide and Seek | Alice and Bob are playing a game on a line with n cells. There are n cells labeled from 1 through n. For each i from 1 to n-1, cells i and i+1 are adjacent.
Alice initially has a token on some cell on the line, and Bob tries to guess where it is.
Bob guesses a sequence of line cell numbers x_1, x_2, …, x_k in order. In the i-th question, Bob asks Alice if her token is currently on cell x_i. That is, Alice can answer either "YES" or "NO" to each Bob's question.
At most one time in this process, before or after answering a question, Alice is allowed to move her token from her current cell to some adjacent cell. Alice acted in such a way that she was able to answer "NO" to all of Bob's questions.
Note that Alice can even move her token before answering the first question or after answering the last question. Alice can also choose to not move at all.
You are given n and Bob's questions x_1, …, x_k. You would like to count the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Let (a,b) denote a scenario where Alice starts at cell a and ends at cell b. Two scenarios (a_i, b_i) and (a_j, b_j) are different if a_i ≠ a_j or b_i ≠ b_j.
Input
The first line contains two integers n and k (1 ≤ n,k ≤ 10^5) — the number of cells and the number of questions Bob asked.
The second line contains k integers x_1, x_2, …, x_k (1 ≤ x_i ≤ n) — Bob's questions.
Output
Print a single integer, the number of scenarios that let Alice answer "NO" to all of Bob's questions.
Examples
Input
5 3
5 1 4
Output
9
Input
4 8
1 2 3 4 4 3 2 1
Output
0
Input
100000 1
42
Output
299997
Note
The notation (i,j) denotes a scenario where Alice starts at cell i and ends at cell j.
In the first example, the valid scenarios are (1, 2), (2, 1), (2, 2), (2, 3), (3, 2), (3, 3), (3, 4), (4, 3), (4, 5). For example, (3,4) is valid since Alice can start at cell 3, stay there for the first three questions, then move to cell 4 after the last question.
(4,5) is valid since Alice can start at cell 4, stay there for the first question, the move to cell 5 for the next two questions. Note that (4,5) is only counted once, even though there are different questions that Alice can choose to do the move, but remember, we only count each pair of starting and ending positions once.
In the second example, Alice has no valid scenarios.
In the last example, all (i,j) where |i-j| ≤ 1 except for (42, 42) are valid scenarios. | ```python
from collections import Counter
nums, num_questions = map(int, input().split())
questions = list(map(int, input().split()))
exist = set()
things = dict(Counter(questions))
nums = nums * 3 - 2 - len(things)
for i in questions:
if i not in exist:
exist.add(i)
if things.get(i - 1):
nums -= 1
if things.get(i + 1):
nums -= 1
things[i] -= 1
print(nums)
``` |
1168_B. Good Triple | Toad Rash has a binary string s. A binary string consists only of zeros and ones.
Let n be the length of s.
Rash needs to find the number of such pairs of integers l, r that 1 ≤ l ≤ r ≤ n and there is at least one pair of integers x, k such that 1 ≤ x, k ≤ n, l ≤ x < x + 2k ≤ r, and s_x = s_{x+k} = s_{x+2k}.
Find this number of pairs for Rash.
Input
The first line contains the string s (1 ≤ |s| ≤ 300 000), consisting of zeros and ones.
Output
Output one integer: the number of such pairs of integers l, r that 1 ≤ l ≤ r ≤ n and there is at least one pair of integers x, k such that 1 ≤ x, k ≤ n, l ≤ x < x + 2k ≤ r, and s_x = s_{x+k} = s_{x+2k}.
Examples
Input
010101
Output
3
Input
11001100
Output
0
Note
In the first example, there are three l, r pairs we need to count: 1, 6; 2, 6; and 1, 5.
In the second example, there are no values x, k for the initial string, so the answer is 0. | ```python
def func(st,en):
for i in range(st,en+1):
for j in range(i+1,en+1 ):
if (j-i+1)%2==1:
if s[(i+j)//2]==s[i]==s[j]:
return False
#print(st, en)
return True
s=input().strip()
c=0
n=len(s)
for i in range(2,9):
for j in range(len(s)):
if i+j<len(s):
if func(j,j+i):
c+=1
print((n*(n+1))//2 - c-n-n+1)
``` |
1186_E. Vus the Cossack and a Field | Vus the Cossack has a field with dimensions n × m, which consists of "0" and "1". He is building an infinite field from this field. He is doing this in this way:
1. He takes the current field and finds a new inverted field. In other words, the new field will contain "1" only there, where "0" was in the current field, and "0" there, where "1" was.
2. To the current field, he adds the inverted field to the right.
3. To the current field, he adds the inverted field to the bottom.
4. To the current field, he adds the current field to the bottom right.
5. He repeats it.
For example, if the initial field was:
\begin{matrix} 1 & 0 & \\\ 1 & 1 & \\\ \end{matrix}
After the first iteration, the field will be like this:
\begin{matrix} 1 & 0 & 0 & 1 \\\ 1 & 1 & 0 & 0 \\\ 0 & 1 & 1 & 0 \\\ 0 & 0 & 1 & 1 \\\ \end{matrix}
After the second iteration, the field will be like this:
\begin{matrix} 1 & 0 & 0 & 1 & 0 & 1 & 1 & 0 \\\ 1 & 1 & 0 & 0 & 0 & 0 & 1 & 1 \\\ 0 & 1 & 1 & 0 & 1 & 0 & 0 & 1 \\\ 0 & 0 & 1 & 1 & 1 & 1 & 0 & 0 \\\ 0 & 1 & 1 & 0 & 1 & 0 & 0 & 1 \\\ 0 & 0 & 1 & 1 & 1 & 1 & 0 & 0 \\\ 1 & 0 & 0 & 1 & 0 & 1 & 1 & 0 \\\ 1 & 1 & 0& 0 & 0 & 0 & 1 & 1 \\\ \end{matrix}
And so on...
Let's numerate lines from top to bottom from 1 to infinity, and columns from left to right from 1 to infinity. We call the submatrix (x_1, y_1, x_2, y_2) all numbers that have coordinates (x, y) such that x_1 ≤ x ≤ x_2 and y_1 ≤ y ≤ y_2.
The Cossack needs sometimes to find the sum of all the numbers in submatrices. Since he is pretty busy right now, he is asking you to find the answers!
Input
The first line contains three integers n, m, q (1 ≤ n, m ≤ 1 000, 1 ≤ q ≤ 10^5) — the dimensions of the initial matrix and the number of queries.
Each of the next n lines contains m characters c_{ij} (0 ≤ c_{ij} ≤ 1) — the characters in the matrix.
Each of the next q lines contains four integers x_1, y_1, x_2, y_2 (1 ≤ x_1 ≤ x_2 ≤ 10^9, 1 ≤ y_1 ≤ y_2 ≤ 10^9) — the coordinates of the upper left cell and bottom right cell, between which you need to find the sum of all numbers.
Output
For each query, print the answer.
Examples
Input
2 2 5
10
11
1 1 8 8
2 4 5 6
1 2 7 8
3 3 6 8
5 6 7 8
Output
32
5
25
14
4
Input
2 3 7
100
101
4 12 5 17
5 4 9 4
1 4 13 18
12 1 14 9
3 10 7 18
3 15 12 17
8 6 8 12
Output
6
3
98
13
22
15
3
Note
The first example is explained in the legend. | ```python
from sys import stdin,stdout
n,m,q = map(int, stdin.readline().split())
mat = [[0]*m for i in range(n)]
for i in range(n):
row = stdin.readline().strip()
for j,c in enumerate(row):
mat[i][j] = 1 if c == '1' else -1
#print(mat)
def get(a,b):
if a < 0 or b < 0:
return 0
x = a^b
ans = 1
while x > 0:
if x % 2 == 1:
ans *= -1
x //= 2
return ans
row_sums = [[0]*(m+1) for i in range(n+1)]
for i in range(n):
for j in range(m):
row_sums[i+1][j+1] = row_sums[i][j+1] + mat[i][j]
#print(row_sums)
mat_sums = [[0]*(m+1) for i in range(n+1)]
for i in range(n):
for j in range(m):
mat_sums[i+1][j+1] = mat_sums[i+1][j] + row_sums[i+1][j+1]
#print(mat_sums)
total = mat_sums[n][m]
def rect_sum(a, b):
if a == 0 or b == 0:
return 0
top_edge = 0
right_edge = 0
small = 0
x = a//n
x_rem = a%n
y = b // m
y_rem = b%m
# print("x", x, "y", y, "x_rem", x_rem, "y_rem", y_rem)
big = 0 if x % 2 == 0 or y % 2 == 0 else total
big *= get(x-1,y-1)
if x % 2 == 1:
right_edge= mat_sums[n][y_rem]
right_edge *= get(x-1,y)
if y % 2 == 1:
top_edge = mat_sums[x_rem][m]
top_edge *= get(x,y-1)
small = mat_sums[x_rem][y_rem]
small *= get(x,y)
# print("big", big, "top", top_edge, "right", right_edge, "small", small)
return top_edge + right_edge+small+big
for it in range(q):
x1,y1,x2,y2 = map(int, stdin.readline().split())
ans = rect_sum(x2,y2) - rect_sum(x1-1, y2) - rect_sum(x2, y1-1) + rect_sum(x1-1,y1-1)
ans = ((x2-x1+1)*(y2-y1+1) + ans)//2
stdout.write(str(ans) + '\n')
``` |
1205_D. Almost All | You are given a tree with n nodes. You have to write non-negative integers on its edges so that the following condition would be satisfied:
For every two nodes i, j, look at the path between them and count the sum of numbers on the edges of this path. Write all obtained sums on the blackboard. Then every integer from 1 to ⌊ (2n^2)/(9) ⌋ has to be written on the blackboard at least once.
It is guaranteed that such an arrangement exists.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of nodes.
Each of the next n-1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v), meaning that there is an edge between nodes u and v. It is guaranteed that these edges form a tree.
Output
Output n-1 lines, each of form u v x (0 ≤ x ≤ 10^6), which will mean that you wrote number x on the edge between u, v.
Set of edges (u, v) has to coincide with the set of edges of the input graph, but you can output edges in any order. You can also output ends of edges in an order different from the order in input.
Examples
Input
3
2 3
2 1
Output
3 2 1
1 2 2
Input
4
2 4
2 3
2 1
Output
4 2 1
3 2 2
1 2 3
Input
5
1 2
1 3
1 4
2 5
Output
2 1 1
5 2 1
3 1 3
4 1 6
Note
In the first example, distance between nodes 1 and 2 is equal to 2, between nodes 2 and 3 to 1, between 1 and 3 to 3.
In the third example, numbers from 1 to 9 (inclusive) will be written on the blackboard, while we need just from 1 to 5 to pass the test. | ```python
import math
n = int(input())
if n == 1:
print()
else:
edge = [list(map(int, input().split())) for i in range(1, n) ]
g = {}
for x, y in edge:
if x not in g:
g[x] = []
if y not in g:
g[y] = []
g[x].append(y)
g[y].append(x)
def find_centroid(g):
p = {}
size = {}
p[1] = -1
Q = [1]
i = 0
while i < len(Q):
u = Q[i]
for v in g[u]:
if p[u] == v: continue
p[v] = u
Q.append(v)
i+=1
for u in Q[::-1]:
size[u] = 1
for v in g[u]:
if p[u] == v:
continue
size[u] += size[v]
cur = 1
n = size[cur]
while True:
max_ = n - size[cur]
ind_ = p[cur]
for v in g[cur]:
if v == p[cur]: continue
if size[v] > max_:
max_ = size[v]
ind_ = v
if max_ <= n // 2:
return cur
cur = ind_
def find_center(g):
d = {}
d[1] = 0
Q = [(1, 0)]
while len(Q) > 0:
u, dis = Q.pop(0)
for v in g[u]:
if v not in d:
d[v] = dis +1
Q.append((v, d[v]))
max_length = -1
s = None
for u, dis in d.items():
if dis > max_length:
max_length = dis
s = u
d = {}
pre = {}
d[s] = 0
Q = [(s, 0)]
while len(Q) > 0:
u, dis = Q.pop(0)
for v in g[u]:
if v not in d:
pre[v] = u
d[v] = dis +1
Q.append((v, d[v]))
max_length = -1
e = None
for u, dis in d.items():
if dis > max_length:
max_length = dis
e = u
route = [e]
while pre[route[-1]] != s:
route.append(pre[route[-1]])
print(route)
return route[len(route) // 2]
root = find_centroid(g)
p = {}
size = {}
Q = [root]
p[root] = -1
i = 0
while i < len(Q):
u = Q[i]
for v in g[u]:
if p[u] == v: continue
p[v] = u
Q.append(v)
i+=1
for u in Q[::-1]:
size[u] = 1
for v in g[u]:
if p[u] == v:
continue
size[u] += size[v]
gr = [(u, size[u]) for u in g[root]]
gr = sorted(gr, key=lambda x:x[1])
thres = math.ceil((n-1) / 3)
sum_ = 0
gr1 = []
gr2 = []
i = 0
while sum_ < thres:
gr1.append(gr[i][0])
sum_ += gr[i][1]
i+=1
while i < len(gr):
gr2.append(gr[i][0])
i+=1
def asign(u, W, ew):
if size[u] == 1:
return
cur = 0
for v in g[u]:
if v == p[u]: continue
first = W[cur]
ew.append((u, v, first))
W_ = [x - first for x in W[cur+1: cur+size[v]]]
asign(v, W_, ew)
cur+=size[v]
a, b = 0, 0
for x in gr1:
a += size[x]
for x in gr2:
b += size[x]
arr_1 = [x for x in range(1, a+1)]
arr_2 = [i*(a+1) for i in range(1, b+1)]
ew = []
cur = 0
for u in gr1:
first = arr_1[cur]
ew.append((root, u, first))
W_ = [x - first for x in arr_1[cur+1:cur+size[u]]]
cur += size[u]
#print(u, W_)
asign(u, W_, ew)
cur = 0
for u in gr2:
first = arr_2[cur]
ew.append((root, u, first))
W_ = [x - first for x in arr_2[cur+1:cur+size[u]]]
cur += size[u]
#print(u, W_)
asign(u, W_, ew)
for u, v, w in ew:
print('{} {} {}'.format(u, v, w))
``` |
1223_A. CME | Let's denote correct match equation (we will denote it as CME) an equation a + b = c there all integers a, b and c are greater than zero.
For example, equations 2 + 2 = 4 (||+||=||||) and 1 + 2 = 3 (|+||=|||) are CME but equations 1 + 2 = 4 (|+||=||||), 2 + 2 = 3 (||+||=|||), and 0 + 1 = 1 (+|=|) are not.
Now, you have n matches. You want to assemble a CME using all your matches. Unfortunately, it is possible that you can't assemble the CME using all matches. But you can buy some extra matches and then assemble CME!
For example, if n = 2, you can buy two matches and assemble |+|=||, and if n = 5 you can buy one match and assemble ||+|=|||.
<image>
Calculate the minimum number of matches which you have to buy for assembling CME.
Note, that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries.
The only line of each query contains one integer n (2 ≤ n ≤ 10^9) — the number of matches.
Output
For each test case print one integer in single line — the minimum number of matches which you have to buy for assembling CME.
Example
Input
4
2
5
8
11
Output
2
1
0
1
Note
The first and second queries are explained in the statement.
In the third query, you can assemble 1 + 3 = 4 (|+|||=||||) without buying matches.
In the fourth query, buy one match and assemble 2 + 4 = 6 (||+||||=||||||). | ```python
# import numpy as np
import array
def solution():
req = int(input())
for i in range(req):
count = int(input())
result = 0
if count==2:
print(2)
continue
while count % 2 != 0 :
result+=1
count+=1
print(result)
def count_of_one(number):
result = 0
while number:
result += number % 2
number //= 2
return result
def to_mixed_frac(first, second):
while True:
for i in range(2, first + 1):
if first % i == 0 and second % i == 0:
first //= i
second //= i
break
else:
break
return str(first) + "/" + str(second)
def array_to_int(array):
for i in range(len(array)):
array[i] = int(array[i])
return array
def join0(array):
result = ""
for i in array:
result += str(i)
return result
def replace(string, new_ch, index):
new_str = ""
for i in range(len(string)):
if i == index:
new_str += new_ch
else:
new_str += string[i]
return new_str
solution()
# input-output by console
``` |
1248_D2. The World Is Just a Programming Task (Hard Version) | This is a harder version of the problem. In this version, n ≤ 300 000.
Vasya is an experienced developer of programming competitions' problems. As all great minds at some time, Vasya faced a creative crisis. To improve the situation, Petya gifted him a string consisting of opening and closing brackets only. Petya believes, that the beauty of the bracket string is a number of its cyclical shifts, which form a correct bracket sequence.
To digress from his problems, Vasya decided to select two positions of the string (not necessarily distinct) and swap characters located at this positions with each other. Vasya will apply this operation exactly once. He is curious what is the maximum possible beauty he can achieve this way. Please help him.
We remind that bracket sequence s is called correct if:
* s is empty;
* s is equal to "(t)", where t is correct bracket sequence;
* s is equal to t_1 t_2, i.e. concatenation of t_1 and t_2, where t_1 and t_2 are correct bracket sequences.
For example, "(()())", "()" are correct, while ")(" and "())" are not.
The cyclical shift of the string s of length n by k (0 ≤ k < n) is a string formed by a concatenation of the last k symbols of the string s with the first n - k symbols of string s. For example, the cyclical shift of string "(())()" by 2 equals "()(())".
Cyclical shifts i and j are considered different, if i ≠ j.
Input
The first line contains an integer n (1 ≤ n ≤ 300 000), the length of the string.
The second line contains a string, consisting of exactly n characters, where each of the characters is either "(" or ")".
Output
The first line should contain a single integer — the largest beauty of the string, which can be achieved by swapping some two characters.
The second line should contain integers l and r (1 ≤ l, r ≤ n) — the indices of two characters, which should be swapped in order to maximize the string's beauty.
In case there are several possible swaps, print any of them.
Examples
Input
10
()()())(()
Output
5
8 7
Input
12
)(()(()())()
Output
4
5 10
Input
6
)))(()
Output
0
1 1
Note
In the first example, we can swap 7-th and 8-th character, obtaining a string "()()()()()". The cyclical shifts by 0, 2, 4, 6, 8 of this string form a correct bracket sequence.
In the second example, after swapping 5-th and 10-th character, we obtain a string ")(())()()(()". The cyclical shifts by 11, 7, 5, 3 of this string form a correct bracket sequence.
In the third example, swap of any two brackets results in 0 cyclical shifts being correct bracket sequences. | ```python
n = int(input())
s = input()
r = 0
l = n-1
root = []
buf = []
to_the_right = True
for count in range(n):
if to_the_right:
i = r
r += 1
else:
i = l
l -= 1
b = s[i]
if b == '(':
if len(buf) == 0 or buf[-1][0] != -1:
buf.append([-1,-1,[]])
buf[-1][0] = i
else:
if len(buf) == 0 or buf[-1][1] != -1:
buf.append([-1,-1,root])
root = []
to_the_right = False
buf[-1][1] = i
if buf[-1][0] != -1 and buf[-1][1] != -1:
tmp = buf.pop()
if len(buf):
buf[-1][2].append(tmp)
else:
root.append(tmp)
to_the_right = True
sol = [[0,1,1]]
if len(buf) == 0:
sol.append([len(root), 1, 1])
for child in root:
sol.append([len(child[2])+1, child[0]+1, child[1]+1])
for gr_child in child[2]:
sol.append([len(root)+len(gr_child[2])+1, gr_child[0]+1, gr_child[1]+1])
print('%d\n%d %d'%tuple(max(sol)))
``` |
1267_B. Balls of Buma | Balph is learning to play a game called Buma. In this game, he is given a row of colored balls. He has to choose the color of one new ball and the place to insert it (between two balls, or to the left of all the balls, or to the right of all the balls).
When the ball is inserted the following happens repeatedly: if some segment of balls of the same color became longer as a result of a previous action and its length became at least 3, then all the balls of this segment are eliminated.
Consider, for example, a row of balls 'AAABBBWWBB'. Suppose Balph chooses a ball of color 'W' and the place to insert it after the sixth ball, i. e. to the left of the two 'W's. After Balph inserts this ball, the balls of color 'W' are eliminated, since this segment was made longer and has length 3 now, so the row becomes 'AAABBBBB'. The balls of color 'B' are eliminated now, because the segment of balls of color 'B' became longer and has length 5 now. Thus, the row becomes 'AAA'. However, none of the balls are eliminated now, because there is no elongated segment.
Help Balph count the number of possible ways to choose a color of a new ball and a place to insert it that leads to the elimination of all the balls.
Input
The only line contains a non-empty string of uppercase English letters of length at most 3 ⋅ 10^5. Each letter represents a ball with the corresponding color.
Output
Output the number of ways to choose a color and a position of a new ball in order to eliminate all the balls.
Examples
Input
BBWWBB
Output
3
Input
BWWB
Output
0
Input
BBWBB
Output
0
Input
OOOWWW
Output
0
Input
WWWOOOOOOWWW
Output
7 | ```python
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 18 16:25:32 2020
@author: MridulSachdeva
"""
s = input()
n = len(s)
condensed = []
temp = s[0]
count = 1
for i in range(1, n):
if s[i] == temp:
count += 1
else:
condensed.append((temp, count))
temp = s[i]
count = 1
condensed.append((temp, count))
if len(condensed) % 2 == 0:
print(0)
elif condensed[int((len(condensed) - 1) / 2)][1] < 2:
print(0)
else:
for i in range(int((len(condensed) - 1) / 2)):
if condensed[i][0] != condensed[-i - 1][0]:
print(0)
break
elif condensed[i][1] + condensed[-i - 1][1] < 3:
print(0)
break
else:
print(condensed[int((len(condensed) - 1) / 2)][1] + 1)
``` |
1288_D. Minimax Problem | You are given n arrays a_1, a_2, ..., a_n; each array consists of exactly m integers. We denote the y-th element of the x-th array as a_{x, y}.
You have to choose two arrays a_i and a_j (1 ≤ i, j ≤ n, it is possible that i = j). After that, you will obtain a new array b consisting of m integers, such that for every k ∈ [1, m] b_k = max(a_{i, k}, a_{j, k}).
Your goal is to choose i and j so that the value of min _{k = 1}^{m} b_k is maximum possible.
Input
The first line contains two integers n and m (1 ≤ n ≤ 3 ⋅ 10^5, 1 ≤ m ≤ 8) — the number of arrays and the number of elements in each array, respectively.
Then n lines follow, the x-th line contains the array a_x represented by m integers a_{x, 1}, a_{x, 2}, ..., a_{x, m} (0 ≤ a_{x, y} ≤ 10^9).
Output
Print two integers i and j (1 ≤ i, j ≤ n, it is possible that i = j) — the indices of the two arrays you have to choose so that the value of min _{k = 1}^{m} b_k is maximum possible. If there are multiple answers, print any of them.
Example
Input
6 5
5 0 3 1 2
1 8 9 1 3
1 2 3 4 5
9 1 0 3 7
2 3 0 6 3
6 4 1 7 0
Output
1 5 | ```python
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
#threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
#sys.setrecursionlimit(300000)
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----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**30, func=lambda a, b: min(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)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
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)
# -------------------------------iye ha chutiya zindegi-------------------------------------
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
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] > k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
class TrieNode:
def __init__(self):
self.children = [None] * 26
self.isEndOfWord = False
class Trie:
def __init__(self):
self.root = self.getNode()
def getNode(self):
return TrieNode()
def _charToIndex(self, ch):
return ord(ch) - ord('a')
def insert(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
pCrawl.children[index] = self.getNode()
pCrawl = pCrawl.children[index]
pCrawl.isEndOfWord = True
def search(self, key):
pCrawl = self.root
length = len(key)
for level in range(length):
index = self._charToIndex(key[level])
if not pCrawl.children[index]:
return False
pCrawl = pCrawl.children[index]
return pCrawl != None and pCrawl.isEndOfWord
#-----------------------------------------trie---------------------------------
class Node:
def __init__(self, data):
self.data = data
self.count=0
self.left = None # left node for 0
self.right = None # right node for 1
class BinaryTrie:
def __init__(self):
self.root = Node(0)
def insert(self, pre_xor):
self.temp = self.root
for i in range(31, -1, -1):
val = pre_xor & (1 << i)
if val:
if not self.temp.right:
self.temp.right = Node(0)
self.temp = self.temp.right
self.temp.count+=1
if not val:
if not self.temp.left:
self.temp.left = Node(0)
self.temp = self.temp.left
self.temp.count += 1
self.temp.data = pre_xor
def query(self, xor):
self.temp = self.root
for i in range(31, -1, -1):
val = xor & (1 << i)
if not val:
if self.temp.left and self.temp.left.count>0:
self.temp = self.temp.left
elif self.temp.right:
self.temp = self.temp.right
else:
if self.temp.right and self.temp.right.count>0:
self.temp = self.temp.right
elif self.temp.left:
self.temp = self.temp.left
self.temp.count-=1
return xor ^ self.temp.data
#-------------------------bin trie-------------------------------------------
n,m=map(int,input().split())
l=[]
pm=2**m-1
for i in range(n):
l.append(list(map(int,input().split())))
def find (x):
s=set()
d=defaultdict(int)
for i in range(n):
a=""
for j in range(m):
if l[i][j]>=x:
a+='1'
else:
a+='0'
d[int(a,2)]=i
s.add(int(a,2))
s=list(s)
#print(s)
for i in range(len(s)):
for j in range(i,len(s)):
if s[i]|s[j]==pm:
return [d[s[i]]+1,d[s[j]]+1]
return [-1,-1]
st=0
end=10**9
ans=(0,0)
while(st<=end):
mid=(st+end)//2
s=find(mid)
if s[0]!=-1:
ans=s
st=mid+1
else:
end=mid-1
print(*ans)
``` |
1331_G. Lingua Romana | per nextum in unam tum XI conscribementis fac sic
vestibulo perlegementum da varo.
morde varo.
seqis cumula varum.
cis
per nextum in unam tum XI conscribementis fac sic
seqis decumulamenta da varo.
varum privamentum fodementum da aresulto.
varum tum III elevamentum tum V multiplicamentum da bresulto.
aresultum tum bresultum addementum da resulto.
si CD tum resultum non praestantiam fac sic
dictum sic f(%d) = %.2f cis tum varum tum resultum egresso describe.
novumversum egresso scribe.
cis
si CD tum resultum praestantiam fac sic
dictum sic f(%d) = MAGNA NIMIS! cis tum varum egresso describe.
novumversum egresso scribe.
cis
cis
Input
The input consists of several integers, one per line. Each integer is between -50 and 50, inclusive.
Output
As described in the problem statement.
Example
Input
0
1
-2
-3
-4
-5
-6
-7
-8
-9
10
Output
f(10) = MAGNA NIMIS!
f(-9) = -3642.00
f(-8) = -2557.17
f(-7) = -1712.35
f(-6) = -1077.55
f(-5) = -622.76
f(-4) = -318.00
f(-3) = -133.27
f(-2) = -38.59
f(1) = 6.00
f(0) = 0.00 | ```python
l = [0 for i in range(11)]
for i in range(11):
l[i] = int(input())
l.reverse()
for i in l:
a = (i ** 3) * 5 + (abs(i) ** 0.5)
if a > 400:
print('f(' + str(i) + ') = MAGNA NIMIS!')
continue
print('f(' + str(i) + ') =', format(a, '.2f'))
``` |
1352_B. Same Parity Summands | You are given two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100). Represent the number n as the sum of k positive integers of the same parity (have the same remainder when divided by 2).
In other words, find a_1, a_2, …, a_k such that all a_i>0, n = a_1 + a_2 + … + a_k and either all a_i are even or all a_i are odd at the same time.
If such a representation does not exist, then report it.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (1 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 100).
Output
For each test case print:
* YES and the required values a_i, if the answer exists (if there are several answers, print any of them);
* NO if the answer does not exist.
The letters in the words YES and NO can be printed in any case.
Example
Input
8
10 3
100 4
8 7
97 2
8 8
3 10
5 3
1000000000 9
Output
YES
4 2 4
YES
55 5 5 35
NO
NO
YES
1 1 1 1 1 1 1 1
NO
YES
3 1 1
YES
111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111110 111111120 | ```python
T = int(input())
for test in range(T):
n, k = map(int, input().split())
if n % 2 != 0 and k % 2 == 0:
print("NO")
else:
if n % 2 != 0: # Ak is odd
if (n - (k-1)) > 0 and (n - (k-1)) % 2 == 1:
print("YES")
temp = [1 for _ in range(k-1)]+[(n - (k-1))]
for i in temp:
print(i, end = ' ')
print()
else:
print("NO")
else: # n is even ak is even
if (n - 2*(k-1)) > 1 and (n - 2* (k-1)) % 2 == 0:
print("YES")
temp = [2 for _ in range(k - 1)] + [(n - 2*(k - 1))]
for i in temp:
print(i, end = ' ')
print()
else:
if (n - (k - 1)) > 0 and (n - (k - 1)) % 2 == 1:
print("YES")
temp = [1 for _ in range(k - 1)] + [(n - (k - 1))]
for i in temp:
print(i, end=' ')
print()
else:
print("NO")
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.