name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
p03291 AtCoder Beginner Contest 104 - We Love ABC | The ABC number of a string T is the number of triples of integers (i, j, k) that satisfy all of the following conditions:
* 1 ≤ i < j < k ≤ |T| (|T| is the length of T.)
* T_i = `A` (T_i is the i-th character of T from the beginning.)
* T_j = `B`
* T_k = `C`
For example, when T = `ABCBC`, there are three triples of integers (i, j, k) that satisfy the conditions: (1, 2, 3), (1, 2, 5), (1, 4, 5). Thus, the ABC number of T is 3.
You are given a string S. Each character of S is `A`, `B`, `C` or `?`.
Let Q be the number of occurrences of `?` in S. We can make 3^Q strings by replacing each occurrence of `?` in S with `A`, `B` or `C`. Find the sum of the ABC numbers of all these strings.
This sum can be extremely large, so print the sum modulo 10^9 + 7.
Constraints
* 3 ≤ |S| ≤ 10^5
* Each character of S is `A`, `B`, `C` or `?`.
Input
Input is given from Standard Input in the following format:
S
Output
Print the sum of the ABC numbers of all the 3^Q strings, modulo 10^9 + 7.
Examples
Input
A??C
Output
8
Input
ABCBC
Output
3
Input
????C?????B??????A???????
Output
979596887 | ```python
s=input()
n=len(s)
dp=[4*[0]for i in range(n+1)]
dp[0][0]=1
for i in range(1,n+1):
for j in range(4):
dp[i][j]+=dp[i-1][j]*((s[i-1]=="?")*2+1)
if s[i-1] in "A?":dp[i][1]+=dp[i-1][0]
if s[i-1] in "B?":dp[i][2]+=dp[i-1][1]
if s[i-1] in "C?":dp[i][3]+=dp[i-1][2]
for j in range(4):dp[i][j]%=10**9+7
#for i in range(n+1):print(dp[i],(" "+s)[i])
print(dp[-1][-1])
``` |
p03447 AtCoder Beginner Contest 087 - Buying Sweets | You went shopping to buy cakes and donuts with X yen (the currency of Japan).
First, you bought one cake for A yen at a cake shop. Then, you bought as many donuts as possible for B yen each, at a donut shop.
How much do you have left after shopping?
Constraints
* 1 \leq A, B \leq 1 000
* A + B \leq X \leq 10 000
* X, A and B are integers.
Input
Input is given from Standard Input in the following format:
X
A
B
Output
Print the amount you have left after shopping.
Examples
Input
1234
150
100
Output
84
Input
1000
108
108
Output
28
Input
579
123
456
Output
0
Input
7477
549
593
Output
405 | ```python
print(eval(input()+"-"+input())%int(input()))
``` |
p03607 AtCoder Beginner Contest 073 - Write and Erase | You are playing the following game with Joisino.
* Initially, you have a blank sheet of paper.
* Joisino announces a number. If that number is written on the sheet, erase the number from the sheet; if not, write the number on the sheet. This process is repeated N times.
* Then, you are asked a question: How many numbers are written on the sheet now?
The numbers announced by Joisino are given as A_1, ... ,A_N in the order she announces them. How many numbers will be written on the sheet at the end of the game?
Constraints
* 1≤N≤100000
* 1≤A_i≤1000000000(=10^9)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print how many numbers will be written on the sheet at the end of the game.
Examples
Input
3
6
2
6
Output
1
Input
4
2
5
5
2
Output
0
Input
6
12
22
16
22
18
12
Output
2 | ```python
n=int(input())
s=set()
for i in range(n):
x=input()
if x in s:
s.discard(x)
else:
s.add(x)
print(len(s))
``` |
p03768 AtCoder Grand Contest 012 - Splatter Painting | Squid loves painting vertices in graphs.
There is a simple undirected graph consisting of N vertices numbered 1 through N, and M edges. Initially, all the vertices are painted in color 0. The i-th edge bidirectionally connects two vertices a_i and b_i. The length of every edge is 1.
Squid performed Q operations on this graph. In the i-th operation, he repaints all the vertices within a distance of d_i from vertex v_i, in color c_i.
Find the color of each vertex after the Q operations.
Constraints
* 1 ≤ N,M,Q ≤ 10^5
* 1 ≤ a_i,b_i,v_i ≤ N
* a_i ≠ b_i
* 0 ≤ d_i ≤ 10
* 1 ≤ c_i ≤10^5
* d_i and c_i are all integers.
* There are no self-loops or multiple edges in the given graph.
Input
Input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_{M} b_{M}
Q
v_1 d_1 c_1
:
v_{Q} d_{Q} c_{Q}
Output
Print the answer in N lines. In the i-th line, print the color of vertex i after the Q operations.
Examples
Input
7 7
1 2
1 3
1 4
4 5
5 6
5 7
2 3
2
6 1 1
1 2 2
Output
2
2
2
2
2
1
0
Input
14 10
1 4
5 7
7 11
4 10
14 7
14 3
6 14
8 11
5 13
8 3
8
8 6 2
9 7 85
6 9 3
6 7 5
10 3 1
12 9 4
9 6 6
8 2 3
Output
1
0
3
1
5
5
3
3
6
1
3
4
5
3 | ```python
import sys
input = sys.stdin.readline
INF = 10**14
N, M = map(int, input().split())
graph = [[] for _ in range(N)]
for _ in range(M):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
maxd = 0
Q = int(input())
Query = []
Color = []
for _ in range(Q):
v, d, c = map(int, input().split())
if d > maxd:
maxd = d
Query.append((v-1, d))
Color.append(c)
Query = Query[::-1]
Color = Color[::-1]
dp = [[INF]*(maxd+1) for _ in range(N)]
for i, (v, d) in enumerate(Query):
if i < dp[v][d]:
dp[v][d] = i
for d in reversed(range(maxd)):
for v in range(N):
if dp[v][d+1] < dp[v][d]:
dp[v][d] = dp[v][d+1]
for nv in graph[v]:
if dp[v][d+1] < dp[nv][d]:
dp[nv][d] = dp[v][d+1]
for v in range(N):
seq = dp[v][0]
if seq == INF:
print(0)
else:
print(Color[seq])
``` |
p03937 AtCoder Grand Contest 007 - Shik and Stone | We have a grid of H rows and W columns. Initially, there is a stone in the top left cell. Shik is trying to move the stone to the bottom right cell. In each step, he can move the stone one cell to its left, up, right, or down (if such cell exists). It is possible that the stone visits a cell multiple times (including the bottom right and the top left cell).
You are given a matrix of characters a_{ij} (1 \leq i \leq H, 1 \leq j \leq W). After Shik completes all moving actions, a_{ij} is `#` if the stone had ever located at the i-th row and the j-th column during the process of moving. Otherwise, a_{ij} is `.`. Please determine whether it is possible that Shik only uses right and down moves in all steps.
Constraints
* 2 \leq H, W \leq 8
* a_{i,j} is either `#` or `.`.
* There exists a valid sequence of moves for Shik to generate the map a.
Input
The input is given from Standard Input in the following format:
H W
a_{11}a_{12}...a_{1W}
:
a_{H1}a_{H2}...a_{HW}
Output
If it is possible that Shik only uses right and down moves, print `Possible`. Otherwise, print `Impossible`.
Examples
Input
4 5
##...
.##..
..##.
...##
Output
Possible
Input
4 5
...
.##..
..##.
...##
Output
Possible
Input
5 3
..#
..
Output
Impossible
Input
4 5
...
.###.
.###.
...##
Output
Impossible | ```python
H,W=map(int,input().split());print(["Imp","P"][H+W-1==sum(input().count("#")for _ in range(H))]+"ossible")
``` |
p00029 English Sentence | Your task is to write a program which reads a text and prints two words. The first one is the word which is arise most frequently in the text. The second one is the word which has the maximum number of letters.
The text includes only alphabetical characters and spaces. A word is a sequence of letters which is separated by the spaces.
Input
A text is given in a line. You can assume the following conditions:
* The number of letters in the text is less than or equal to 1000.
* The number of letters in a word is less than or equal to 32.
* There is only one word which is arise most frequently in given text.
* There is only one word which has the maximum number of letters in given text.
Output
The two words separated by a space.
Example
Input
Thank you for your mail and your lectures
Output
your lectures | ```python
word_list = input().split(' ')
word_dict = {}
longest_word_len = 0
longest_word = ''
high_freq_word_num = 0
for word in word_list:
if longest_word_len < len(word):
longest_word_len = len(word)
longest_word = word
if word not in word_dict:
word_dict[word] = 1
else :
word_dict[word] += 1
if high_freq_word_num < word_dict[word]:
high_freq_word_num = word_dict[word]
for word in word_list:
if word_dict[word] == high_freq_word_num:
print(word + ' ' + longest_word)
break
``` |
p00160 Delivery Fee | The courier charges for a courier company are set according to size and weight as shown in the table below.
A size | B size | C size | D size | E size | F size
--- | --- | --- | --- | --- | --- | ---
Size | 60 cm or less | 80 cm or less | 100 cm or less | 120 cm or less | 140 cm or less | 160 cm or less
Weight | 2kg or less | 5kg or less | 10kg or less | 15kg or less | 20kg or less | 25kg or less
Price | 600 yen | 800 yen | 1000 yen | 1200 yen | 1400 yen | 1600 yen
The size is the sum of the three sides (length, width, height). For example, a baggage that is 120 cm in size and weighs less than 15 kg will be D size (1,200 yen). Even if the size is 120 cm or less, if the weight exceeds 15 kg and 20 kg or less, it will be E size.
Please create a program that outputs the total charge by inputting the information of the luggage brought in in one day. Luggage that exceeds F size is excluded and is not included in the total price.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
x1 y1 h1 w1
x2 y2 h2 w2
::
xn yn hn wn
The number of packages n (1 ≤ n ≤ 10000) on the first line, followed by the i-th package on the n lines: vertical length xi, horizontal length yi, height hi, weight wi (1 ≤ xi, yi , hi, wi ≤ 200) are given on one line, separated by blanks.
The number of datasets does not exceed 20.
Output
Outputs the total package charge for each dataset on one line.
Example
Input
2
50 25 5 5
80 60 10 30
3
10 15 25 24
5 8 12 5
30 30 30 18
0
Output
800
3800 | ```python
S = [60, 80, 100, 120, 140, 160]
W = [2, 5, 10, 15, 20, 25]
P = [600, 800, 1000, 1200, 1400, 1600]
while 1:
n = int(input())
if n == 0:
break
r = 0
for i in range(n):
x, y, h, w = map(int, input().split())
s = x + y + h
for j in range(6):
if s <= S[j] and w <= W[j]:
r += P[j]
break
print(r)
``` |
p00487 Bug Party | Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here, it is abbreviated as JOI.
JOI is conducting research to confine many microorganisms in one petri dish alive. There are N microorganisms to be investigated, and they are numbered 1, 2, ..., N. When each microorganism is trapped in a petri dish, it instantly releases a harmful substance called foo (fatally odd object) into the petri dish. The amount of foo released by each microorganism is known. The foo released by all the microorganisms trapped in the petri dish is evenly ingested by each microorganism in the petri dish. The foo tolerance of each microorganism is known, and if foo is ingested in excess of this amount, the microorganism will die.
The foo release amount of the microorganism i is ai milligrams, and the foo tolerance is bi milligrams. That is, when the microorganisms i1, i2, ..., ik are trapped in the petri dish, each microorganism in the petri dish ingests (ai1 + ai2 + ... + aik) / k milligrams of foo, and the microorganisms in the petri dish ingest. i will die if this intake is greater than bi.
On behalf of JOI, you must keep as many microorganisms alive in the petri dish as possible. However, no microbes in the petri dish should die from ingestion of foo, as carcasses of microorganisms adversely affect the environment in the petri dish.
It is still a mystery how JOI profits from making "just a strange invention", and no one in JOI knows except the president.
input
Read the following input from standard input.
* The integer N is written on the first line, which indicates that there are N microorganisms to be investigated.
* The following N lines contain information on each microorganism. On the first line of i + (1 ≤ i ≤ N), the positive integers ai and bi are written separated by blanks, and the foo emission amount of the microorganism i is ai milligrams and the foo tolerance is bi milligrams. Represent.
output
Output the maximum number of microorganisms that can be confined in one petri dish to the standard output in one line.
Example
Input
6
12 8
5 9
2 4
10 12
6 7
13 9
Output
3 | ```python
# AOJ 0564: Bug Party
# Python3 2018.6.30 bal4u
import heapq
tbl = []
N = int(input())
for i in range(N):
a, b = map(int, input().split())
tbl.append((a, b))
tbl.sort()
Q = []
ans = s = sz = 0
for t in tbl:
s += t[0]
heapq.heappush(Q, (t[1], t[0]))
sz += 1
while sz and sz*Q[0][0] < s:
s -= Q[0][1]
heapq.heappop(Q)
sz -= 1
if sz > ans: ans = sz
print(ans)
``` |
p00816 Shredding Company | You have just been put in charge of developing a new shredder for the Shredding Company. Although a ``normal'' shredder would just shred sheets of paper into little pieces so that the contents would become unreadable, this new shredder needs to have the following unusual basic characteristics.
* The shredder takes as input a target number and a sheet of paper with a number written on it.
* It shreds (or cuts) the sheet into pieces each of which has one or more digits on it.
* The sum of the numbers written on each piece is the closest possible number to the target number, without going over it.
For example, suppose that the target number is 50, and the sheet of paper has the number 12346. The shredder would cut the sheet into four pieces, where one piece has 1, another has 2, the third has 34, and the fourth has 6. This is because their sum 43 (= 1 + 2 + 34 + 6) is closest to the target number 50 of all possible combinations without going over 50. For example, a combination where the pieces are 1, 23, 4, and 6 is not valid, because the sum of this combination 34 (= 1 + 23 + 4 + 6) is less than the above combination's 43. The combination of 12, 34, and 6 is not valid either, because the sum 52 (= 12+34+6) is greater than the target number of 50.
<image>
Figure 1. Shredding a sheet of paper having the number 12346 when the target number is 50
There are also three special rules:
* If the target number is the same as the number on the sheet of paper, then the paper is not cut. For example, if the target number is 100 and the number on the sheet of paper is also 100, then the paper is not cut.
* If it is not possible to make any combination whose sum is less than or equal to the target number, then error is printed on a display. For example, if the target number is 1 and the number on the sheet of paper is 123, it is not possible to make any valid combination, as the combination with the smallest possible sum is 1, 2, 3. The sum for this combination is 6, which is greater than the target number, and thus error is printed.
* If there is more than one possible combination where the sum is closest to the target number without going over it, then rejected is printed on a display. For example, if the target number is 15, and the number on the sheet of paper is 111, then there are two possible combinations with the highest possible sum of 12: (a) 1 and 11 and (b) 11 and 1; thus rejected is printed.
In order to develop such a shredder, you have decided to first make a simple program that would simulate the above characteristics and rules. Given two numbers, where the first is the target number and the second is the number on the sheet of paper to be shredded, you need to figure out how the shredder should ``cut up'' the second number.
Input
The input consists of several test cases, each on one line, as follows:
t1 num1
t2 num2
...
tn numn
0 0
Each test case consists of the following two positive integers, which are separated by one space: (1) the first integer (ti above) is the target number; (2) the second integer (numi above) is the number that is on the paper to be shredded.
Neither integers may have a 0 as the first digit, e.g., 123 is allowed but 0123 is not. You may assume that both integers are at most 6 digits in length. A line consisting of two zeros signals the end of the input.
Output
For each test case in the input, the corresponding output takes one of the following three types:
* sum part1 part2 ...
* rejected
* error
In the first type, partj and sum have the following meaning:
* Each partj is a number on one piece of shredded paper. The order of partj corresponds to the order of the original digits on the sheet of paper.
* sum is the sum of the numbers after being shredded, i.e., sum = part1 + part2 + ... .
Each number should be separated by one space.
The message "error" is printed if it is not possible to make any combination, and "rejected" if there is more than one possible combination.
No extra characters including spaces are allowed at the beginning of each line, nor at the end of each line.
Example
Input
50 12346
376 144139
927438 927438
18 3312
9 3142
25 1299
111 33333
103 862150
6 1104
0 0
Output
43 1 2 34 6
283 144 139
927438 927438
18 3 3 12
error
21 1 2 9 9
rejected
103 86 2 15 0
rejected | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 998244353
dd = [(0,-1),(1,0),(0,1),(-1,0)]
ddn = [(0,-1),(1,-1),(1,0),(1,1),(0,1),(-1,-1),(-1,0),(-1,1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
ii = [2**i for i in range(6)]
while True:
t,n = LI()
if t == 0 and n == 0:
break
s = [c for c in str(n)]
l = len(s)
r = None
rm = -1
rc = 0
for i in range(2**(l-1)):
k = []
c = s[0]
for j in range(l-1):
if ii[j] & i:
c += s[j+1]
else:
k.append(c)
c = s[j+1]
k.append(c)
m = sum(map(int,k))
if m <= t:
if rm < m:
rm = m
r = k
rc = 1
elif rm == m:
rc += 1
if rc == 0:
rr.append('error')
elif rc > 1:
rr.append('rejected')
else:
rr.append('{} {}'.format(rm, ' '.join(r)))
return '\n'.join(map(str, rr))
print(main())
``` |
p00947 Quality of Check Digits | Example
Input
0 3 1 7 5 9 8 6 4 2
7 0 9 2 1 5 4 8 6 3
4 2 0 6 8 7 1 3 5 9
1 7 5 0 9 8 3 4 2 6
6 1 2 3 0 4 5 9 7 8
3 6 7 4 2 0 9 5 8 1
5 8 6 9 7 2 0 1 3 4
8 9 4 5 3 6 2 0 1 7
9 4 3 8 6 1 7 2 0 5
2 5 8 1 4 3 6 7 9 0
Output
0 | ```python
from itertools import product
T = [list(map(int, input().split())) for i in range(10)]
def calc(v):
val = 0
for e in v:
val = T[val][e]
return val
ans = 0
for code in product(range(10), repeat=4):
e = calc(code)
ok = 1
code = list(code) + [e]
for i in range(5):
d = code[:]
for j in range(10):
if code[i] == j:
continue
d[i] = j
if calc(d) == 0:
ok = 0
for i in range(4):
d = code[:]
if d[i] == d[i+1]:
continue
d[i], d[i+1] = d[i+1], d[i]
if calc(d) == 0:
ok = 0
if ok == 0:
ans += 1
print(ans)
``` |
p01080 Traffic Tree | Problem
A graph is given in which N vertices, each numbered from 1 to N, are connected by N-1 undirected edges. For each vertex, output the shortest number of steps to start from that vertex and visit all vertices.
However, one step is to follow one side from one vertex and move to another vertex.
Constraints
* 2 ≤ N ≤ 105
* 1 ≤ ui, vi ≤ N (1 ≤ i ≤ N-1)
* ui ≠ vi
* The graph given is concatenated
Input
The input is given in the following format.
N
u1 v1
..
..
..
uN−1 vN−1
The first line is given one integer N.
In the following N-1 line, the integers ui and vi representing the vertex numbers at both ends of the i-th side are given on the i-th line, separated by blanks.
Output
Output the shortest number of steps to visit all vertices starting from vertex i on the i-th line from vertex 1 to vertex N.
Examples
Input
2
1 2
Output
1
1
Input
6
1 2
1 3
3 4
3 5
5 6
Output
7
6
8
7
7
6 | ```python
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
from collections import deque
N = int(input())
#隣接リストの作成
G = [[] for _ in range(N)]
for _ in range(N - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
#直径を求める
dist = [-1] * N
dist[0] = 0
que = deque()
que.append(0) #スタート地点を入れる
while len(que) != 0:
tmp = que.popleft()
for i in G[tmp]:
if dist[i] == -1:
dist[i] = dist[tmp] + 1
que.append(i)
tmp = 0
start = -1
for index, x in enumerate(dist):
if tmp < x:
start = index
tmp = x
dist = [-1] * N
dist[start] = 0
que = deque()
que.append(start) #スタート地点を入れる
while len(que) != 0:
tmp = que.popleft()
for i in G[tmp]:
if dist[i] == -1:
dist[i] = dist[tmp] + 1
que.append(i)
tmp = 0
gpal = -1
for index, x in enumerate(dist):
if tmp < x:
goal = index
tmp = x
dist1 = [-1] * N
dist1[goal] = 0
que = deque()
que.append(goal) #スタート地点を入れる
while len(que) != 0:
tmp = que.popleft()
for i in G[tmp]:
if dist1[i] == -1:
dist1[i] = dist1[tmp] + 1
que.append(i)
# print (dist)
# print (dist1)
for i in range(N):
print (2 * (N - 1) - max(dist[i], dist1[i]))
if __name__ == '__main__':
main()
``` |
p01350 Carrot Tour | I'm traveling to a country with a rabbit. There are n cities in this country numbered from 1 to n, and the rabbit is now in city 1. City i is a point on the coordinate plane (xi, yi) ).
Rabbits travel to meet the following conditions.
* The travel path is a polygonal line, each part of which must be a line segment connecting two different cities.
* The total length of the travel route must be r or less. The overlapping part of the route is also counted for the number of times it has passed.
* When the direction of movement changes, the bending angle must be less than or equal to θ. There is no limit to the initial direction of movement.
If you move from one city to another, you will get one carrot in the destination city. You can visit the same city multiple times, and you will get a carrot each time you visit. Find the maximum number of carrots you can put in.
Input
One integer n is given on the first line of the input, and two real numbers r and θ are given on the second line, separated by a space.
1 ≤ n ≤ 20
0 <r <104
0 ° <θ <180 °
The following n lines are given the integers xi and yi separated by spaces.
-10 000 ≤ xi, yi ≤ 10 000
The answer does not change even if r and θ are changed within ± 10-3.
The locations of both cities are different.
Output
Output the maximum number of carrots that the rabbit can get on this trip in one line.
Example
Input
5
100.1 90.1
0 0
0 10
5 5
10 0
10 10
Output
10 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f():
n = I()
r,t = LF()
a = [LI() for _ in range(n)]
d = {}
M = 32
for i in range(n):
ax,ay = a[i]
for j in range(n):
if i == j:
continue
bx,by = a[j]
d[i*M+j] = math.atan2(bx-ax,by-ay) / math.pi * 180
ky = {}
for i in range(n):
ax,ay = a[i]
for j in range(n):
bx,by = a[j]
ky[i*M+j] = pow(pow(ax-bx, 2) + pow(ay-by, 2), 0.5)
e = collections.defaultdict(list)
for i in range(n):
for j in range(n):
if i == j:
continue
ij = i*M+j
dij = d[ij]
for k in range(n):
if k == j:
continue
jk = j*M+k
djk = d[jk]
if abs(dij-djk) <= t or 360 - abs(dij-djk) <= t:
e[(i,j)].append(((j,k), ky[jk]))
def search():
res = 0
dp = [[None]*n for _ in range(n)]
for j in range(1, n):
k = ky[j]
if k > r:
continue
s = (j,1)
res = 1
dp[0][j] = k
if res == 0:
return 0
while True:
wf = False
nd = [[None]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if dp[i][j] is None:
continue
dij = dp[i][j]
for nn,k in e[(i,j)]:
nk = dij + k
if nk > r or (not nd[j][nn[1]] is None and nd[j][nn[1]] < nk):
continue
nd[j][nn[1]] = nk
wf = True
if wf:
res += 1
dp = nd
else:
break
return res
return search()
while True:
rr.append(f())
break
return '\n'.join(map(str,rr))
print(main())
``` |
p01832 Shifting a Matrix | Example
Input
3 2
R1
Output
3 1 2
4 5 6
7 8 9 | ```python
from string import digits
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N, L = map(int, readline().split())
S = readline().strip()
*I, = range(N*N)
LRUD = "LRUD"
FS = [[], [], [], []]
for i in range(N):
base = N*i
F = I[:]
for j in range(N):
F[base+j] = base+((j+1) % N)
FS[0].append(F)
F = I[:]
for j in range(N):
F[base+j] = base+((j-1) % N)
FS[1].append(F)
base = i
F = I[:]
for j in range(N):
F[base+N*j] = base+((j+1) % N)*N
FS[2].append(F)
F = I[:]
for j in range(N):
F[base+N*j] = base+((j-1) % N)*N
FS[3].append(F)
def fast_pow(f, n):
r = I[:]
while n:
if n & 1:
r = [f[x] for x in r]
f = [f[x] for x in f]
n >>= 1
return r
S += "$"
cur = 0
def number():
nonlocal cur
r = 0
while S[cur] in digits:
r = 10*r + int(S[cur])
cur += 1 # digits
return r
def expr():
nonlocal cur
f0 = I[:]
while 1:
if S[cur] == '(':
cur += 1 # '('
r1 = expr()
cur += 1 # ')'
num = number()
f1 = fast_pow(r1, num)
elif S[cur] in LRUD:
t = LRUD.index(S[cur])
cur += 1 # LRUD
num = number()
f1 = FS[t][num-1]
else:
break
f0 = [f0[x] for x in f1]
return f0
f = expr()
ans = [str(x+1) for x in f]
for i in range(N):
write(" ".join(ans[i*N:i*N+N]))
write("\n")
solve()
``` |
p01967 Many Kinds of Apples | A: Many Kinds of Apples
Problem Statement
Apple Farmer Mon has two kinds of tasks: "harvest apples" and "ship apples".
There are N different species of apples, and N distinguishable boxes. Apples are labeled by the species, and boxes are also labeled, from 1 to N. The i-th species of apples are stored in the i-th box.
For each i, the i-th box can store at most c_i apples, and it is initially empty (no apple exists).
Mon receives Q instructions from his boss Kukui, and Mon completely follows in order. Each instruction is either of two types below.
* "harvest apples": put d x-th apples into the x-th box.
* "ship apples": take d x-th apples out from the x-th box.
However, not all instructions are possible to carry out. Now we call an instruction which meets either of following conditions "impossible instruction":
* When Mon harvest apples, the amount of apples exceeds the capacity of that box.
* When Mon tries to ship apples, there are not enough apples to ship.
Your task is to detect the instruction which is impossible to carry out.
Input
Input is given in the following format.
N
c_1 c_2 $ \ cdots $ c_N
Q
t_1 x_1 d_1
t_2 x_2 d_2
$ \ vdots $
t_Q x_Q d_Q
In line 1, you are given the integer N, which indicates the number of species of apples.
In line 2, given c_i (1 \ leq i \ leq N) separated by whitespaces. C_i indicates the capacity of the i-th box.
In line 3, given Q, which indicates the number of instructions.
Instructions are given successive Q lines. T_i x_i d_i means what kind of instruction, which apple Mon handles in this instruction, how many apples Mon handles, respectively. If t_i is equal to 1, it means Mon does the task of "harvest apples" , else if t_i is equal to 2, it means Mon does the task of "ship apples".
Constraints
All input values are integers, and satisfy following constraints.
* 1 \ leq N \ leq 1,000
* 1 \ leq c_i \ leq 100,000 (1 \ leq i \ leq N)
* 1 \ leq Q \ leq 100,000
* t_i \ in \\ {1, 2 \\} (1 \ leq i \ leq Q)
* 1 \ leq x_i \ leq N (1 \ leq i \ leq Q)
* 1 \ leq d_i \ leq 100,000 (1 \ leq i \ leq Q)
Output
If there is "impossible instruction", output the index of the apples which have something to do with the first "impossible instruction".
Otherwise, output 0.
Sample Input 1
2
3 3
Four
1 1 2
one two Three
2 1 3
2 2 3
Sample Output 1
1
In this case, there are not enough apples to ship in the first box.
Sample Input 2
2
3 3
Four
1 1 3
2 1 2
one two Three
1 1 3
Sample Output 2
1
In this case, the amount of apples exceeds the capacity of the first box.
Sample Input 3
3
3 4 5
Four
1 1 3
one two Three
1 3 5
2 2 2
Sample Output 3
0
Sample Input 4
6
28 56 99 3 125 37
Ten
1 1 10
1 1 14
1 3 90
1 5 10
2 3 38
2 1 5
1 3 92
1 6 18
2 5 9
2 1 4
Sample Output 4
3
Example
Input
2
3 3
4
1 1 2
1 2 3
2 1 3
2 2 3
Output
1 | ```python
n = int(input())
C = list(map(int, input().split()))
q = int(input())
data = []
for _ in range(q):
t, x, d = map(int, input().split())
data.append([t, x, d])
apple = [0] * n
for D in data:
t, x, d = D
if t == 1:
apple[x-1] += d
if apple[x-1] > C[x-1]:
print(x)
break
else:
apple[x-1] -= d
if apple[x-1] < 0:
print(x)
break
else:
print(0)
``` |
p02114 Fissure Puzzle Easy | Problem
There is a grid of $ N \ times N $ cells. Initially all cells are white. Follow the steps below to increase the number of black squares.
Select one white cell from the cells that are even-numbered from the top and even-numbered from the left. The selected square turns black. Further, the adjacent white squares also change to black in a chain reaction in each of the vertical and horizontal directions of the squares. This chain continues until there are no white cells in that direction. (An example is shown below)
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
□□□□□□□□□
↓ Select the 4th from the top and the 6th from the left
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
■■■■■■■■■
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
↓ Select the second from the top and the second from the left
□ ■ □□□ ■ □□□
■■■■■■ □□□
□ ■ □□□ ■ □□□
■■■■■■■■■
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
□□□□□ ■ □□□
↓ Select 6th from the top and 8th from the left
□ ■ □□□ ■ □□□
■■■■■■ □□□
□ ■ □□□ ■ □□□
■■■■■■■■■
□□□□□ ■ □ ■ □
□□□□□ ■■■■
□□□□□ ■ □ ■ □
□□□□□ ■ □ ■ □
□□□□□ ■ □ ■ □
You want to create a grid where the color of the $ i $ th cell from the top and the $ j $ th cell from the left is $ A_ {i, j} $. Find the minimum number of times to select a square.
Constraints
The input satisfies the following conditions.
* $ 3 \ le N \ le 127 $
* $ N $ is odd
* $ A_ {i, j} $ is'o'or'x'
* Only input that can be made is given
Input
The input is given in the following format.
$ N $
$ A_ {1,1} $ $ A_ {1,2} $ ... $ A_ {1, N} $
$ A_ {2,1} $ $ A_ {2,2} $ ... $ A_ {2, N} $
...
$ A_ {N, 1} $ $ A_ {N, 2} $ ... $ A_ {N, N} $
When $ A_ {i, j} $ is'o', it means that the $ i $ th cell from the top and the $ j $ th cell from the left are white, and when it is'x', it is a black cell. Represents that.
Output
Outputs the minimum number of times to select a cell on the first line.
Examples
Input
5
oxooo
oxooo
oxooo
xxxxx
oxooo
Output
1
Input
9
oxoooooxo
oxxxxxxxx
oxoooooxo
xxxxxxxxx
oxoxooooo
oxxxxxxxx
oxoxoxooo
oxoxxxxxx
oxoxoxooo
Output
4 | ```python
from collections import deque
n = int(input())
A = [input() for i in range(n)]
cnt = 0
dd = [[-1, 0], [0, -1], [1, 0], [0, 1]]
used = {}
for i in range(n):
for j in range(n):
if A[i][j] == 'x' or (i, j) in used:
continue
deq = deque([(j, i)])
used[i, j] = 1
cnt += 1
while deq:
x, y = deq.popleft()
for dx, dy in dd:
nx = x + dx; ny = y + dy
if 0 <= nx < n and 0 <= ny < n:
if A[ny][nx] == 'o' and (ny, nx) not in used:
used[ny, nx] = 1
deq.append((nx, ny))
print(cnt//3)
``` |
p02254 Huffman Coding | We want to encode a given string $S$ to a binary string. Each alphabet character in $S$ should be mapped to a different variable-length code and the code must not be a prefix of others.
Huffman coding is known as one of ways to obtain a code table for such encoding.
For example, we consider that appearance frequencycies of each alphabet character in $S$ are as follows:
| a| b| c| d| e| f
---|---|---|---|---|---|---
freq.| 45| 13| 12| 16| 9| 5
code| 0| 101| 100| 111| 1101| 1100
We can obtain "Huffman codes" (the third row of the table) using Huffman's algorithm.
The algorithm finds a full binary tree called "Huffman tree" as shown in the following figure.
<image>
To obtain a Huffman tree, for each alphabet character, we first prepare a node which has no parents and a frequency (weight) of the alphabet character. Then, we repeat the following steps:
1. Choose two nodes, $x$ and $y$, which has no parents and the smallest weights.
2. Create a new node $z$ whose weight is the sum of $x$'s and $y$'s.
3. Add edge linking $z$ to $x$ with label $0$ and to $y$ with label $1$. Then $z$ become their parent.
4. If there is only one node without a parent, which is the root, finish the algorithm. Otherwise, go to step 1.
Finally, we can find a "Huffman code" in a path from the root to leaves.
Task
Given a string $S$, output the length of a binary string obtained by using Huffman coding for $S$.
Constraints
* $1 \le |S| \le 10^5$
* $S$ consists of lowercase English letters.
Input
$S$
A string $S$ is given in a line.
Output
Print the length of a binary string in a line.
Examples
Input
abca
Output
6
Input
aaabbcccdeeeffg
Output
41
Input
z
Output
1 | ```python
from heapq import heappop, heappush
from collections import Counter
class Node:
def __init__(self, weight):
self.weight = weight
def set_parent(self,parent):
self.parent = parent
def get_length(self):
try:
tmp = 1 + self.parent.get_length()
except AttributeError:
tmp = 0
return tmp
def get_weight(self):
return self.weight
def __lt__(self, other):
return self.weight < other.weight
S = input()
d = Counter(S)
tree_dic = {}
h = []
num = 0
for i in d:
tree_dic[i] = Node(d[i])
heappush(h,tree_dic[i])
while(len(h) > 1):
tmp0 = heappop(h)
tmp1 = heappop(h)
tree_dic[num] = Node(tmp0.get_weight() + tmp1.get_weight())
tmp0.set_parent(tree_dic[num])
tmp1.set_parent(tree_dic[num])
heappush(h,tree_dic[num])
num+=1
ans = 0
for i in S:
ans += tree_dic[i].get_length()
if len(S) == 1:
print(1)
elif len(d) == 1:
print(len(S))
else:
print(ans)
``` |
p02402 Min | Write a program which reads a sequence of $n$ integers $a_i (i = 1, 2, ... n)$, and prints the minimum value, maximum value and sum of the sequence.
Constraints
* $0 < n \leq 10000$
* $-1000000 \leq a_i \leq 1000000$
Input
In the first line, an integer $n$ is given. In the next line, $n$ integers $a_i$ are given in a line.
Output
Print the minimum value, maximum value and sum in a line. Put a single space between the values.
Example
Input
5
10 1 5 4 17
Output
1 17 37 | ```python
input()
l=list([int(i) for i in input().split()])
print(min(l), max(l), sum(l))
``` |
1004_A. Sonya and Hotels | Sonya decided that having her own hotel business is the best way of earning money because she can profit and rest wherever she wants.
The country where Sonya lives is an endless line. There is a city in each integer coordinate on this line. She has n hotels, where the i-th hotel is located in the city with coordinate x_i. Sonya is a smart girl, so she does not open two or more hotels in the same city.
Sonya understands that her business needs to be expanded by opening new hotels, so she decides to build one more. She wants to make the minimum distance from this hotel to all others to be equal to d. The girl understands that there are many possible locations to construct such a hotel. Thus she wants to know the number of possible coordinates of the cities where she can build a new hotel.
Because Sonya is lounging in a jacuzzi in one of her hotels, she is asking you to find the number of cities where she can build a new hotel so that the minimum distance from the original n hotels to the new one is equal to d.
Input
The first line contains two integers n and d (1≤ n≤ 100, 1≤ d≤ 10^9) — the number of Sonya's hotels and the needed minimum distance from a new hotel to all others.
The second line contains n different integers in strictly increasing order x_1, x_2, …, x_n (-10^9≤ x_i≤ 10^9) — coordinates of Sonya's hotels.
Output
Print the number of cities where Sonya can build a new hotel so that the minimum distance from this hotel to all others is equal to d.
Examples
Input
4 3
-3 2 9 16
Output
6
Input
5 2
4 8 11 18 19
Output
5
Note
In the first example, there are 6 possible cities where Sonya can build a hotel. These cities have coordinates -6, 5, 6, 12, 13, and 19.
In the second example, there are 5 possible cities where Sonya can build a hotel. These cities have coordinates 2, 6, 13, 16, and 21. | ```python
n, d = map(int,input().split())
a = list(map(int,input().split()))
count = 0
for i in range(n-1):
if a[i + 1] - a[i] == 2 * d:
count +=1
elif a[i + 1] - a[i] > 2 * d:
count += 2
print(count + 2)
``` |
1028_A. Find Square | Consider a table of size n × m, initially fully white. Rows are numbered 1 through n from top to bottom, columns 1 through m from left to right. Some square inside the table with odd side length was painted black. Find the center of this square.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 115) — the number of rows and the number of columns in the table.
The i-th of the next n lines contains a string of m characters s_{i1} s_{i2} … s_{im} (s_{ij} is 'W' for white cells and 'B' for black cells), describing the i-th row of the table.
Output
Output two integers r and c (1 ≤ r ≤ n, 1 ≤ c ≤ m) separated by a space — the row and column numbers of the center of the black square.
Examples
Input
5 6
WWBBBW
WWBBBW
WWBBBW
WWWWWW
WWWWWW
Output
2 4
Input
3 3
WWW
BWW
WWW
Output
2 1 | ```python
import os
import sys
import math
def main():
n,m = [int(i) for i in input().split()]
centeri, centerj = -1,-1
starti, startj = -1,-1
for i in range(n):
s = input()
if not 'B' in s:
continue
if starti == -1:
starti = i
a = [int(pos) for pos,char in enumerate(s) if char=='B']
centerj = min(a) + (max(a)-min(a))/2
a = centerj - s.index('B')
centeri = starti + a
print('{} {}'.format(int(centeri+1), int(centerj+1)))
if __name__ == '__main__':
main()
``` |
1046_G. Space Isaac | Everybody seems to think that the Martians are green, but it turns out they are metallic pink and fat. Ajs has two bags of distinct nonnegative integers. The bags are disjoint, and the union of the sets of numbers in the bags is \{0,1,…,M-1\}, for some positive integer M. Ajs draws a number from the first bag and a number from the second bag, and then sums them modulo M.
What are the residues modulo M that Ajs cannot obtain with this action?
Input
The first line contains two positive integer N (1 ≤ N ≤ 200 000) and M (N+1 ≤ M ≤ 10^{9}), denoting the number of the elements in the first bag and the modulus, respectively.
The second line contains N nonnegative integers a_1,a_2,…,a_N (0 ≤ a_1<a_2< …< a_N<M), the contents of the first bag.
Output
In the first line, output the cardinality K of the set of residues modulo M which Ajs cannot obtain.
In the second line of the output, print K space-separated integers greater or equal than zero and less than M, which represent the residues Ajs cannot obtain. The outputs should be sorted in increasing order of magnitude. If K=0, do not output the second line.
Examples
Input
2 5
3 4
Output
1
2
Input
4 1000000000
5 25 125 625
Output
0
Input
2 4
1 3
Output
2
0 2
Note
In the first sample, the first bag and the second bag contain \{3,4\} and \{0,1,2\}, respectively. Ajs can obtain every residue modulo 5 except the residue 2: 4+1 ≡ 0, 4+2 ≡ 1, 3+0 ≡ 3, 3+1 ≡ 4 modulo 5. One can check that there is no choice of elements from the first and the second bag which sum to 2 modulo 5.
In the second sample, the contents of the first bag are \{5,25,125,625\}, while the second bag contains all other nonnegative integers with at most 9 decimal digits. Every residue modulo 1 000 000 000 can be obtained as a sum of an element in the first bag and an element in the second bag. | ```python
import sys
input = sys.stdin.readline
def main():
n, m = map(int, input().split())
a = list(map(int, input().split())) + [0]*500000
ans_S = 0
a[n] = a[0] + m
s = [0]*600600
for i in range(n):
s[i] = a[i + 1] - a[i]
s[n] = -1
for i in range(n):
s[2*n - i] = s[i]
for i in range(2*n + 1, 3*n + 1):
s[i] = s[i - n]
l, r = 0, 0
z = [0]*600600
for i in range(1, 3*n + 1):
if i < r:
z[i] = z[i - l]
while i + z[i] <= 3*n and (s[i + z[i]] == s[z[i]]):
z[i] += 1
if i + z[i] > r:
l = i
r = i + z[i]
ans = []
for i in range(n + 1, 2*n + 1):
if z[i] < n:
continue
ans_S += 1
ans.append((a[0] + a[2*n - i + 1]) % m)
ans.sort()
print(ans_S)
print(*ans)
return
if __name__=="__main__":
main()
``` |
1070_F. Debate | Elections in Berland are coming. There are only two candidates — Alice and Bob.
The main Berland TV channel plans to show political debates. There are n people who want to take part in the debate as a spectator. Each person is described by their influence and political views. There are four kinds of political views:
* supporting none of candidates (this kind is denoted as "00"),
* supporting Alice but not Bob (this kind is denoted as "10"),
* supporting Bob but not Alice (this kind is denoted as "01"),
* supporting both candidates (this kind is denoted as "11").
The direction of the TV channel wants to invite some of these people to the debate. The set of invited spectators should satisfy three conditions:
* at least half of spectators support Alice (i.e. 2 ⋅ a ≥ m, where a is number of spectators supporting Alice and m is the total number of spectators),
* at least half of spectators support Bob (i.e. 2 ⋅ b ≥ m, where b is number of spectators supporting Bob and m is the total number of spectators),
* the total influence of spectators is maximal possible.
Help the TV channel direction to select such non-empty set of spectators, or tell that this is impossible.
Input
The first line contains integer n (1 ≤ n ≤ 4⋅10^5) — the number of people who want to take part in the debate as a spectator.
These people are described on the next n lines. Each line describes a single person and contains the string s_i and integer a_i separated by space (1 ≤ a_i ≤ 5000), where s_i denotes person's political views (possible values — "00", "10", "01", "11") and a_i — the influence of the i-th person.
Output
Print a single integer — maximal possible total influence of a set of spectators so that at least half of them support Alice and at least half of them support Bob. If it is impossible print 0 instead.
Examples
Input
6
11 6
10 4
01 3
00 3
00 7
00 9
Output
22
Input
5
11 1
01 1
00 100
10 1
01 1
Output
103
Input
6
11 19
10 22
00 18
00 29
11 29
10 28
Output
105
Input
3
00 5000
00 5000
00 5000
Output
0
Note
In the first example 4 spectators can be invited to maximize total influence: 1, 2, 3 and 6. Their political views are: "11", "10", "01" and "00". So in total 2 out of 4 spectators support Alice and 2 out of 4 spectators support Bob. The total influence is 6+4+3+9=22.
In the second example the direction can select all the people except the 5-th person.
In the third example the direction can select people with indices: 1, 4, 5 and 6.
In the fourth example it is impossible to select any non-empty set of spectators. | ```python
arr = [[],[],[]]
ans = 0
temp=0
for _ in range(int(input())):
s,c = input().split()
if s=='11':
ans+=int(c)
temp+=1
elif s=='00':
arr[0].append(int(c))
elif s=='01':
arr[1].append(int(c))
else:
arr[2].append(int(c))
temp1 = min(len(arr[1]),len(arr[2]))
arr[1].sort(reverse=True)
arr[2].sort(reverse=True)
for i in range(temp1):
ans+=arr[1][i]+arr[2][i]
if len(arr[1])<len(arr[2]):
for i in range(temp1,len(arr[2])):
arr[0].append(arr[2][i])
else:
for i in range(temp1,len(arr[1])):
arr[0].append(arr[1][i])
arr[0].sort(reverse=True)
temp3=min(temp,len(arr[0]))
for i in range(temp3):
ans+=arr[0][i]
print(ans)
``` |
1092_B. Teams Forming | There are n students in a university. The number of students is even. The i-th student has programming skill equal to a_i.
The coach wants to form n/2 teams. Each team should consist of exactly two students, and each student should belong to exactly one team. Two students can form a team only if their skills are equal (otherwise they cannot understand each other and cannot form a team).
Students can solve problems to increase their skill. One solved problem increases the skill by one.
The coach wants to know the minimum total number of problems students should solve to form exactly n/2 teams (i.e. each pair of students should form a team). Your task is to find this number.
Input
The first line of the input contains one integer n (2 ≤ n ≤ 100) — the number of students. It is guaranteed that n is even.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 100), where a_i is the skill of the i-th student.
Output
Print one number — the minimum total number of problems students should solve to form exactly n/2 teams.
Examples
Input
6
5 10 2 3 14 5
Output
5
Input
2
1 100
Output
99
Note
In the first example the optimal teams will be: (3, 4), (1, 6) and (2, 5), where numbers in brackets are indices of students. Then, to form the first team the third student should solve 1 problem, to form the second team nobody needs to solve problems and to form the third team the second student should solve 4 problems so the answer is 1 + 4 = 5.
In the second example the first student should solve 99 problems to form a team with the second one. | ```python
n1=int(input())
s1=list(map(int,input().split()))
s1.sort()
sa1=0
se2=0
for i in range(0,n1,2):
sa1=sa1+s1[i]
for i in range(1,n1,2):
se2=se2+s1[i]
print(se2-sa1)
``` |
1140_E. Palindrome-less Arrays | Let's denote that some array b is bad if it contains a subarray b_l, b_{l+1}, ..., b_{r} of odd length more than 1 (l < r and r - l + 1 is odd) such that ∀ i ∈ \{0, 1, ..., r - l\} b_{l + i} = b_{r - i}.
If an array is not bad, it is good.
Now you are given an array a_1, a_2, ..., a_n. Some elements are replaced by -1. Calculate the number of good arrays you can obtain by replacing each -1 with some integer from 1 to k.
Since the answer can be large, print it modulo 998244353.
Input
The first line contains two integers n and k (2 ≤ n, k ≤ 2 ⋅ 10^5) — the length of array a and the size of "alphabet", i. e., the upper bound on the numbers you may use to replace -1.
The second line contains n integers a_1, a_2, ..., a_n (a_i = -1 or 1 ≤ a_i ≤ k) — the array a.
Output
Print one integer — the number of good arrays you can get, modulo 998244353.
Examples
Input
2 3
-1 -1
Output
9
Input
5 2
1 -1 -1 1 2
Output
0
Input
5 3
1 -1 -1 1 2
Output
2
Input
4 200000
-1 -1 12345 -1
Output
735945883 | ```python
class PalArray():
P = 998244353
def __init__(self, n, k, a):
self.n, self.k, self.a = n, k, a
self.dp = None
def fast_pow(self, a, b):
r = 1
while b > 0:
if b%2 == 1:
r = (r*a)%self.P
a = (a*a)%self.P
b = int(b/2)
return r
def populate_dp(self):
self.dp = [[0 for i in range(2)] for j in range(self.n+1)]
self.dp[1][0] = self.k-2
self.dp[1][1] = self.k-1
for i in range(2, self.n+1):
self.dp[i][0] = (((self.k-2)*(self.dp[i-1][0]))%self.P + self.dp[i-1][1])%self.P
self.dp[i][1] = ((self.k-1)*self.dp[i-1][0])%self.P
def check_array(self, a):
for i in range(1, len(a)):
if a[i] != -1 and a[i] == a[i-1]:
return False
return True
def compute_count(self, a):
check = False
res = 1
mis_cnt = 0
lv = None
for v in a:
if v == -1:
mis_cnt += 1
else:
if mis_cnt > 0:
if not check:
check = True
res = (res*self.fast_pow(self.k-1, mis_cnt))%self.P
else:
res = (res*self.dp[mis_cnt][int(lv==v)])%self.P
mis_cnt = 0
lv = v
check = True
if mis_cnt > 0:
if lv is not None:
res = (res*self.fast_pow(self.k-1, mis_cnt))%self.P
else:
res = (((res*self.fast_pow(self.k-1, mis_cnt-1))%self.P)*self.k)%self.P
return res
def num_combinations(self):
self.populate_dp()
a1 = [self.a[i] for i in range(0,self.n,2)]
a2 = [self.a[i] for i in range(1,self.n,2)]
cnt1 = self.compute_count(a1)*int(self.check_array(a1))
cnt2 = self.compute_count(a2)*int(self.check_array(a2))
return (cnt1*cnt2)%self.P
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
print(PalArray(n,k,a).num_combinations())
``` |
1159_C. The Party and Sweets | n boys and m girls came to the party. Each boy presented each girl some integer number of sweets (possibly zero). All boys are numbered with integers from 1 to n and all girls are numbered with integers from 1 to m. For all 1 ≤ i ≤ n the minimal number of sweets, which i-th boy presented to some girl is equal to b_i and for all 1 ≤ j ≤ m the maximal number of sweets, which j-th girl received from some boy is equal to g_j.
More formally, let a_{i,j} be the number of sweets which the i-th boy give to the j-th girl. Then b_i is equal exactly to the minimum among values a_{i,1}, a_{i,2}, …, a_{i,m} and g_j is equal exactly to the maximum among values b_{1,j}, b_{2,j}, …, b_{n,j}.
You are interested in the minimum total number of sweets that boys could present, so you need to minimize the sum of a_{i,j} for all (i,j) such that 1 ≤ i ≤ n and 1 ≤ j ≤ m. You are given the numbers b_1, …, b_n and g_1, …, g_m, determine this number.
Input
The first line contains two integers n and m, separated with space — the number of boys and girls, respectively (2 ≤ n, m ≤ 100 000). The second line contains n integers b_1, …, b_n, separated by spaces — b_i is equal to the minimal number of sweets, which i-th boy presented to some girl (0 ≤ b_i ≤ 10^8). The third line contains m integers g_1, …, g_m, separated by spaces — g_j is equal to the maximal number of sweets, which j-th girl received from some boy (0 ≤ g_j ≤ 10^8).
Output
If the described situation is impossible, print -1. In another case, print the minimal total number of sweets, which boys could have presented and all conditions could have satisfied.
Examples
Input
3 2
1 2 1
3 4
Output
12
Input
2 2
0 1
1 0
Output
-1
Input
2 3
1 0
1 1 2
Output
4
Note
In the first test, the minimal total number of sweets, which boys could have presented is equal to 12. This can be possible, for example, if the first boy presented 1 and 4 sweets, the second boy presented 3 and 2 sweets and the third boy presented 1 and 1 sweets for the first and the second girl, respectively. It's easy to see, that all conditions are satisfied and the total number of sweets is equal to 12.
In the second test, the boys couldn't have presented sweets in such way, that all statements satisfied.
In the third test, the minimal total number of sweets, which boys could have presented is equal to 4. This can be possible, for example, if the first boy presented 1, 1, 2 sweets for the first, second, third girl, respectively and the second boy didn't present sweets for each girl. It's easy to see, that all conditions are satisfied and the total number of sweets is equal to 4. | ```python
n, m = list(map(int, input().split()))
b = list(map(int, input().split()))
g = list(map(int, input().split()))
b.sort()
g.sort()
if b[-1] > g[0]:
print(-1)
elif b[-1] == g[0]:
print(sum(g) + m * (sum(b) - b[-1]))
elif n == 1:
print(-1)
else :
print(sum(g) + b[-1] + b[-2] * (m - 1) + m * (sum(b) - b[-1] - b[-2]))
``` |
1181_C. Flag | Innokenty works at a flea market and sells some random stuff rare items. Recently he found an old rectangular blanket. It turned out that the blanket is split in n ⋅ m colored pieces that form a rectangle with n rows and m columns.
The colored pieces attracted Innokenty's attention so he immediately came up with the following business plan. If he cuts out a subrectangle consisting of three colored stripes, he can sell it as a flag of some country. Innokenty decided that a subrectangle is similar enough to a flag of some country if it consists of three stripes of equal heights placed one above another, where each stripe consists of cells of equal color. Of course, the color of the top stripe must be different from the color of the middle stripe; and the color of the middle stripe must be different from the color of the bottom stripe.
Innokenty has not yet decided what part he will cut out, but he is sure that the flag's boundaries should go along grid lines. Also, Innokenty won't rotate the blanket. Please help Innokenty and count the number of different subrectangles Innokenty can cut out and sell as a flag. Two subrectangles located in different places but forming the same flag are still considered different.
<image> <image> <image>
These subrectangles are flags.
<image> <image> <image> <image> <image> <image>
These subrectangles are not flags.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1 000) — the number of rows and the number of columns on the blanket.
Each of the next n lines contains m lowercase English letters from 'a' to 'z' and describes a row of the blanket. Equal letters correspond to equal colors, different letters correspond to different colors.
Output
In the only line print the number of subrectangles which form valid flags.
Examples
Input
4 3
aaa
bbb
ccb
ddd
Output
6
Input
6 1
a
a
b
b
c
c
Output
1
Note
<image> <image>
The selected subrectangles are flags in the first example. | ```python
import os
from io import BytesIO, StringIO
#input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
DEBUG = True
debug_print = print if DEBUG else lambda *x,**y: None
def input_as_list():
return list(map(int, input().split()))
def array_of(f, *dim):
return [array_of(f, *dim[1:]) for _ in range(dim[0])] if dim else f()
def main():
n, m = input_as_list()
g = [input() for _ in range(n)]
prev_flgs = dict()
s = 0
for j in range(m):
lst = []
prev = ''
cnt = 0
for i in range(n):
e = g[i][j]
if e == prev:
cnt += 1
else:
if prev: lst.append((prev, cnt))
prev = e
cnt = 1
lst.append((e, cnt))
flgs = dict()
idx = 0
for i in range(len(lst) - 2):
f1, f2, f3 = lst[i], lst[i+1], lst[i+2]
if f1[1] == f2[1] == f3[1]:
flgs[idx] = [f1[0]+f2[0]+f3[0], f1[1], 1]
elif min(f1[1], f2[1], f3[1]) == f2[1]:
flgs[idx+f1[1]-f2[1]] = [f1[0]+f2[0]+f3[0], f2[1], 1]
idx += f1[1]
if prev_flgs:
for f in flgs:
if f in prev_flgs:
fv = flgs[f]
pfv = prev_flgs[f]
if fv[0] == pfv[0] and fv[1] == pfv[1]:
s += pfv[2] + 1
flgs[f][2] = pfv[2] + 1
else:
s += 1
else:
s += 1
else:
s += len(flgs)
prev_flgs = flgs
print(s)
main()
``` |
119_B. Before Exam | Vasya is about to take his first university exam in about several minutes. And it's not just some ordinary exam, it's on mathematical analysis. Of course, right now Vasya can only think of one thing: what the result of his talk with the examiner will be...
To prepare for the exam, one has to study proofs of n theorems. It is known that there will be k examination cards on the exam and each card contains <image> distinct theorems. Besides, no theorem is mentioned in more than one card (that is, <image> theorems won't be mentioned in any card). During the exam several students may get the same card.
We do not know the exact way theorems are distributed by cards, however the students that took the exam before Vasya told him what theorems their cards contained. Vasya evaluates his level of proficiency in the i-th theorem by some number ai. The level of proficiency in some card is the average of the levels of proficiency in the theorems that are included in the card. Now Vasya wants to know the minimally and maximally possible levels of his proficiency in the card he gets on the exam. Vasya wants to determine it by the data he has collected from other students. Unfortunately, Vasya has no time left to do the math and he asked you to help him.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 100) — the number of theorems and the number of cards correspondingly. The second line contains n integers ai (0 ≤ ai ≤ 100), the i-th number (1 ≤ i ≤ n) corresponds to Vasya's proficiency in the i-th theorem.
The third line contains number q (0 ≤ q ≤ 100) — the number of people that have taken the exam before Vasya. Each of the following q lines contains the description of a student's card: <image> integers from 1 to n inclusive. They are the numbers of theorems included in the card in the order in which they are enumerated in the input data. The numbers are given in an arbitrary order. It is guaranteed that the given cards are valid (that is, that all theorems in one card are different and that different people get cards that either don't contain the same theorems or coincide up to the theorems' permutation).
Output
Print two real numbers, representing Vasya's minimum and maximum proficiency in the card he will get on the exam. The absolute or relative error should not exceed 10 - 6.
Examples
Input
7 3
7 15 0 19 10 5 12
2
1 6
7 4
Output
5.0000000000 15.5000000000
Input
4 2
10 8 1 17
2
2 3
3 2
Output
4.5000000000 13.5000000000
Note
Let's analyze the first sample. Vasya's proficiency in the cards whose content he already knows equals 6 and 15.5 correspondingly. The three theorems that are left are only enough to make one exam card. If we consider all possible variants of theorems included in the card we can see that in the best case scenario Vasya gets the card that contains theorems 4 and 7 (his proficiency would equal 15.5) and in the worst case scenario he gets theorems 3 and 5 (his proficiency would equal 5).
The ⌊ x⌋ operation denotes taking integer part of real number x (rounding down). | ```python
n,k = map(int, input().split())
a = list(map(int, input().split()))
ansMin, ansMax = 10**10, -10**10
were = [0]*n
sz = n//k
for i in range(int(input())):
cur = 0.0
t = map(int, input().split())
for x in t:
were[x-1]=1
cur+=a[x-1]
cur/=sz
ansMin = min(ansMin, cur)
ansMax = max(ansMax, cur)
remain = []
for i in range(n):
if not were[i]:
remain.append(a[i])
remain.sort()
if len(remain)-n%k>=sz:
ansMin = min(ansMin, 1.0*sum(remain[:sz])/sz)
ansMax = max(ansMax, 1.0*sum(remain[-sz:])/sz)
print('%.10f %.10f' % (ansMin, ansMax))
``` |
1216_F. Wi-Fi | You work as a system administrator in a dormitory, which has n rooms one after another along a straight hallway. Rooms are numbered from 1 to n.
You have to connect all n rooms to the Internet.
You can connect each room to the Internet directly, the cost of such connection for the i-th room is i coins.
Some rooms also have a spot for a router. The cost of placing a router in the i-th room is also i coins. You cannot place a router in a room which does not have a spot for it. When you place a router in the room i, you connect all rooms with the numbers from max(1,~i - k) to min(n,~i + k) inclusive to the Internet, where k is the range of router. The value of k is the same for all routers.
Calculate the minimum total cost of connecting all n rooms to the Internet. You can assume that the number of rooms which have a spot for a router is not greater than the number of routers you have.
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 2 ⋅ 10^5) — the number of rooms and the range of each router.
The second line of the input contains one string s of length n, consisting only of zeros and ones. If the i-th character of the string equals to '1' then there is a spot for a router in the i-th room. If the i-th character of the string equals to '0' then you cannot place a router in the i-th room.
Output
Print one integer — the minimum total cost of connecting all n rooms to the Internet.
Examples
Input
5 2
00100
Output
3
Input
6 1
000000
Output
21
Input
4 1
0011
Output
4
Input
12 6
000010000100
Output
15
Note
In the first example it is enough to place the router in the room 3, then all rooms will be connected to the Internet. The total cost of connection is 3.
In the second example you can place routers nowhere, so you need to connect all rooms directly. Thus, the total cost of connection of all rooms is 1 + 2 + 3 + 4 + 5 + 6 = 21.
In the third example you need to connect the room 1 directly and place the router in the room 3. Thus, the total cost of connection of all rooms is 1 + 3 = 4.
In the fourth example you need to place routers in rooms 5 and 10. Then all rooms will be connected to the Internet. The total cost of connection is 5 + 10 = 15. | ```python
mod=10**9+7
from sys import stdin, stdout
import bisect
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound
import itertools
import collections
import math
import heapq
from random import randint as rn
def modinv(n,p):
return pow(n,p-2,p)
def ncr(n,r,p): #for using this uncomment the lines calculating fact and ifact
t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
return t
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def GCD(x,y):
while(y):
x, y = y, x % y
return x
"""*******************************************************"""
def main():
n,k=map(int,input().split())
s=sin()
q=[]
g=[0]
for i in range(1,n+1):
g.append(g[i - 1] + i)
f=[0]*200001
mi = 1000000000000000
ans = g[n];
z=0
for i in range(1,n+1):
if (s[i-1] == '0'):
continue
f[i] = g[max(0, i - k - 1)] + i;
while (len(q)>0 and z<len(q) and q[z] < i - 2 * k - 1):
mi = min(mi, f[q[z]] - g[q[z] + k])
z+=1
if (len(q)>0 and z<len(q)):
f[i] = min(f[i], f[q[z]] + i)
if (i > k):
f[i] = min(f[i], g[i - k - 1] + mi + i)
while (len(q)>0 and f[-1] > f[i]):
q.pop()
q.append(i)
ans = min(ans, g[n] - g[min(n, i + k)] + f[i]);
print(ans)
######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
#threading.Thread(target=main).start()
``` |
123_B. Squares | You are given an infinite checkered field. You should get from a square (x1; y1) to a square (x2; y2). Using the shortest path is not necessary. You can move on the field squares in four directions. That is, when you are positioned in any square, you can move to any other side-neighboring one.
A square (x; y) is considered bad, if at least one of the two conditions is fulfilled:
* |x + y| ≡ 0 (mod 2a),
* |x - y| ≡ 0 (mod 2b).
Your task is to find the minimum number of bad cells one will have to visit on the way from (x1; y1) to (x2; y2).
Input
The only line contains integers a, b, x1, y1, x2 and y2 — the parameters of the bad squares, the coordinates of the initial and the final squares correspondingly (2 ≤ a, b ≤ 109 and |x1|,|y1|,|x2|,|y2| ≤ 109). It is guaranteed that the initial and the final square aren't bad.
Output
Print a single number — the minimum number of bad cells that one will have to visit in order to travel from square (x1; y1) to square (x2; y2).
Examples
Input
2 2 1 0 0 1
Output
1
Input
2 2 10 11 0 1
Output
5
Input
2 4 3 -1 3 7
Output
2
Note
In the third sample one of the possible paths in (3;-1)->(3;0)->(3;1)->(3;2)->(4;2)->(4;3)->(4;4)->(4;5)->(4;6)->(4;7)->(3;7). Squares (3;1) and (4;4) are bad. | ```python
a, b, x_1, y_1, x_2, y_2 = map(int, input().split())
a_b, a_e = (x_2 + y_2), (x_1 + y_1)
b_b, b_e = (x_2 - y_2), (x_1 - y_1)
if a_b > a_e:
a_b, a_e = a_e, a_b
if b_b > b_e:
b_b, b_e = b_e, b_b
if a_b % (2 * a) != 0:
a_b = (a_b // (2 * a) + 1) * (2 * a)
a_result, b_result = 0, 0
if a_b <= a_e:
a_result = (abs(a_e - a_b) + (2 * a - 1)) // (2 * a)
if b_b % (2 * b) != 0:
b_b = (b_b // (2 * b) + 1) * (2 * b)
if b_b <= b_e:
b_result = (abs(b_e - b_b) + (2 * b - 1)) // (2 * b)
print(max([a_result, b_result]))
``` |
125_C. Hobbits' Party | Everyone knows that hobbits love to organize all sorts of parties and celebrations. There are n hobbits living in the Shire. They decided to organize the Greatest Party (GP) that would last for several days. Next day the hobbits wrote a guest list, some non-empty set containing all the inhabitants of the Shire. To ensure that everybody enjoy themselves and nobody gets bored, for any two days (say, days A and B) of the GP there existed at least one hobbit, invited to come on day A and on day B. However, to ensure that nobody has a row, for any three different days A, B, C there shouldn't be a hobbit invited on days A, B and C. The Shire inhabitants are keen on keeping the GP going for as long as possible. Your task is given number n, to indicate the GP's maximum duration and the guest lists for each day.
Input
The first line contains an integer n (3 ≤ n ≤ 10000), representing the number of hobbits.
Output
In the first output line print a number k — the maximum duration of GP in days. Then on k lines print the guest lists, (the guests should be separated by spaces). Print each guest list on the single line. Each list can contain an arbitrary positive number of hobbits. The hobbits are numbered with integers from 1 to n.
Examples
Input
4
Output
3
1 2
1 3
2 3
Input
5
Output
3
1 2
1 3
2 3 | ```python
n = int(input())
d = int(0.5 + (1 + 8*n)**0.5 / 2)
curr = 1
res = [[] for _ in range(d)]
for i in range(d):
j = i + 1
while len(res[i]) < d - 1:
res[i].append(str(curr))
res[j].append(str(curr))
curr += 1
j += 1
print(d)
for l in res:
print(' '.join(l))
``` |
1281_E. Jeremy Bearimy | Welcome! Everything is fine.
You have arrived in The Medium Place, the place between The Good Place and The Bad Place. You are assigned a task that will either make people happier or torture them for eternity.
You have a list of k pairs of people who have arrived in a new inhabited neighborhood. You need to assign each of the 2k people into one of the 2k houses. Each person will be the resident of exactly one house, and each house will have exactly one resident.
Of course, in the neighborhood, it is possible to visit friends. There are 2k - 1 roads, each of which connects two houses. It takes some time to traverse a road. We will specify the amount of time it takes in the input. The neighborhood is designed in such a way that from anyone's house, there is exactly one sequence of distinct roads you can take to any other house. In other words, the graph with the houses as vertices and the roads as edges is a tree.
The truth is, these k pairs of people are actually soulmates. We index them from 1 to k. We denote by f(i) the amount of time it takes for the i-th pair of soulmates to go to each other's houses.
As we have said before, you will need to assign each of the 2k people into one of the 2k houses. You have two missions, one from the entities in The Good Place and one from the entities of The Bad Place. Here they are:
* The first mission, from The Good Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is minimized. Let's define this minimized sum as G. This makes sure that soulmates can easily and efficiently visit each other;
* The second mission, from The Bad Place, is to assign the people into the houses such that the sum of f(i) over all pairs i is maximized. Let's define this maximized sum as B. This makes sure that soulmates will have a difficult time to visit each other.
What are the values of G and B?
Input
The first line of input contains a single integer t (1 ≤ t ≤ 500) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer k denoting the number of pairs of people (1 ≤ k ≤ 10^5). The next 2k - 1 lines describe the roads; the i-th of them contains three space-separated integers a_i, b_i, t_i which means that the i-th road connects the a_i-th and b_i-th houses with a road that takes t_i units of time to traverse (1 ≤ a_i, b_i ≤ 2k, a_i ≠ b_i, 1 ≤ t_i ≤ 10^6). It is guaranteed that the given roads define a tree structure.
It is guaranteed that the sum of the k in a single file is at most 3 ⋅ 10^5.
Output
For each test case, output a single line containing two space-separated integers G and B.
Example
Input
2
3
1 2 3
3 2 4
2 4 3
4 5 6
5 6 5
2
1 2 1
1 3 2
1 4 3
Output
15 33
6 6
Note
For the sample test case, we have a minimum sum equal to G = 15. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 5 and 6, giving us f(1) = 5;
* The second pair of people get assigned to houses 1 and 4, giving us f(2) = 6;
* The third pair of people get assigned to houses 3 and 2, giving us f(3) = 4.
Note that the sum of the f(i) is 5 + 6 + 4 = 15.
We also have a maximum sum equal to B = 33. One way this can be achieved is with the following assignment:
* The first pair of people get assigned to houses 1 and 4, giving us f(1) = 6;
* The second pair of people get assigned to houses 6 and 2, giving us f(2) = 14;
* The third pair of people get assigned to houses 3 and 5, giving us f(3) = 13.
Note that the sum of the f(i) is 6 + 14 + 13 = 33. | ```python
import sys
def input():
return sys.stdin.readline().strip()
def solve():
k = int(input())
n = 2*k
e = [[] for i in range(n)]
p = [None]*(n)
for i in range(n-1):
a, b, t = map(int, input().split())
a -= 1
b -= 1
e[a].append((b,t))
e[b].append((a,t))
q = [0]
qi = 0
while qi < len(q):
x = q[qi]
qi += 1
px = p[x]
for v, w in e[x]:
if v != px:
q.append(v)
p[v] = x
d1 = [False] * n
d2 = [0] * n
m = 0
M = 0
for qi in range(len(q)-1,-1,-1):
x = q[qi]
px = p[x]
cnt = 1
c1 = 1
for v, w in e[x]:
if v != px:
if d1[v]:
m += w
cnt += 1
dv = d2[v]
M += w * min(dv, n - dv)
c1 += dv
d1[x] = cnt % 2
d2[x] = c1
print(m, M)
for i in range(int(input())):
solve()
``` |
1301_E. Nanosoft | Warawreh created a great company called Nanosoft. The only thing that Warawreh still has to do is to place a large picture containing its logo on top of the company's building.
The logo of Nanosoft can be described as four squares of the same size merged together into one large square. The top left square is colored with red, the top right square is colored with green, the bottom left square is colored with yellow and the bottom right square is colored with blue.
An Example of some correct logos:
<image>
An Example of some incorrect logos:
<image>
Warawreh went to Adhami's store in order to buy the needed picture. Although Adhami's store is very large he has only one picture that can be described as a grid of n rows and m columns. The color of every cell in the picture will be green (the symbol 'G'), red (the symbol 'R'), yellow (the symbol 'Y') or blue (the symbol 'B').
Adhami gave Warawreh q options, in every option he gave him a sub-rectangle from that picture and told him that he can cut that sub-rectangle for him. To choose the best option, Warawreh needs to know for every option the maximum area of sub-square inside the given sub-rectangle that can be a Nanosoft logo. If there are no such sub-squares, the answer is 0.
Warawreh couldn't find the best option himself so he asked you for help, can you help him?
Input
The first line of input contains three integers n, m and q (1 ≤ n , m ≤ 500, 1 ≤ q ≤ 3 ⋅ 10^{5}) — the number of row, the number columns and the number of options.
For the next n lines, every line will contain m characters. In the i-th line the j-th character will contain the color of the cell at the i-th row and j-th column of the Adhami's picture. The color of every cell will be one of these: {'G','Y','R','B'}.
For the next q lines, the input will contain four integers r_1, c_1, r_2 and c_2 (1 ≤ r_1 ≤ r_2 ≤ n, 1 ≤ c_1 ≤ c_2 ≤ m). In that option, Adhami gave to Warawreh a sub-rectangle of the picture with the upper-left corner in the cell (r_1, c_1) and with the bottom-right corner in the cell (r_2, c_2).
Output
For every option print the maximum area of sub-square inside the given sub-rectangle, which can be a NanoSoft Logo. If there are no such sub-squares, print 0.
Examples
Input
5 5 5
RRGGB
RRGGY
YYBBG
YYBBR
RBBRG
1 1 5 5
2 2 5 5
2 2 3 3
1 1 3 5
4 4 5 5
Output
16
4
4
4
0
Input
6 10 5
RRRGGGRRGG
RRRGGGRRGG
RRRGGGYYBB
YYYBBBYYBB
YYYBBBRGRG
YYYBBBYBYB
1 1 6 10
1 3 3 10
2 2 6 6
1 7 6 10
2 1 5 10
Output
36
4
16
16
16
Input
8 8 8
RRRRGGGG
RRRRGGGG
RRRRGGGG
RRRRGGGG
YYYYBBBB
YYYYBBBB
YYYYBBBB
YYYYBBBB
1 1 8 8
5 2 5 7
3 1 8 6
2 3 5 8
1 2 6 8
2 1 5 5
2 1 7 7
6 5 7 5
Output
64
0
16
4
16
4
36
0
Note
Picture for the first test:
<image>
The pictures from the left to the right corresponds to the options. The border of the sub-rectangle in the option is marked with black, the border of the sub-square with the maximal possible size, that can be cut is marked with gray. | ```python
def main():
import sys
input = sys.stdin.buffer.readline
# max
def STfunc(a, b):
if a > b:
return a
else:
return b
# クエリは0-indexedで[(r1, c1), (r2, c2))
class SparseTable():
def __init__(self, grid):
# A: 処理したい2D配列
self.N = len(grid)
self.M = len(grid[0])
self.KN = self.N.bit_length() - 1
self.KM = self.M.bit_length() - 1
self.flatten = lambda n, m, kn, km: \
(n * self.M + m) * ((self.KN + 1) * (self.KM + 1)) + (kn * (self.KM + 1) + km)
self.table = [0] * (self.flatten(self.N - 1, self.M - 1, self.KN, self.KM) + 1)
for i, line in enumerate(grid):
for j, val in enumerate(line):
self.table[self.flatten(i, j, 0, 0)] = val
for km in range(1, self.KM + 1):
for i in range(self.N):
for j in range(self.M):
j2 = j + (1 << (km - 1))
if j2 <= self.M - 1:
self.table[self.flatten(i, j, 0, km)] = \
STfunc(self.table[self.flatten(i, j, 0, km - 1)],
self.table[self.flatten(i, j2, 0, km - 1)])
for kn in range(1, self.KN + 1):
for km in range(self.KM + 1):
for i in range(self.N):
i2 = i + (1 << (kn - 1))
for j in range(self.M):
if i2 <= self.N - 1:
self.table[self.flatten(i, j, kn, km)] = \
STfunc(self.table[self.flatten(i, j, kn - 1, km)],
self.table[self.flatten(i2, j, kn - 1, km)])
def query(self, r1, c1, r2, c2):
# [(r1, c1), (r2, c2))の最小値を求める
kr = (r2 - r1).bit_length() - 1
kc = (c2 - c1).bit_length() - 1
r2 -= (1 << kr)
c2 -= (1 << kc)
return STfunc(STfunc(self.table[self.flatten(r1, c1, kr, kc)], self.table[self.flatten(r2, c1, kr, kc)]),
STfunc(self.table[self.flatten(r1, c2, kr, kc)], self.table[self.flatten(r2, c2, kr, kc)]))
H, W, Q = map(int, input().split())
grid = []
for _ in range(H):
grid.append(input())
#print(grid)
R = [[0] * W for _ in range(H)]
G = [[0] * W for _ in range(H)]
Y = [[0] * W for _ in range(H)]
B = [[0] * W for _ in range(H)]
R_enc = ord('R')
G_enc = ord('G')
Y_enc = ord('Y')
B_enc = ord('B')
for h in range(H):
for w in range(W):
if grid[h][w] == R_enc:
R[h][w] = 1
elif grid[h][w] == G_enc:
G[h][w] = 1
elif grid[h][w] == Y_enc:
Y[h][w] = 1
else:
B[h][w] = 1
for h in range(1, H):
for w in range(1, W):
if R[h][w]:
tmp = min(R[h-1][w-1], R[h-1][w], R[h][w-1]) + 1
if tmp > 1:
R[h][w] = tmp
for h in range(1, H):
for w in range(W-2, -1, -1):
if G[h][w]:
tmp = min(G[h-1][w+1], G[h-1][w], G[h][w+1]) + 1
if tmp > 1:
G[h][w] = tmp
for h in range(H-2, -1, -1):
for w in range(1, W):
if Y[h][w]:
tmp = min(Y[h+1][w-1], Y[h+1][w], Y[h][w-1]) + 1
if tmp > 1:
Y[h][w] = tmp
for h in range(H-2, -1, -1):
for w in range(W-2, -1, -1):
if B[h][w]:
tmp = min(B[h+1][w+1], B[h+1][w], B[h][w+1]) + 1
if tmp > 1:
B[h][w] = tmp
M = [[0] * W for _ in range(H)]
for h in range(H):
for w in range(W):
if h < H-1 and w < W-1:
M[h][w] = min(R[h][w], G[h][w+1], Y[h+1][w], B[h+1][w+1])
ST = SparseTable(M)
ans = [None] * Q
for q in range(Q):
r1, c1, r2, c2 = map(int, input().split())
r1 -= 1
c1 -= 1
r2 -= 1
c2 -= 1
ok = 0
ng = 501
mid = 250
while ng - ok > 1:
R1 = r1 + mid - 1
C1 = c1 + mid - 1
R2 = r2 - mid + 1
C2 = c2 - mid + 1
if R1 >= R2 or C1 >= C2:
ng = mid
mid = (ok + ng)//2
continue
#print(ST.query(R1, C1, R2, C2), mid, [R1, C1, R2, C2])
if ST.query(R1, C1, R2, C2) >= mid:
ok = mid
else:
ng = mid
mid = (ok+ng)//2
#[print(M[h]) for h in range(H)]
ans[q] = (2*ok)**2
sys.stdout.write('\n'.join(map(str, ans)))
if __name__ == '__main__':
main()
``` |
1325_E. Ehab's REAL Number Theory Problem | You are given an array a of length n that has a special condition: every element in this array has at most 7 divisors. Find the length of the shortest non-empty subsequence of this array product of whose elements is a perfect square.
A sequence a is a subsequence of an array b if a can be obtained from b by deletion of several (possibly, zero or all) elements.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of a.
The second line contains n integers a_1, a_2, …, a_{n} (1 ≤ a_i ≤ 10^6) — the elements of the array a.
Output
Output the length of the shortest non-empty subsequence of a product of whose elements is a perfect square. If there are several shortest subsequences, you can find any of them. If there's no such subsequence, print "-1".
Examples
Input
3
1 4 6
Output
1
Input
4
2 3 6 6
Output
2
Input
3
6 15 10
Output
3
Input
4
2 3 5 7
Output
-1
Note
In the first sample, you can choose a subsequence [1].
In the second sample, you can choose a subsequence [6, 6].
In the third sample, you can choose a subsequence [6, 15, 10].
In the fourth sample, there is no such subsequence. | ```python
from collections import deque
import sys
input=sys.stdin.readline
def make_mf():
res=[-1]*(mxa+5)
ptoi=[0]*(mxa+5)
pn=1
for i in range(2,mxa+5):
if res[i]==-1:
res[i]=i
ptoi[i]=pn
pn+=1
for j in range(i**2,mxa+5,i):
if res[j]==-1:res[j]=i
return res,ptoi,pn
def make_to():
to=[[] for _ in range(pn)]
ss=set()
for a in aa:
pp=[]
while a>1:
p=mf[a]
e=0
while p==mf[a]:
a//=p
e^=1
if e:pp.append(p)
if len(pp)==0:ext(1)
elif len(pp)==1:pp.append(1)
u,v=ptoi[pp[0]],ptoi[pp[1]]
to[u].append(v)
to[v].append(u)
if pp[0]**2<=mxa:ss.add(u)
if pp[1]**2<=mxa:ss.add(v)
return to,ss
def ext(ans):
print(ans)
exit()
def solve():
ans=inf
for u in ss:
ans=bfs(u,ans)
if ans==inf:ans=-1
return ans
def bfs(u,ans):
dist=[-1]*pn
q=deque()
q.append((u,0,-1))
dist[u]=0
while q:
u,d,pu=q.popleft()
if d*2>=ans:break
for v in to[u]:
if v==pu:continue
if dist[v]!=-1:ans=min(ans,d+dist[v]+1)
dist[v]=d+1
q.append((v,d+1,u))
return ans
inf=10**9
n=int(input())
aa=list(map(int,input().split()))
mxa=max(aa)
mf,ptoi,pn=make_mf()
to,ss=make_to()
print(solve())
``` |
1344_D. Résumé Review | Uh oh! Applications to tech companies are due soon, and you've been procrastinating by doing contests instead! (Let's pretend for now that it is actually possible to get a job in these uncertain times.)
You have completed many programming projects. In fact, there are exactly n types of programming projects, and you have completed a_i projects of type i. Your résumé has limited space, but you want to carefully choose them in such a way that maximizes your chances of getting hired.
You want to include several projects of the same type to emphasize your expertise, but you also don't want to include so many that the low-quality projects start slipping in. Specifically, you determine the following quantity to be a good indicator of your chances of getting hired:
$$$ f(b_1,…,b_n)=∑_{i=1}^n b_i(a_i-b_i^2). $$$
Here, b_i denotes the number of projects of type i you include in your résumé. Of course, you cannot include more projects than you have completed, so you require 0≤ b_i ≤ a_i for all i.
Your résumé only has enough room for k projects, and you will absolutely not be hired if your résumé has empty space, so you require ∑_{i=1}^n b_i=k.
Find values for b_1,…, b_n that maximize the value of f(b_1,…,b_n) while satisfying the above two constraints.
Input
The first line contains two integers n and k (1≤ n≤ 10^5, 1≤ k≤ ∑_{i=1}^n a_i) — the number of types of programming projects and the résumé size, respectively.
The next line contains n integers a_1,…,a_n (1≤ a_i≤ 10^9) — a_i is equal to the number of completed projects of type i.
Output
In a single line, output n integers b_1,…, b_n that achieve the maximum value of f(b_1,…,b_n), while satisfying the requirements 0≤ b_i≤ a_i and ∑_{i=1}^n b_i=k. If there are multiple solutions, output any.
Note that you do not have to output the value f(b_1,…,b_n).
Examples
Input
10 32
1 2 3 4 5 5 5 5 5 5
Output
1 2 3 3 3 4 4 4 4 4
Input
5 8
4 4 8 2 1
Output
2 2 2 1 1
Note
For the first test, the optimal answer is f=-269. Note that a larger f value is possible if we ignored the constraint ∑_{i=1}^n b_i=k.
For the second test, the optimal answer is f=9. | ```python
import os
import sys
#sys.setrecursionlimit(int(2e5))
from collections import deque
import math
readline = sys.stdin.readline
#####################################################################################
class CF(object):
def __init__(self):
self.eps = 1e-7
self.n, self.k = list(map(int, readline().split()))
self.a = list(map(int, readline().split()))
assert(len(self.a) == self.n)
def fd(self, i):
return 3*i*(i+1) + 1
def find_le(self, x, ca):
if(self.fd(0) > x): return 0, 0
ans = int(((12*x-3) **.5 - 3)/6 + self.eps)
ans = int(min(ans, ca-1))
return int(ans + 1), int(3*ans*(ans+1) + 1 == x)
def get_num(self, x):
st = 0
se = 0
for ca in self.a:
t1,t2 = self.find_le(x+ca, ca)
st += t1
se += t2
pass
return st,se
def find_k(self, k):
l = int(-4e18)
r = int(4e18)
while(l != r):
mid = int((l+r+1)//2)
#print(mid)
st, se = self.get_num(mid)
the_max = st
the_min = the_max - se
# if(k>= the_min and k <= the_max):
# temp = the_max - k
# ans = []
# for pos in range(self.n):
# if(eq[pos] == 1):
# if(temp > 0):
# ans.append(int(tot[pos] - 1))
# temp -= 1
# else:
# ans.append(int(tot[pos]))
# else:
# ans.append(int(tot[pos]))
# pass
# print(' '.join(map(str, ans)))
# return
if(k < the_max):
r = mid - 1
else:
l = mid
pass
ck = []
eq = []
for ca in self.a:
t1,t2 = self.find_le(l+ca, ca)
ck.append(t1)
ck1 = []
eq1 = 0
for ca in self.a:
t1,t2 = self.find_le(l+1+ca, ca)
ck1.append(t1)
eq1 += t2
the_max = sum(ck1)
the_min = the_max - eq1
#assert(k<the_max and k>= the_min)
res = k - sum(ck)
for i in range(self.n):
if(ck1[i]>ck[i]):
if(res>0):
res-=1
ck[i] += 1
pass
print(' '.join(map(str, ck)))
def main(self):
self.find_k(self.k)
pass
if __name__ == "__main__":
cf = CF()
cf.main()
pass
``` |
1366_D. Two Divisors | You are given n integers a_1, a_2, ..., a_n.
For each a_i find its two divisors d_1 > 1 and d_2 > 1 such that \gcd(d_1 + d_2, a_i) = 1 (where \gcd(a, b) is the greatest common divisor of a and b) or say that there is no such pair.
Input
The first line contains single integer n (1 ≤ n ≤ 5 ⋅ 10^5) — the size of the array a.
The second line contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 10^7) — the array a.
Output
To speed up the output, print two lines with n integers in each line.
The i-th integers in the first and second lines should be corresponding divisors d_1 > 1 and d_2 > 1 such that \gcd(d_1 + d_2, a_i) = 1 or -1 and -1 if there is no such pair. If there are multiple answers, print any of them.
Example
Input
10
2 3 4 5 6 7 8 9 10 24
Output
-1 -1 -1 -1 3 -1 -1 -1 2 2
-1 -1 -1 -1 2 -1 -1 -1 5 3
Note
Let's look at a_7 = 8. It has 3 divisors greater than 1: 2, 4, 8. As you can see, the sum of any pair of divisors is divisible by 2 as well as a_7.
There are other valid pairs of d_1 and d_2 for a_{10}=24, like (3, 4) or (8, 3). You can print any of them. | ```python
import sys
from collections import deque, Counter
from itertools import product
from functools import reduce
input = sys.stdin.buffer.readline
n = int(input())
ls = list(map(int, input().split()))
mx = max(ls)
pr = [i for i in range(mx+1)]
for u in range(2, mx+1):
if u*u > mx: break
if pr[u] == u:
for v in range(u*2, mx+1, u):
pr[v] = min(pr[v], u)
def get_fac(n):
fac = []
while n > 1:
p = pr[n]
if not fac or fac[-1] != p: fac.append(p)
n //= p
return fac
d1, d2 = [], []
for u in ls:
f = get_fac(u)
if len(f) < 2:
d1.append(-1)
d2.append(-1)
else:
d1.append(f[0])
d2.append(reduce(lambda x, y: x*y, f[1:]))
print(*d1)
print(*d2)
``` |
1387_A. Graph | You are given an undirected graph where each edge has one of two colors: black or red.
Your task is to assign a real number to each node so that:
* for each black edge the sum of values at its endpoints is 1;
* for each red edge the sum of values at its endpoints is 2;
* the sum of the absolute values of all assigned numbers is the smallest possible.
Otherwise, if it is not possible, report that there is no feasible assignment of the numbers.
Input
The first line contains two integers N (1 ≤ N ≤ 100 000) and M (0 ≤ M ≤ 200 000): the number of nodes and the number of edges, respectively. The nodes are numbered by consecutive integers: 1, 2, …, N.
The next M lines describe the edges. Each line contains three integers a, b and c denoting that there is an edge between nodes a and b (1 ≤ a, b ≤ N) with color c (1 denotes black, 2 denotes red).
Output
If there is a solution, the first line should contain the word "YES" and the second line should contain N space-separated numbers. For each i (1 ≤ i ≤ N), the i-th number should be the number assigned to the node i.
Output should be such that:
* the sum of the numbers at the endpoints of each edge differs from the precise value by less than 10^{-6};
* the sum of the absolute values of all assigned numbers differs from the smallest possible by less than 10^{-6}.
If there are several valid solutions, output any of them.
If there is no solution, the only line should contain the word "NO".
Scoring
Subtasks:
1. (5 points) N ≤ 5, M ≤ 14
2. (12 points) N ≤ 100
3. (17 points) N ≤ 1000
4. (24 points) N ≤ 10 000
5. (42 points) No further constraints
Examples
Input
4 4
1 2 1
2 3 2
1 3 2
3 4 1
Output
YES
0.5 0.5 1.5 -0.5
Input
2 1
1 2 1
Output
YES
0.3 0.7
Input
3 2
1 2 2
2 3 2
Output
YES
0 2 0
Input
3 4
1 2 2
2 2 1
2 1 1
1 2 2
Output
NO
Note
Note that in the second example the solution is not unique. | ```python
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# import heapq as hq
# import bisect as bs
# from collections import deque as dq
# from collections import defaultdict as dc
# from math import ceil,floor,sqrt
# from collections import Counter
n,m = RL()
dic = [[] for _ in range(n+1)]
for _ in range(m):
u,v,t = RL()
dic[u].append((v,t))
dic[v].append((u,t))
v = [None] * (n+1)
f = [True] * (n+1)
key = {}
color = [0]*(n+1)
flag = True
for s in range(1,n+1):
if v[s] is not None: continue
v[s] = 0
color[s] = s
now = [s]
ss = [0]
while now and flag:
p = now.pop()
for child,t in dic[p]:
if v[child] is not None:
if f[child]!=f[p]:
if v[child]+v[p]!=t:
flag = False
break
elif f[child] is True:
if s not in key:
key[s] = (v[child]+v[p]-t)/(-2)
elif v[child]+v[p]+key[s]*2!=t:
flag = False
break
else:
if s not in key:
key[s] = (v[child]+v[p]-t)/2
elif v[child]+v[p]-key[s]*2!=t:
flag = False
break
else:
v[child] = t-v[p]
f[child] = not f[p]
if f[child]:
ss.append(-1*v[child])
else:
ss.append(v[child])
color[child] = s
now.append(child)
if not flag:
break
if s not in key:
ss.sort()
nn = len(ss)
key[s] = (ss[nn>>1]+ss[nn-1>>1])/2
if flag:
print("YES")
res = []
for i in range(1,n+1):
if f[i]:
res.append(v[i]+key[color[i]])
else:
res.append(v[i]-key[color[i]])
print_list(res)
else:
print("NO")
``` |
1408_D. Searchlights | There are n robbers at coordinates (a_1, b_1), (a_2, b_2), ..., (a_n, b_n) and m searchlight at coordinates (c_1, d_1), (c_2, d_2), ..., (c_m, d_m).
In one move you can move each robber to the right (increase a_i of each robber by one) or move each robber up (increase b_i of each robber by one). Note that you should either increase all a_i or all b_i, you can't increase a_i for some points and b_i for some other points.
Searchlight j can see a robber i if a_i ≤ c_j and b_i ≤ d_j.
A configuration of robbers is safe if no searchlight can see a robber (i.e. if there is no pair i,j such that searchlight j can see a robber i).
What is the minimum number of moves you need to perform to reach a safe configuration?
Input
The first line of input contains two integers n and m (1 ≤ n, m ≤ 2000): the number of robbers and the number of searchlight.
Each of the next n lines contains two integers a_i, b_i (0 ≤ a_i, b_i ≤ 10^6), coordinates of robbers.
Each of the next m lines contains two integers c_i, d_i (0 ≤ c_i, d_i ≤ 10^6), coordinates of searchlights.
Output
Print one integer: the minimum number of moves you need to perform to reach a safe configuration.
Examples
Input
1 1
0 0
2 3
Output
3
Input
2 3
1 6
6 1
10 1
1 10
7 7
Output
4
Input
1 2
0 0
0 0
0 0
Output
1
Input
7 3
0 8
3 8
2 7
0 10
5 5
7 0
3 5
6 6
3 11
11 5
Output
6
Note
In the first test, you can move each robber to the right three times. After that there will be one robber in the coordinates (3, 0).
The configuration of the robbers is safe, because the only searchlight can't see the robber, because it is in the coordinates (2, 3) and 3 > 2.
In the second test, you can move each robber to the right two times and two times up. After that robbers will be in the coordinates (3, 8), (8, 3).
It's easy the see that the configuration of the robbers is safe.
It can be proved that you can't reach a safe configuration using no more than 3 moves. | ```python
n, m = map(int, input().split())
robbers = []
lights = []
for i in range(n):
a, b = map(int, input().split())
robbers.append((a, b))
for i in range(m):
c, d = map(int, input().split())
lights.append((c, d))
C = [0] * 1000002
for a, b in robbers:
for c, d in lights:
if a <= c:
C[c - a] = max(C[c - a], d - b + 1)
result = 1000001
max_value = 0
for i in range(1000001, -1, -1):
max_value = max(max_value, C[i])
result = min(result, i + max_value)
print(result)
``` |
1452_B. Toy Blocks | You are asked to watch your nephew who likes to play with toy blocks in a strange way.
He has n boxes and the i-th box has a_i blocks. His game consists of two steps:
1. he chooses an arbitrary box i;
2. he tries to move all blocks from the i-th box to other boxes.
If he can make the same number of blocks in each of n - 1 other boxes then he will be happy, otherwise, will be sad. Note that your nephew can only move the blocks from the chosen box to the other boxes; he cannot move blocks from the other boxes.
You don't want to make your nephew sad, so you decided to put several extra blocks into some boxes in such a way that no matter which box i he chooses he won't be sad. What is the minimum number of extra blocks you need to put?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first line of each test case contains the integer n (2 ≤ n ≤ 10^5) — the number of boxes.
The second line of each test case contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 10^9) — the number of blocks in each box.
It's guaranteed that the sum of n over test cases doesn't exceed 10^5.
Output
For each test case, print a single integer — the minimum number of blocks you need to put. It can be proved that the answer always exists, i. e. the number of blocks is finite.
Example
Input
3
3
3 2 2
4
2 2 3 2
3
0 3 0
Output
1
0
3
Note
In the first test case, you can, for example, put one extra block into the first box and make a = [4, 2, 2]. If your nephew chooses the box with 4 blocks, then we will move two blocks to the second box and two blocks to the third box. If he chooses the box with 2 blocks then he will move these two blocks to the other box with 2 blocks.
In the second test case, you don't need to put any extra blocks, since no matter which box your nephew chooses, he can always make other boxes equal.
In the third test case, you should put 3 extra blocks. For example, you can put 2 blocks in the first box and 1 block in the third box. You'll get array a = [2, 3, 1]. | ```python
from __future__ import division, print_function
import bisect
import math
import heapq
import itertools
import sys
from collections import deque
from atexit import register
from collections import Counter
from functools import reduce
if sys.version_info[0] < 3:
from io import BytesIO as stream
else:
from io import StringIO as stream
if sys.version_info[0] < 3:
class dict(dict):
"""dict() -> new empty dictionary"""
def items(self):
"""D.items() -> a set-like object providing a view on D's items"""
return dict.iteritems(self)
def keys(self):
"""D.keys() -> a set-like object providing a view on D's keys"""
return dict.iterkeys(self)
def values(self):
"""D.values() -> an object providing a view on D's values"""
return dict.itervalues(self)
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def sync_with_stdio(sync=True):
"""Set whether the standard Python streams are allowed to buffer their I/O.
Args:
sync (bool, optional): The new synchronization setting.
"""
global input, flush
if sync:
flush = sys.stdout.flush
else:
sys.stdin = stream(sys.stdin.read())
input = lambda: sys.stdin.readline().rstrip('\r\n')
sys.stdout = stream()
register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
def main():
# sys.stdin = open("input.txt")
for _ in range(int(input())):
n=int(input())
a=[int(o) for o in input().split()]
su = sum(a)
ma = max(a)
k = max(ma,math.ceil(su/(n-1)))
print(k*(n-1)-su)
if __name__ == '__main__':
sync_with_stdio(False)
main()
``` |
1475_G. Strange Beauty | Polycarp found on the street an array a of n elements.
Polycarp invented his criterion for the beauty of an array. He calls an array a beautiful if at least one of the following conditions must be met for each different pair of indices i ≠ j:
* a_i is divisible by a_j;
* or a_j is divisible by a_i.
For example, if:
* n=5 and a=[7, 9, 3, 14, 63], then the a array is not beautiful (for i=4 and j=2, none of the conditions above is met);
* n=3 and a=[2, 14, 42], then the a array is beautiful;
* n=4 and a=[45, 9, 3, 18], then the a array is not beautiful (for i=1 and j=4 none of the conditions above is met);
Ugly arrays upset Polycarp, so he wants to remove some elements from the array a so that it becomes beautiful. Help Polycarp determine the smallest number of elements to remove to make the array a beautiful.
Input
The first line contains one integer t (1 ≤ t ≤ 10) — the number of test cases. Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
The second line of each test case contains n numbers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2 ⋅ 10^5) — elements of the array a.
Output
For each test case output one integer — the minimum number of elements that must be removed to make the array a beautiful.
Example
Input
4
5
7 9 3 14 63
3
2 14 42
4
45 9 3 18
3
2 2 8
Output
2
0
1
0
Note
In the first test case, removing 7 and 14 will make array a beautiful.
In the second test case, the array a is already beautiful.
In the third test case, removing one of the elements 45 or 18 will make the array a beautiful.
In the fourth test case, the array a is beautiful. | ```python
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
def __init__(self, file):
self.newlines = 0
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# --------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def S(): return input().strip()
def print_list(l): print(' '.join(map(str, l)))
# sys.setrecursionlimit(200000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
# from collections import deque as dq
# import math
# import bisect as bs
from collections import Counter
# from collections import defaultdict as dc
for t in range(N()):
n = N()
a = RLL()
count = Counter(a)
dp = [0] * 200001
for i in range(1, 200001):
if count[i] == 0: continue
dp[i] += count[i]
for j in range(2 * i, 200001, i):
dp[j] = max(dp[i], dp[j])
print(n - max(dp))
``` |
1526_A. Mean Inequality | You are given an array a of 2n distinct integers. You want to arrange the elements of the array in a circle such that no element is equal to the the arithmetic mean of its 2 neighbours.
More formally, find an array b, such that:
* b is a permutation of a.
* For every i from 1 to 2n, b_i ≠ \frac{b_{i-1}+b_{i+1}}{2}, where b_0 = b_{2n} and b_{2n+1} = b_1.
It can be proved that under the constraints of this problem, such array b always exists.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases. The description of testcases follows.
The first line of each testcase contains a single integer n (1 ≤ n ≤ 25).
The second line of each testcase contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of the array.
Note that there is no limit to the sum of n over all testcases.
Output
For each testcase, you should output 2n integers, b_1, b_2, … b_{2n}, for which the conditions from the statement are satisfied.
Example
Input
3
3
1 2 3 4 5 6
2
123 456 789 10
1
6 9
Output
3 1 4 2 5 6
123 10 456 789
9 6
Note
In the first testcase, array [3, 1, 4, 2, 5, 6] works, as it's a permutation of [1, 2, 3, 4, 5, 6], and (3+4)/(2)≠ 1, (1+2)/(2)≠ 4, (4+5)/(2)≠ 2, (2+6)/(2)≠ 5, (5+3)/(2)≠ 6, (6+1)/(2)≠ 3. | ```python
for x in range(int(input())):
n = int(input())
m=list(map(int,input().split()))
m.sort(reverse=True)
a=[0]*2*n
for i in range(n):
a[2*i]=m[i]
for i in range(n):
a[2*i+1]=m[n+i]
print(*a)
``` |
157_D. Suspects | As Sherlock Holmes was investigating a crime, he identified n suspects. He knows for sure that exactly one of them committed the crime. To find out which one did it, the detective lines up the suspects and numbered them from 1 to n. After that, he asked each one: "Which one committed the crime?". Suspect number i answered either "The crime was committed by suspect number ai", or "Suspect number ai didn't commit the crime". Also, the suspect could say so about himself (ai = i).
Sherlock Holmes understood for sure that exactly m answers were the truth and all other answers were a lie. Now help him understand this: which suspect lied and which one told the truth?
Input
The first line contains two integers n and m (1 ≤ n ≤ 105, 0 ≤ m ≤ n) — the total number of suspects and the number of suspects who told the truth. Next n lines contain the suspects' answers. The i-th line contains either "+ai" (without the quotes), if the suspect number i says that the crime was committed by suspect number ai, or "-ai" (without the quotes), if the suspect number i says that the suspect number ai didn't commit the crime (ai is an integer, 1 ≤ ai ≤ n).
It is guaranteed that at least one suspect exists, such that if he committed the crime, then exactly m people told the truth.
Output
Print n lines. Line number i should contain "Truth" if suspect number i has told the truth for sure. Print "Lie" if the suspect number i lied for sure and print "Not defined" if he could lie and could tell the truth, too, depending on who committed the crime.
Examples
Input
1 1
+1
Output
Truth
Input
3 2
-1
-2
-3
Output
Not defined
Not defined
Not defined
Input
4 1
+2
-3
+4
-1
Output
Lie
Not defined
Lie
Not defined
Note
The first sample has the single person and he confesses to the crime, and Sherlock Holmes knows that one person is telling the truth. That means that this person is telling the truth.
In the second sample there are three suspects and each one denies his guilt. Sherlock Holmes knows that only two of them are telling the truth. Any one of them can be the criminal, so we don't know for any of them, whether this person is telling the truth or not.
In the third sample the second and the fourth suspect defend the first and the third one. But only one is telling the truth, thus, the first or the third one is the criminal. Both of them can be criminals, so the second and the fourth one can either be lying or telling the truth. The first and the third one are lying for sure as they are blaming the second and the fourth one. | ```python
"""
Brandt Smith, Lemuel Gorion and Peter Haddad
codeforces.com
Problem 156B
"""
import sys
n, m = map(int, input().split(' '))
inp = []
guess = [0] * (n + 1)
for i in range(n):
temp = int(input())
inp.append(temp)
if temp < 0:
m -= 1
guess[-temp] -= 1
else:
guess[temp] += 1
dic = {temp for temp in range(1, n + 1) if guess[temp] == m}
if len(dic) == 0:
for i in range(n):
print('Not defined')
elif len(dic) == 1:
temp = dic.pop()
for i in inp:
if i == temp or (i < 0 and i + temp):
print('Truth')
else:
print('Lie')
else:
temp = dic.update({-i for i in dic})
for i in inp:
if i in dic:
print('Not defined')
else:
if i < 0:
print('Truth')
else:
print('Lie')
# Made By Mostafa_Khaled
``` |
224_A. Parallelepiped | You've got a rectangular parallelepiped with integer edge lengths. You know the areas of its three faces that have a common vertex. Your task is to find the sum of lengths of all 12 edges of this parallelepiped.
Input
The first and the single line contains three space-separated integers — the areas of the parallelepiped's faces. The area's values are positive ( > 0) and do not exceed 104. It is guaranteed that there exists at least one parallelepiped that satisfies the problem statement.
Output
Print a single number — the sum of all edges of the parallelepiped.
Examples
Input
1 1 1
Output
12
Input
4 6 6
Output
28
Note
In the first sample the parallelepiped has sizes 1 × 1 × 1, in the second one — 2 × 2 × 3. | ```python
a,b,c=map(int,input().split())
print(int(4*pow(a*c/b,0.5)+4*pow(a*b/c,0.5)+4*pow(b*c/a,0.5)))
``` |
248_D. Sweets for Everyone! | For he knew every Who down in Whoville beneath, Was busy now, hanging a mistletoe wreath. "And they're hanging their stockings!" he snarled with a sneer, "Tomorrow is Christmas! It's practically here!"
Dr. Suess, How The Grinch Stole Christmas
Christmas celebrations are coming to Whoville. Cindy Lou Who and her parents Lou Lou Who and Betty Lou Who decided to give sweets to all people in their street. They decided to give the residents of each house on the street, one kilogram of sweets. So they need as many kilos of sweets as there are homes on their street.
The street, where the Lou Who family lives can be represented as n consecutive sections of equal length. You can go from any section to a neighbouring one in one unit of time. Each of the sections is one of three types: an empty piece of land, a house or a shop. Cindy Lou and her family can buy sweets in a shop, but no more than one kilogram of sweets in one shop (the vendors care about the residents of Whoville not to overeat on sweets).
After the Lou Who family leave their home, they will be on the first section of the road. To get to this section of the road, they also require one unit of time. We can assume that Cindy and her mom and dad can carry an unlimited number of kilograms of sweets. Every time they are on a house section, they can give a kilogram of sweets to the inhabitants of the house, or they can simply move to another section. If the family have already given sweets to the residents of a house, they can't do it again. Similarly, if they are on the shop section, they can either buy a kilo of sweets in it or skip this shop. If they've bought a kilo of sweets in a shop, the seller of the shop remembered them and the won't sell them a single candy if they come again. The time to buy and give sweets can be neglected. The Lou Whos do not want the people of any house to remain without food.
The Lou Whos want to spend no more than t time units of time to give out sweets, as they really want to have enough time to prepare for the Christmas celebration. In order to have time to give all the sweets, they may have to initially bring additional k kilos of sweets.
Cindy Lou wants to know the minimum number of k kilos of sweets they need to take with them, to have time to give sweets to the residents of each house in their street.
Your task is to write a program that will determine the minimum possible value of k.
Input
The first line of the input contains two space-separated integers n and t (2 ≤ n ≤ 5·105, 1 ≤ t ≤ 109). The second line of the input contains n characters, the i-th of them equals "H" (if the i-th segment contains a house), "S" (if the i-th segment contains a shop) or "." (if the i-th segment doesn't contain a house or a shop).
It is guaranteed that there is at least one segment with a house.
Output
If there isn't a single value of k that makes it possible to give sweets to everybody in at most t units of time, print in a single line "-1" (without the quotes). Otherwise, print on a single line the minimum possible value of k.
Examples
Input
6 6
HSHSHS
Output
1
Input
14 100
...HHHSSS...SH
Output
0
Input
23 50
HHSS.......SSHHHHHHHHHH
Output
8
Note
In the first example, there are as many stores, as houses. If the family do not take a single kilo of sweets from home, in order to treat the inhabitants of the first house, they will need to make at least one step back, and they have absolutely no time for it. If they take one kilogram of sweets, they won't need to go back.
In the second example, the number of shops is equal to the number of houses and plenty of time. Available at all stores passing out candy in one direction and give them when passing in the opposite direction.
In the third example, the shops on the street are fewer than houses. The Lou Whos have to take the missing number of kilograms of sweets with them from home. | ```python
def check(n, casas):
#print('n:',n)
global T,N,street
current = n
time = T
need = 0
last_house = 0
for ind, i in enumerate(street):
time -= 1
if i == 'S':
current += 1
elif i == 'H':
need += 1
if need == 1:
last_house = ind
if need > 0 and current >= need:
#print('p',time, ind-last_house)
current -= need
casas -= need
need = 0
if casas > 0:
if (ind-last_house)*2 >= N-last_house-1:
time -= N-last_house-1 + N-ind-1
return time >= 0
time -= (ind-last_house)*2
else:
time -= ind-last_house
#print('lugar:',i,ind,current, time, need, last_house)
if casas == 0:
break
#print(time)
return time >= 0 and casas == 0
N,T = [int(i) for i in input().split()]
street = input().rstrip('.')
N = len(street)
C = street.count('H')
S = street.count('S')
l = max(C-S, 0)
r = 500005
#print(N, C)
while l < r:
mid = (l+r)//2
if check(mid, C):
r = mid
else:
l = mid + 1
print(l if l < 500005 else -1)
``` |
296_B. Yaroslav and Two Strings | Yaroslav thinks that two strings s and w, consisting of digits and having length n are non-comparable if there are two numbers, i and j (1 ≤ i, j ≤ n), such that si > wi and sj < wj. Here sign si represents the i-th digit of string s, similarly, wj represents the j-th digit of string w.
A string's template is a string that consists of digits and question marks ("?").
Yaroslav has two string templates, each of them has length n. Yaroslav wants to count the number of ways to replace all question marks by some integers in both templates, so as to make the resulting strings incomparable. Note that the obtained strings can contain leading zeroes and that distinct question marks can be replaced by distinct or the same integers.
Help Yaroslav, calculate the remainder after dividing the described number of ways by 1000000007 (109 + 7).
Input
The first line contains integer n (1 ≤ n ≤ 105) — the length of both templates. The second line contains the first template — a string that consists of digits and characters "?". The string's length equals n. The third line contains the second template in the same format.
Output
In a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).
Examples
Input
2
90
09
Output
1
Input
2
11
55
Output
0
Input
5
?????
?????
Output
993531194
Note
The first test contains no question marks and both strings are incomparable, so the answer is 1.
The second test has no question marks, but the given strings are comparable, so the answer is 0. | ```python
#!/usr/bin/python3
def build(n, s, t):
ans = 1
for i in range(n):
if s[i] == '?' and t[i] == '?':
ans = (55 * ans) % (10 ** 9 + 7)
elif s[i] == '?':
ans = ((ord(t[i]) - ord('0') + 1) * ans) % (10 ** 9 + 7)
elif t[i] == '?':
ans = ((ord('9') - ord(s[i]) + 1) * ans) % (10 ** 9 + 7)
return ans
n = int(input())
s = input()
t = input()
sltt = True
tlts = True
qm = 0
cqm = 0
for i in range(n):
if t[i] == '?':
qm += 1
if s[i] == '?':
qm += 1
if t[i] == '?' and s[i] == '?':
cqm += 1
if t[i] == '?' or s[i] == '?':
continue
if ord(s[i]) < ord(t[i]):
tlts = False
if ord(t[i]) < ord(s[i]):
sltt = False
if not sltt and not tlts:
print(pow(10, qm, 10 ** 9 + 7))
elif sltt and tlts:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t) - build(n, t, s) + pow(10, cqm, 10 ** 9 + 7)) % (10 ** 9 + 7))
elif sltt:
print((pow(10, qm, 10 ** 9 + 7) - build(n, s, t)) % (10 ** 9 + 7))
else:
print((pow(10, qm, 10 ** 9 + 7) - build(n, t, s)) % (10 ** 9 + 7))
``` |
319_E. Ping-Pong | In this problem at each moment you have a set of intervals. You can move from interval (a, b) from our set to interval (c, d) from our set if and only if c < a < d or c < b < d. Also there is a path from interval I1 from our set to interval I2 from our set if there is a sequence of successive moves starting from I1 so that we can reach I2.
Your program should handle the queries of the following two types:
1. "1 x y" (x < y) — add the new interval (x, y) to the set of intervals. The length of the new interval is guaranteed to be strictly greater than all the previous intervals.
2. "2 a b" (a ≠ b) — answer the question: is there a path from a-th (one-based) added interval to b-th (one-based) added interval?
Answer all the queries. Note, that initially you have an empty set of intervals.
Input
The first line of the input contains integer n denoting the number of queries, (1 ≤ n ≤ 105). Each of the following lines contains a query as described above. All numbers in the input are integers and don't exceed 109 by their absolute value.
It's guaranteed that all queries are correct.
Output
For each query of the second type print "YES" or "NO" on a separate line depending on the answer.
Examples
Input
5
1 1 5
1 5 11
2 1 2
1 2 9
2 1 2
Output
NO
YES | ```python
def dfs(G, start, path_exists):
s = [start]
visited = set([])
if not start in path_exists:
path_exists[start] = set([])
while(s):
node = s.pop()
if not node in visited:
visited.add(node)
path_exists[start].add(node)
a, b = G[node]
for i, (c, d) in enumerate(G):
if i != node:
if i in path_exists[start] or (c < a < d) or (c < b < d):
s.append(i)
if __name__ == "__main__":
n = int(input())
G = []
path_exists = {}
for _ in range(n):
q, a, b = map(int, input().split())
if q == 1:
G.append((a, b))
else:
a -= 1
b -= 1
dfs(G, a, path_exists)
if b in path_exists[a]:
print("YES")
else:
print("NO")
``` |
367_B. Sereja ans Anagrams | Sereja has two sequences a and b and number p. Sequence a consists of n integers a1, a2, ..., an. Similarly, sequence b consists of m integers b1, b2, ..., bm. As usual, Sereja studies the sequences he has. Today he wants to find the number of positions q (q + (m - 1)·p ≤ n; q ≥ 1), such that sequence b can be obtained from sequence aq, aq + p, aq + 2p, ..., aq + (m - 1)p by rearranging elements.
Sereja needs to rush to the gym, so he asked to find all the described positions of q.
Input
The first line contains three integers n, m and p (1 ≤ n, m ≤ 2·105, 1 ≤ p ≤ 2·105). The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The next line contains m integers b1, b2, ..., bm (1 ≤ bi ≤ 109).
Output
In the first line print the number of valid qs. In the second line, print the valid values in the increasing order.
Examples
Input
5 3 1
1 2 3 2 1
1 2 3
Output
2
1 3
Input
6 3 2
1 3 2 2 3 1
1 2 3
Output
2
1 2 | ```python
from sys import stdin, stdout
from math import log, sqrt
lines = stdin.readlines()
n = int(lines[0].split()[0])
m = int(lines[0].split()[1])
p = int(lines[0].split()[2])
a = [int(x) for x in lines[1].split()]
b = [int(x) for x in lines[2].split()]
def hash_elem(x):
x = (x * 1662634645 + 32544235) & 0xffffffff
x = ((x >> 13) + (x << 19)) & 0xffffffff
x = (x * 361352451) & 0xffffffff
return x
c = [hash_elem(elem) for elem in a]
c_new = [sum([c[q + p * i] for i in range(m)]) for q in range(min(p, max(0, n - (m - 1) * p)))]
for q in range(p, n - (m - 1) * p):
prev = c_new[q - p]
# print(len(c_new)-1, q, q + p*(m-1))
c_new.append(prev - c[q - p] + c[q + p * (m - 1)])
b_check = sum([hash_elem(elem) for elem in b])
ans1 = 0
ans = []
for q in range(n - (m - 1) * p):
c_check = c_new[q]
if b_check != c_check:
continue
else:
ans1 += 1
ans.append(q + 1)
print(ans1)
stdout.write(' '.join([str(x) for x in ans]))
``` |
40_E. Number Table | As it has been found out recently, all the Berland's current economical state can be described using a simple table n × m in size. n — the number of days in each Berland month, m — the number of months. Thus, a table cell corresponds to a day and a month of the Berland's year. Each cell will contain either 1, or -1, which means the state's gains in a particular month, on a particular day. 1 corresponds to profits, -1 corresponds to losses. It turned out important for successful development to analyze the data on the state of the economy of the previous year, however when the treasurers referred to the archives to retrieve the data, it turned out that the table had been substantially damaged. In some table cells the number values had faded and were impossible to be deciphered. It is known that the number of cells in which the data had been preserved is strictly less than max(n, m). However, there is additional information — the product of the numbers in each line and column equaled -1. Your task is to find out how many different tables may conform to the preserved data. As the answer to the task can be quite large, you have to find it modulo p.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000). The second line contains the integer k (0 ≤ k < max(n, m)) — the number of cells in which the data had been preserved. The next k lines contain the data on the state of the table in the preserved cells. Each line is of the form "a b c", where a (1 ≤ a ≤ n) — the number of the table row, b (1 ≤ b ≤ m) — the number of the column, c — the value containing in the cell (1 or -1). They are numbered starting from 1. It is guaranteed that no two lines with same a and b values exist. The last line contains an integer p (2 ≤ p ≤ 109 + 7).
Output
Print the number of different tables that could conform to the preserved data modulo p.
Examples
Input
2 2
0
100
Output
2
Input
2 2
1
1 1 -1
100
Output
1 | ```python
import itertools
import math
n, m = [int(x) for x in input().split()]
if n%2 != m%2:
print(0)
else:
k = int(input())
S = [[] for i in range(max(n,m))]
for i in range(k):
a, b, c = [int(x) for x in input().split()]
if n<m:
S[b-1].append(c==-1)
else:
S[a-1].append(c==-1)
p = int(input())
restrictions = k
for string in S:
if len(string) >= min(n,m):
if sum(string)%2:
restrictions -= 1
else:
print(0)
break
else:
print(pow(2, (n-1)*(m-1) - restrictions, p))
``` |
460_A. Vasya and Socks | Vasya has n pairs of socks. In the morning of each day Vasya has to put on a pair of socks before he goes to school. When he comes home in the evening, Vasya takes off the used socks and throws them away. Every m-th day (at days with numbers m, 2m, 3m, ...) mom buys a pair of socks to Vasya. She does it late in the evening, so that Vasya cannot put on a new pair of socks before the next day. How many consecutive days pass until Vasya runs out of socks?
Input
The single line contains two integers n and m (1 ≤ n ≤ 100; 2 ≤ m ≤ 100), separated by a space.
Output
Print a single integer — the answer to the problem.
Examples
Input
2 2
Output
3
Input
9 3
Output
13
Note
In the first sample Vasya spends the first two days wearing the socks that he had initially. Then on day three he puts on the socks that were bought on day two.
In the second sample Vasya spends the first nine days wearing the socks that he had initially. Then he spends three days wearing the socks that were bought on the third, sixth and ninth days. Than he spends another day wearing the socks that were bought on the twelfth day. | ```python
n, m = map(int, input().split() )
r = 0
t = 1
while n:
n -= 1
if t % m == 0:
n += 1
t += 1
print(t-1)
``` |
507_E. Breaking Good | Breaking Good is a new video game which a lot of gamers want to have. There is a certain level in the game that is really difficult even for experienced gamers.
Walter William, the main character of the game, wants to join a gang called Los Hermanos (The Brothers). The gang controls the whole country which consists of n cities with m bidirectional roads connecting them. There is no road is connecting a city to itself and for any two cities there is at most one road between them. The country is connected, in the other words, it is possible to reach any city from any other city using the given roads.
The roads aren't all working. There are some roads which need some more work to be performed to be completely functioning.
The gang is going to rob a bank! The bank is located in city 1. As usual, the hardest part is to escape to their headquarters where the police can't get them. The gang's headquarters is in city n. To gain the gang's trust, Walter is in charge of this operation, so he came up with a smart plan.
First of all the path which they are going to use on their way back from city 1 to their headquarters n must be as short as possible, since it is important to finish operation as fast as possible.
Then, gang has to blow up all other roads in country that don't lay on this path, in order to prevent any police reinforcements. In case of non-working road, they don't have to blow up it as it is already malfunctional.
If the chosen path has some roads that doesn't work they'll have to repair those roads before the operation.
Walter discovered that there was a lot of paths that satisfied the condition of being shortest possible so he decided to choose among them a path that minimizes the total number of affected roads (both roads that have to be blown up and roads to be repaired).
Can you help Walter complete his task and gain the gang's trust?
Input
The first line of input contains two integers n, m (2 ≤ n ≤ 105, <image>), the number of cities and number of roads respectively.
In following m lines there are descriptions of roads. Each description consists of three integers x, y, z (1 ≤ x, y ≤ n, <image>) meaning that there is a road connecting cities number x and y. If z = 1, this road is working, otherwise it is not.
Output
In the first line output one integer k, the minimum possible number of roads affected by gang.
In the following k lines output three integers describing roads that should be affected. Each line should contain three integers x, y, z (1 ≤ x, y ≤ n, <image>), cities connected by a road and the new state of a road. z = 1 indicates that the road between cities x and y should be repaired and z = 0 means that road should be blown up.
You may output roads in any order. Each affected road should appear exactly once. You may output cities connected by a single road in any order. If you output a road, it's original state should be different from z.
After performing all operations accroding to your plan, there should remain working only roads lying on some certain shortest past between city 1 and n.
If there are multiple optimal answers output any.
Examples
Input
2 1
1 2 0
Output
1
1 2 1
Input
4 4
1 2 1
1 3 0
2 3 1
3 4 1
Output
3
1 2 0
1 3 1
2 3 0
Input
8 9
1 2 0
8 3 0
2 3 1
1 4 1
8 7 0
1 5 1
4 6 1
5 7 0
6 8 0
Output
3
2 3 0
1 5 0
6 8 1
Note
In the first test the only path is 1 - 2
In the second test the only shortest path is 1 - 3 - 4
In the third test there are multiple shortest paths but the optimal is 1 - 4 - 6 - 8 | ```python
from collections import deque
def bfs(n, v, s, t):
dis = [n] * n
load = [n] * n
path = [None] * n
q = deque([s])
dis[s] = 0
load[s] = 0
while (q):
node = q.popleft()
for i in range(len(v[node])):
nb = v[node][i][0]
status = v[node][i][1]
tmp_dis = dis[node] + 1
tmp_load = load[node] + (status != 1)
if ((tmp_dis, tmp_load) < (dis[nb], load[nb])):
dis[nb] = tmp_dis
load[nb] = tmp_load
path[nb] = node
if (node != t): q.append(nb)
if (node == t):
break
node = t
opt = set()
while (node != s):
opt.add((min(node, path[node]), max(node, path[node])))
node = path[node]
return dis[t], load[t], opt
#def sp(s, t):
## dijkstra
#global m, n, v, st, l_min, w_min, opt
#current = s
#visited = set([s])
#dis = {}
#dis[s] = 0
#path = [[] for _ in xrange(n)]
#path[s] = [[]]
#load = [[] for _ in xrange(n)]
#load[s] = [0]
#while (current != t):
#if (debug >= 2):
#print 'current=%d' % current
#for i in xrange(len(v[current])):
#nb = v[current][i]
#status = st[current][i]
#if (debug >= 2):
#print ' nb=%d, st=%d:' % (nb, status),
#if (not dis.has_key(nb) or dis[nb] > 1 + dis[current]):
## update
#dis[nb] = 1 + dis[current]
#load[nb] = []
#path[nb] = []
#for j in xrange(len(load[current])):
#path[nb].append(path[current][j][:])
#path[nb][j].append((current, nb))
#if (status == 0):
#load[nb].append(load[current][j] + 1)
#else:
#load[nb].append(load[current][j])
#if (debug >= 2):
#print 'Updated'
#elif (dis[nb] == 1 + dis[current]):
## append
#for j in xrange(len(load[current])):
#path[nb].append(path[current][j][:])
#path[nb][len(path[nb]) - 1].append((current, nb))
#if (status == 0): load[nb].append(1 + load[current][j])
#else: load[nb].append(load[current][j])
#if (debug >= 2):
#print 'Appended'
#else:
#if (debug >= 2):
#print 'Passed'
#sorted_idx = sorted(dis, key = dis.get)
#if (debug >= 2): print sorted_idx
#idx = 0
#while (sorted_idx[idx] in visited): idx += 1
#current = sorted_idx[idx]
#visited.add(current)
#w_min = min(load[t])
#l_min = dis[t]
#opt = tuple(path[t][load[t].index(w_min)])
#return 0
#def dfs(s, t, visited, path, l, w):
#global m, n, v, st, l_min, w_min, opt
##print path
#if (s == t):
#if (l < l_min):
#l_min = l
#w_min = w
#opt = tuple(path)
#else:
#if (w < w_min):
#w_min = w
#opt = tuple(path)
#return 0
#if (l >= l_min): return 0
##if (w >= w_min): return 0
#for i in xrange(len(v[s])):
#if (v[s][i] in visited): continue
#visited.add(v[s][i])
#path.append((s, v[s][i]))
#if (st[s][i] == 1):
#dfs(v[s][i], t, visited, path, l + 1, w)
#else:
#dfs(v[s][i], t, visited, path, l + 1, w + 1)
#visited.remove(v[s][i])
#path.pop(len(path) - 1)
#return 0
global debug
debug = 0
#global m, n, v, st, l_min, w_min
n, m = list(map(int, input().split()))
#e = []
v = [[] for _ in range(n)]
a = 0 # bad count
b = 0 # good count
#l_min = n
#w_min = n
#opt = ()
for i in range(m):
v1, v2, status = list(map(int, input().split()))
if (status == 0): a += 1
else: b += 1
v[v1 - 1].append((v2 - 1, status))
v[v2 - 1].append((v1 - 1, status))
#e.append((v1, v2, status))
if (debug >= 1): t0 = time.time()
#dfs(0, n - 1, set(), [], 0, 0)
#sp(n - 1, 0)
#sp(0, n - 1)
l_min, w_min, opt = bfs(n, v, 0, n - 1)
#l_min, w_min, opt = bfs(n, v, st, n - 1, 0)
print(b - l_min + 2 * w_min)
#print opt
#for i in xrange(len(e)):
# if ((e[i][0] - 1, e[i][1] - 1) in opt or (e[i][1] - 1, e[i][0] - 1) in opt):
# if (e[i][2] == 0): print '%d %d 1' % (e[i][0], e[i][1])
# else:
# if (e[i][2] == 1): print '%d %d 0' % (e[i][0], e[i][1])
#for i in xrange(len(e)):
# if ((min(e[i][0] - 1, e[i][1] - 1), max(e[i][0] - 1, e[i][1] - 1)) in opt):
# if (e[i][2] == 0): print '%d %d 1' % (e[i][0], e[i][1])
# else:
# if (e[i][2] == 1): print '%d %d 0' % (e[i][0], e[i][1])
for v1 in range(n):
for v2, status in v[v1]:
if (v2 < v1): continue
if ((v1, v2) in opt):
if (status == 0): print('%d %d 1' % (v1 + 1, v2 + 1))
else:
if (status == 1): print('%d %d 0' % (v1 + 1, v2 + 1))
if (debug >= 1): print('%f' % (time.time() - t0))
``` |
557_A. Ilya and Diplomas | Soon a school Olympiad in Informatics will be held in Berland, n schoolchildren will participate there.
At a meeting of the jury of the Olympiad it was decided that each of the n participants, depending on the results, will get a diploma of the first, second or third degree. Thus, each student will receive exactly one diploma.
They also decided that there must be given at least min1 and at most max1 diplomas of the first degree, at least min2 and at most max2 diplomas of the second degree, and at least min3 and at most max3 diplomas of the third degree.
After some discussion it was decided to choose from all the options of distributing diplomas satisfying these limitations the one that maximizes the number of participants who receive diplomas of the first degree. Of all these options they select the one which maximizes the number of the participants who receive diplomas of the second degree. If there are multiple of these options, they select the option that maximizes the number of diplomas of the third degree.
Choosing the best option of distributing certificates was entrusted to Ilya, one of the best programmers of Berland. However, he found more important things to do, so it is your task now to choose the best option of distributing of diplomas, based on the described limitations.
It is guaranteed that the described limitations are such that there is a way to choose such an option of distributing diplomas that all n participants of the Olympiad will receive a diploma of some degree.
Input
The first line of the input contains a single integer n (3 ≤ n ≤ 3·106) — the number of schoolchildren who will participate in the Olympiad.
The next line of the input contains two integers min1 and max1 (1 ≤ min1 ≤ max1 ≤ 106) — the minimum and maximum limits on the number of diplomas of the first degree that can be distributed.
The third line of the input contains two integers min2 and max2 (1 ≤ min2 ≤ max2 ≤ 106) — the minimum and maximum limits on the number of diplomas of the second degree that can be distributed.
The next line of the input contains two integers min3 and max3 (1 ≤ min3 ≤ max3 ≤ 106) — the minimum and maximum limits on the number of diplomas of the third degree that can be distributed.
It is guaranteed that min1 + min2 + min3 ≤ n ≤ max1 + max2 + max3.
Output
In the first line of the output print three numbers, showing how many diplomas of the first, second and third degree will be given to students in the optimal variant of distributing diplomas.
The optimal variant of distributing diplomas is the one that maximizes the number of students who receive diplomas of the first degree. Of all the suitable options, the best one is the one which maximizes the number of participants who receive diplomas of the second degree. If there are several of these options, the best one is the one that maximizes the number of diplomas of the third degree.
Examples
Input
6
1 5
2 6
3 7
Output
1 2 3
Input
10
1 2
1 3
1 5
Output
2 3 5
Input
6
1 3
2 2
2 2
Output
2 2 2 | ```python
ttl = int(input())
mx1 = [int(i) for i in list(input().split(" "))]
mx2 = [int(i) for i in list(input().split(" "))]
mx3 = [int(i) for i in list(input().split(" "))]
min1 = mx1[0]
min2 = mx2[0]
min3 = mx3[0]
max1 = mx1[1]-min1
max2 = mx2[1]-min2
max3 = mx3[1]-min3
ttl -=(mx1[0]+mx2[0]+mx3[0])
while(ttl>0):
if(ttl>=(max1) and ttl>0):
ttl -= max1
min1+= max1
else:
min1 += ttl
ttl = 0
if(ttl>=(max2) and ttl>0):
ttl -= max2
min2+= max2
else:
min2 += ttl
ttl = 0
if(ttl>=(max3) and ttl>0):
ttl -= max3
min3+= max3
else:
min3 += ttl
ttl = 0
print(str(min1)+" "+str(min2)+" "+str(min3))
``` |
604_D. Moodular Arithmetic | As behooves any intelligent schoolboy, Kevin Sun is studying psycowlogy, cowculus, and cryptcowgraphy at the Bovinia State University (BGU) under Farmer Ivan. During his Mathematics of Olympiads (MoO) class, Kevin was confronted with a weird functional equation and needs your help. For two fixed integers k and p, where p is an odd prime number, the functional equation states that
<image>
for some function <image>. (This equation should hold for any integer x in the range 0 to p - 1, inclusive.)
It turns out that f can actually be many different functions. Instead of finding a solution, Kevin wants you to count the number of distinct functions f that satisfy this equation. Since the answer may be very large, you should print your result modulo 109 + 7.
Input
The input consists of two space-separated integers p and k (3 ≤ p ≤ 1 000 000, 0 ≤ k ≤ p - 1) on a single line. It is guaranteed that p is an odd prime number.
Output
Print a single integer, the number of distinct functions f modulo 109 + 7.
Examples
Input
3 2
Output
3
Input
5 4
Output
25
Note
In the first sample, p = 3 and k = 2. The following functions work:
1. f(0) = 0, f(1) = 1, f(2) = 2.
2. f(0) = 0, f(1) = 2, f(2) = 1.
3. f(0) = f(1) = f(2) = 0. | ```python
MOD = 10**9+7
def f(a,b):
if b == 1:
return a%MOD
elif b % 2 == 0:
return f((a*a)%MOD,b//2)
else:
return (a*f((a*a)%MOD,b//2)) % MOD
p,k = map(int,input().split())
if k == 0:
print(f(p,p-1))
exit()
if k == 1:
print(f(p,p))
exit()
t = 1
a = k
while a != 1:
a = (a*k % p)
t += 1
n = (p-1)//t
print(f(p,n))
``` |
676_C. Vasya and String | High school student Vasya got a string of length n as a birthday present. This string consists of letters 'a' and 'b' only. Vasya denotes beauty of the string as the maximum length of a substring (consecutive subsequence) consisting of equal letters.
Vasya can change no more than k characters of the original string. What is the maximum beauty of the string he can achieve?
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 100 000, 0 ≤ k ≤ n) — the length of the string and the maximum number of characters to change.
The second line contains the string, consisting of letters 'a' and 'b' only.
Output
Print the only integer — the maximum beauty of the string Vasya can achieve by changing no more than k characters.
Examples
Input
4 2
abba
Output
4
Input
8 1
aabaabaa
Output
5
Note
In the first sample, Vasya can obtain both strings "aaaa" and "bbbb".
In the second sample, the optimal answer is obtained with the string "aaaaabaa" or with the string "aabaaaaa". | ```python
######### ## ## ## #### ##### ## # ## # ##
# # # # # # # # # # # # # # # # # # #
# # # # ### # # # # # # # # # # # #
# ##### # # # # ### # # # # # # # # #####
# # # # # # # # # # # # # # # # # #
######### # # # # ##### # ##### # ## # ## # #
"""
PPPPPPP RRRRRRR OOOO VV VV EEEEEEEEEE
PPPPPPPP RRRRRRRR OOOOOO VV VV EE
PPPPPPPPP RRRRRRRRR OOOOOOOO VV VV EE
PPPPPPPP RRRRRRRR OOOOOOOO VV VV EEEEEE
PPPPPPP RRRRRRR OOOOOOOO VV VV EEEEEEE
PP RRRR OOOOOOOO VV VV EEEEEE
PP RR RR OOOOOOOO VV VV EE
PP RR RR OOOOOO VV VV EE
PP RR RR OOOO VVVV EEEEEEEEEE
"""
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
import sys
input = sys.stdin.readline
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if(k > n - k):
k = n - k;
res = 1;
for i in range(k):
res = res * (n - i);
res = res / (i + 1);
return int(res);
## upper bound function code -- such that e in a[:i] e < x;
def upper_bound(a, x, lo=0, hi = None):
if hi == None:
hi = len(a);
while lo < hi:
mid = (lo+hi)//2;
if a[mid] < x:
lo = mid+1;
else:
hi = mid;
return lo;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
# spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
ret = {};
while x != 1:
ret[spf[x]] = ret.get(spf[x], 0) + 1;
x = x//spf[x]
return ret;
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
def possible(freq, l, k):
for i in range(l, len(freq)):
val = freq[i] - freq[i - l]
alt = l - val
if val + k >= l or alt + k >= l:
return True
return False
def solve():
maxim = 0
n, k = map(int, input().split())
s = list(input())
if s[-1] == '\n':
s.pop()
freq = [0]
for x in s:
if x == 'a':
if len(freq) == 0:
freq.append(1)
else:
freq.append(freq[-1] + 1)
else:
freq.append(freq[-1])
# print(freq)
low, high = 0, n + 1
while low < high:
mid = (high - low) // 2 + low
if possible(freq, mid, k):
maxim = max(maxim, mid)
low = mid + 1
else:
high = mid
print(maxim)
if __name__ == '__main__':
for _ in range(1):
solve()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
``` |
69_C. Game | In one school with Vasya there is a student Kostya. Kostya does not like physics, he likes different online games. Every day, having come home, Kostya throws his bag in the farthest corner and sits down at his beloved computer. Kostya even eats glued to the game. A few days ago Kostya bought a new RPG game "HaresButtle", which differs from all other games in this genre. It has a huge number of artifacts. As we know, artifacts are divided into basic and composite ones. Only the basic artifacts are available on sale. More powerful composite artifacts are collected from some number of basic artifacts.
After the composing composite artifact, all the components disappear.
Kostya is the head of the alliance, so he has to remember, what artifacts has not only himself, but also his allies. You must identify by sequence of artifacts purchased by Kostya and his allies, how many and which artifacts has been collected by each of them. It is believed that initially no one has any artifacts.
Input
The first line has 4 natural numbers: k (1 ≤ k ≤ 100) — the number of Kostya's allies, n (1 ≤ n ≤ 50) — the number of basic artifacts, m (0 ≤ m ≤ 50) — the number of composite artifacts, q (1 ≤ q ≤ 500) — the number of his friends' purchases. The following n lines contain the names of basic artifacts. After them m lines contain the descriptions of composite artifacts in the following format:
<Art. Name>: <Art. №1> <Art. №1 Number>, <Art. №2> <Art. №2 Number>, ... <Art. №X> <Art. №Х Number>
All the numbers are natural numbers not exceeding 100 (1 ≤ X ≤ n).
The names of all artifacts are different, they are composed of lowercase Latin letters, and the length of each name is from 1 to 100 characters inclusive. All the words in the format of the description of a composite artifact are separated by exactly one space. It is guaranteed that all components of the new artifact are different and have already been met in the input data as the names of basic artifacts.
Next, each of the following q lines is characterized by the number ai, the number of a friend who has bought the artifact (1 ≤ ai ≤ k), and the name of the purchased basic artifact. Let's assume that the backpacks of the heroes are infinitely large and any artifact bought later can fit in there.
It is guaranteed that after the i-th purchase no more than one opportunity to collect the composite artifact appears. If such an opportunity arose, the hero must take advantage of it.
Output
The output file should consist of k blocks. The first line should contain number bi — the number of different artifacts the i-th ally has. Then the block should contain bi lines with the names of these artifacts and the number of these artifacts. At that the lines should be printed in accordance with the lexicographical order of the names of the artifacts. In each block all the artifacts must be different, and all the numbers except the bi should be positive.
Examples
Input
2 3 2 5
desolator
refresher
perseverance
vanguard: desolator 1, refresher 1
maelstorm: perseverance 2
1 desolator
2 perseverance
1 refresher
2 desolator
2 perseverance
Output
1
vanguard 1
2
desolator 1
maelstorm 1 | ```python
# Not really fair, since I already solved this one previously. ;)
k, n, m, q = [int(i) for i in input().split()]
basic = [input() for i in range(n)]
composite = {}
for i in range(m):
name, items = input().split(":")
composite[name] = {}
for item in items.split(","):
component, cnt = item.split()
composite[name][component] = int(cnt)
friends = {}
for i in range(1, k+1):
friends[str(i)] = {}
for artifact in basic:
friends[str(i)][artifact] = 0
for artifact in composite.keys():
friends[str(i)][artifact] = 0
for i in range(q):
ai, artifact = input().split()
friends[ai][artifact] += 1
for artifact, combo in composite.items():
if all(friends[ai][basic]==cnt for basic, cnt in combo.items()):
for basic, cnt in combo.items():
friends[ai][basic] -= cnt
friends[ai][artifact] += 1
break
for i in range(1, k+1):
print(sum([i>0 for i in friends[str(i)].values()]))
for artifact in sorted(friends[str(i)].keys()):
if friends[str(i)][artifact] > 0:
print(artifact, friends[str(i)][artifact])
``` |
742_C. Arpa's loud Owf and Mehrdad's evil plan | As you have noticed, there are lovely girls in Arpa’s land.
People in Arpa's land are numbered from 1 to n. Everyone has exactly one crush, i-th person's crush is person with the number crushi.
<image>
Someday Arpa shouted Owf loudly from the top of the palace and a funny game started in Arpa's land. The rules are as follows.
The game consists of rounds. Assume person x wants to start a round, he calls crushx and says: "Oww...wwf" (the letter w is repeated t times) and cuts off the phone immediately. If t > 1 then crushx calls crushcrushx and says: "Oww...wwf" (the letter w is repeated t - 1 times) and cuts off the phone immediately. The round continues until some person receives an "Owf" (t = 1). This person is called the Joon-Joon of the round. There can't be two rounds at the same time.
Mehrdad has an evil plan to make the game more funny, he wants to find smallest t (t ≥ 1) such that for each person x, if x starts some round and y becomes the Joon-Joon of the round, then by starting from y, x would become the Joon-Joon of the round. Find such t for Mehrdad if it's possible.
Some strange fact in Arpa's land is that someone can be himself's crush (i.e. crushi = i).
Input
The first line of input contains integer n (1 ≤ n ≤ 100) — the number of people in Arpa's land.
The second line contains n integers, i-th of them is crushi (1 ≤ crushi ≤ n) — the number of i-th person's crush.
Output
If there is no t satisfying the condition, print -1. Otherwise print such smallest t.
Examples
Input
4
2 3 1 4
Output
3
Input
4
4 4 4 4
Output
-1
Input
4
2 1 4 3
Output
1
Note
In the first sample suppose t = 3.
If the first person starts some round:
The first person calls the second person and says "Owwwf", then the second person calls the third person and says "Owwf", then the third person calls the first person and says "Owf", so the first person becomes Joon-Joon of the round. So the condition is satisfied if x is 1.
The process is similar for the second and the third person.
If the fourth person starts some round:
The fourth person calls himself and says "Owwwf", then he calls himself again and says "Owwf", then he calls himself for another time and says "Owf", so the fourth person becomes Joon-Joon of the round. So the condition is satisfied when x is 4.
In the last example if the first person starts a round, then the second person becomes the Joon-Joon, and vice versa. | ```python
from math import gcd
def DFS(v):
re = 0
cur = v
while not used[cur]:
used[cur] = True
re += 1
cur = gr[cur]
if re % 2 == 0:
re //= 2
return 0 if cur != v else re
n = int(input())
used = [False] * (n + 1)
gr = [0] + list(map(int, input().split()))
res = 1
for u in range(1, len(gr)):
if not used[u]:
r = DFS(u)
if r:
res = (res * r) // gcd(res, r)
else:
print(-1)
exit()
print(res)
``` |
810_A. Straight «A» | Noora is a student of one famous high school. It's her final year in school — she is going to study in university next year. However, she has to get an «A» graduation certificate in order to apply to a prestigious one.
In school, where Noora is studying, teachers are putting down marks to the online class register, which are integers from 1 to k. The worst mark is 1, the best is k. Mark that is going to the certificate, is calculated as an average of all the marks, rounded to the closest integer. If several answers are possible, rounding up is produced. For example, 7.3 is rounded to 7, but 7.5 and 7.8784 — to 8.
For instance, if Noora has marks [8, 9], then the mark to the certificate is 9, because the average is equal to 8.5 and rounded to 9, but if the marks are [8, 8, 9], Noora will have graduation certificate with 8.
To graduate with «A» certificate, Noora has to have mark k.
Noora got n marks in register this year. However, she is afraid that her marks are not enough to get final mark k. Noora decided to ask for help in the internet, where hacker Leha immediately responded to her request. He is ready to hack class register for Noora and to add Noora any number of additional marks from 1 to k. At the same time, Leha want his hack be unseen to everyone, so he decided to add as less as possible additional marks. Please help Leha to calculate the minimal number of marks he has to add, so that final Noora's mark will become equal to k.
Input
The first line contains two integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 100) denoting the number of marks, received by Noora and the value of highest possible mark.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ k) denoting marks received by Noora before Leha's hack.
Output
Print a single integer — minimal number of additional marks, that Leha has to add in order to change Noora's final mark to k.
Examples
Input
2 10
8 9
Output
4
Input
3 5
4 4 4
Output
3
Note
Consider the first example testcase.
Maximal mark is 10, Noora received two marks — 8 and 9, so current final mark is 9. To fix it, Leha can add marks [10, 10, 10, 10] (4 marks in total) to the registry, achieving Noora having average mark equal to <image>. Consequently, new final mark is 10. Less number of marks won't fix the situation.
In the second example Leha can add [5, 5, 5] to the registry, so that making average mark equal to 4.5, which is enough to have 5 in the certificate. | ```python
n,k=tuple(int(i) for i in input().strip().split(" "))
a=input().strip().split(" ")
sum=0
o=0
for i in a:
sum+=int(i)
if sum/n>=k-0.5:
print(0)
exit(0)
while sum/n<k-0.5:
sum+=k
n+=1
o+=1
print(o)
``` |
835_D. Palindromic characteristics | Palindromic characteristics of string s with length |s| is a sequence of |s| integers, where k-th number is the total number of non-empty substrings of s which are k-palindromes.
A string is 1-palindrome if and only if it reads the same backward as forward.
A string is k-palindrome (k > 1) if and only if:
1. Its left half equals to its right half.
2. Its left and right halfs are non-empty (k - 1)-palindromes.
The left half of string t is its prefix of length ⌊|t| / 2⌋, and right half — the suffix of the same length. ⌊|t| / 2⌋ denotes the length of string t divided by 2, rounded down.
Note that each substring is counted as many times as it appears in the string. For example, in the string "aaa" the substring "a" appears 3 times.
Input
The first line contains the string s (1 ≤ |s| ≤ 5000) consisting of lowercase English letters.
Output
Print |s| integers — palindromic characteristics of string s.
Examples
Input
abba
Output
6 1 0 0
Input
abacaba
Output
12 4 1 0 0 0 0
Note
In the first example 1-palindromes are substring «a», «b», «b», «a», «bb», «abba», the substring «bb» is 2-palindrome. There are no 3- and 4-palindromes here. | ```python
def main():
s = input()
n = len(s)
isPalindrome = [[False for i in range(n + 1)] for i in range(n + 1)]
for i in range(n):
isPalindrome[i][i] = True
for i in range(n - 1, -1, -1):
for j in range(i + 1, n):
if (s[i] == s[j] and (i + 1 == j or isPalindrome[i + 1][j - 1] == True)):
isPalindrome[i][j] = True
degreePalindrome = [[0 for i in range(n)] for i in range(n)]
#degreePalindrome[i][j] = degreePalindrome[i][mid] + 1
res = [0] * (n + 1)
for i in range(n):
for j in range(i, n):
if (i == j):
degreePalindrome[i][j] = 1
elif isPalindrome[i][j]:
mid = (i + j - 1) // 2
degreePalindrome[i][j] = degreePalindrome[i][mid] + 1
res[degreePalindrome[i][j]] += 1
for i in range( n - 2, 0, -1):
res[i] += res[i + 1]
print(*res[1::])
if __name__ == "__main__":
main()
``` |
926_B. Add Points | There are n points on a straight line, and the i-th point among them is located at xi. All these coordinates are distinct.
Determine the number m — the smallest number of points you should add on the line to make the distances between all neighboring points equal.
Input
The first line contains a single integer n (3 ≤ n ≤ 100 000) — the number of points.
The second line contains a sequence of integers x1, x2, ..., xn ( - 109 ≤ xi ≤ 109) — the coordinates of the points. All these coordinates are distinct. The points can be given in an arbitrary order.
Output
Print a single integer m — the smallest number of points you should add on the line to make the distances between all neighboring points equal.
Examples
Input
3
-5 10 5
Output
1
Input
6
100 200 400 300 600 500
Output
0
Input
4
10 9 0 -1
Output
8
Note
In the first example you can add one point with coordinate 0.
In the second example the distances between all neighboring points are already equal, so you shouldn't add anything. | ```python
import math
n = int(input())
a = list(map(int, input().split()))
a.sort()
g = 0
for i in range(n - 1):
g = math.gcd(g, a[i + 1] - a[i])
print((a[-1] - a[0]) // g - n + 1)
``` |
981_B. Businessmen Problems | Two famous competing companies ChemForces and TopChemist decided to show their sets of recently discovered chemical elements on an exhibition. However they know that no element should be present in the sets of both companies.
In order to avoid this representatives of both companies decided to make an agreement on the sets the companies should present. The sets should be chosen in the way that maximizes the total income of the companies.
All elements are enumerated with integers. The ChemForces company has discovered n distinct chemical elements with indices a_1, a_2, …, a_n, and will get an income of x_i Berland rubles if the i-th element from this list is in the set of this company.
The TopChemist company discovered m distinct chemical elements with indices b_1, b_2, …, b_m, and it will get an income of y_j Berland rubles for including the j-th element from this list to its set.
In other words, the first company can present any subset of elements from \\{a_1, a_2, …, a_n\} (possibly empty subset), the second company can present any subset of elements from \\{b_1, b_2, …, b_m\} (possibly empty subset). There shouldn't be equal elements in the subsets.
Help the representatives select the sets in such a way that no element is presented in both sets and the total income is the maximum possible.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of elements discovered by ChemForces.
The i-th of the next n lines contains two integers a_i and x_i (1 ≤ a_i ≤ 10^9, 1 ≤ x_i ≤ 10^9) — the index of the i-th element and the income of its usage on the exhibition. It is guaranteed that all a_i are distinct.
The next line contains a single integer m (1 ≤ m ≤ 10^5) — the number of chemicals invented by TopChemist.
The j-th of the next m lines contains two integers b_j and y_j, (1 ≤ b_j ≤ 10^9, 1 ≤ y_j ≤ 10^9) — the index of the j-th element and the income of its usage on the exhibition. It is guaranteed that all b_j are distinct.
Output
Print the maximum total income you can obtain by choosing the sets for both companies in such a way that no element is presented in both sets.
Examples
Input
3
1 2
7 2
3 10
4
1 4
2 4
3 4
4 4
Output
24
Input
1
1000000000 239
3
14 15
92 65
35 89
Output
408
Note
In the first example ChemForces can choose the set (3, 7), while TopChemist can choose (1, 2, 4). This way the total income is (10 + 2) + (4 + 4 + 4) = 24.
In the second example ChemForces can choose the only element 10^9, while TopChemist can choose (14, 92, 35). This way the total income is (239) + (15 + 65 + 89) = 408. | ```python
drugs_a = {}
drugs_b = {}
for _ in range(int(input())):
n,p = map(int,input().split())
drugs_a[n] = p
for _ in range(int(input())):
n,p = map(int,input().split())
drugs_b[n] = p
try:
if drugs_b[n] > drugs_a[n]:
del drugs_a[n]
else:
del drugs_b[n]
except KeyError:
pass
ans = 0
for i in drugs_a.values():
ans += i
for i in drugs_b.values():
ans += i
if len(drugs_b) == len(drugs_a):
temp = min(min(list(drugs_a.values())),min(list(drugs_b.values())))
print(ans)
``` |
p02551 AtCoder Beginner Contest 179 - Simplified Reversi | There is a grid with N rows and N columns of squares. Let (i, j) be the square at the i-th row from the top and the j-th column from the left.
Each of the central (N-2) \times (N-2) squares in the grid has a black stone on it. Each of the 2N - 1 squares on the bottom side and the right side has a white stone on it.
Q queries are given. We ask you to process them in order. There are two kinds of queries. Their input format and description are as follows:
* `1 x`: Place a white stone on (1, x). After that, for each black stone between (1, x) and the first white stone you hit if you go down from (1, x), replace it with a white stone.
* `2 x`: Place a white stone on (x, 1). After that, for each black stone between (x, 1) and the first white stone you hit if you go right from (x, 1), replace it with a white stone.
How many black stones are there on the grid after processing all Q queries?
Constraints
* 3 \leq N \leq 2\times 10^5
* 0 \leq Q \leq \min(2N-4,2\times 10^5)
* 2 \leq x \leq N-1
* Queries are pairwise distinct.
Input
Input is given from Standard Input in the following format:
N Q
Query_1
\vdots
Query_Q
Output
Print how many black stones there are on the grid after processing all Q queries.
Examples
Input
5 5
1 3
2 3
1 4
2 2
1 2
Output
1
Input
200000 0
Output
39999200004
Input
176527 15
1 81279
2 22308
2 133061
1 80744
2 44603
1 170938
2 139754
2 15220
1 172794
1 159290
2 156968
1 56426
2 77429
1 97459
2 71282
Output
31159505795 | ```python
class SegTree():
def __init__(self, initial, operation, identity):
n = len(initial)
self.initial = initial
self.operation = operation
self.identity = identity
self.num = 1 << (len(bin(n - 1)) - 2)
self.tree = [identity] * (2 * self.num - 1)
for i in range(n):
self.tree[i + self.num - 1] = self.initial[i]
for i in reversed(range(self.num - 1)):
self.tree[i] = min(self.tree[2*i + 1], self.tree[2*i + 2])
def update(self, k, x):
k += self.num - 1
self.tree[k] = x
while k >= 1:
k = (k - 1) // 2
self.tree[k] = self.operation(self.tree[2*k + 1], self.tree[2*k + 2])
def query(self, l, r):
res = self.identity
l += self.num - 1
r += self.num - 1
while l < r:
if l % 2 == 0:
res = self.operation(res, self.tree[l])
l += 1
if r % 2 == 0:
res = self.operation(res, self.tree[r - 1])
l = (l - 1) // 2
r = (r - 1) // 2
return res
N, Q = [int(i) for i in input().split()]
H, W = SegTree([N]*N, min, N), SegTree([N]*N, min, N)
revd = 0
for _ in range(Q):
t, x = [int(i) for i in input().split()]
if t == 1:
h = H.query(x, N + 1)
w = W.query(h, N + 1)
revd += h - 2
W.update(h, min(x, w))
else:
w = W.query(x, N + 1)
h = H.query(w, N + 1)
revd += w - 2
H.update(w, min(x, h))
ans = (N - 2)*(N - 2) - revd
print(ans)
``` |
p02682 AtCoder Beginner Contest 167 - Easy Linear Programming | We have A cards, each of which has an integer 1 written on it. Similarly, we also have B cards with 0s and C cards with -1s.
We will pick up K among these cards. What is the maximum possible sum of the numbers written on the cards chosen?
Constraints
* All values in input are integers.
* 0 \leq A, B, C
* 1 \leq K \leq A + B + C \leq 2 \times 10^9
Input
Input is given from Standard Input in the following format:
A B C K
Output
Print the maximum possible sum of the numbers written on the cards chosen.
Examples
Input
2 1 1 3
Output
2
Input
1 2 3 4
Output
0
Input
2000000000 0 0 2000000000
Output
2000000000 | ```python
A, B, C, K = map(int, input().split())
hoge = max(K - A - B, 0)
print(min(A, K) - hoge)
``` |
p02810 Dwango Programming Contest 6th - Span Covering | Niwango bought a piece of land that can be represented as a half-open interval [0, X).
Niwango will lay out N vinyl sheets on this land. The sheets are numbered 1,2, \ldots, N, and they are distinguishable. For Sheet i, he can choose an integer j such that 0 \leq j \leq X - L_i and cover [j, j + L_i) with this sheet.
Find the number of ways to cover the land with the sheets such that no point in [0, X) remains uncovered, modulo (10^9+7). We consider two ways to cover the land different if and only if there is an integer i (1 \leq i \leq N) such that the region covered by Sheet i is different.
Constraints
* 1 \leq N \leq 100
* 1 \leq L_i \leq X \leq 500
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N X
L_1 L_2 \ldots L_N
Output
Print the answer.
Examples
Input
3 3
1 1 2
Output
10
Input
18 477
324 31 27 227 9 21 41 29 50 34 2 362 92 11 13 17 183 119
Output
134796357 | ```python
N,X=map(int,input().split())
L=sorted(map(int,input().split()),reverse=True)
mod=10**9+7
D=[[0]*(X+1) for i in range(N//2+2)]
D[1][L[0]]=1
for l in L[1:]:
ND=[[0]*(X+1) for i in range(N//2+1)]
for c in range(1,N//2+1):
for s in range(X+1):
if D[c][s]==0:
continue
k=D[c][s]
if s+l+c<=X and c+1<=N//2:
ND[c+1][s+l]=(ND[c+1][s+l]+k*(c+1))%mod
ND[c][s]=(ND[c][s]+k*(s-c*(l-1)))%mod
for i in range(1,min(X-s-c+2,l+1)):
ND[c][s+i]=(ND[c][s+i]+k*2*c)%mod
if c==1:
continue
for i in range(1,min(X-s-c+3,l+1)):
ND[c-1][s+i]=(ND[c-1][s+i]+k*(c-1)*(l-i+1))%mod
D=ND
print(D[1][X])
``` |
p02947 AtCoder Beginner Contest 137 - Green Bin | We will call a string obtained by arranging the characters contained in a string a in some order, an anagram of a.
For example, `greenbin` is an anagram of `beginner`. As seen here, when the same character occurs multiple times, that character must be used that number of times.
Given are N strings s_1, s_2, \ldots, s_N. Each of these strings has a length of 10 and consists of lowercase English characters. Additionally, all of these strings are distinct. Find the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i is an anagram of s_j.
Constraints
* 2 \leq N \leq 10^5
* s_i is a string of length 10.
* Each character in s_i is a lowercase English letter.
* s_1, s_2, \ldots, s_N are all distinct.
Input
Input is given from Standard Input in the following format:
N
s_1
s_2
:
s_N
Output
Print the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i is an anagram of s_j.
Examples
Input
3
acornistnt
peanutbomb
constraint
Output
1
Input
2
oneplustwo
ninemodsix
Output
0
Input
5
abaaaaaaaa
oneplustwo
aaaaaaaaba
twoplusone
aaaabaaaaa
Output
4 | ```python
N = int(input())
from collections import Counter
S = [''.join(sorted(input())) for _ in range(N)]
ans = 0
for i in Counter(S).values():
ans += i*(i-1)//2
print(ans)
``` |
p03083 ExaWizards 2019 - Black or White | Today, Snuke will eat B pieces of black chocolate and W pieces of white chocolate for an afternoon snack.
He will repeat the following procedure until there is no piece left:
* Choose black or white with equal probability, and eat a piece of that color if it exists.
For each integer i from 1 to B+W (inclusive), find the probability that the color of the i-th piece to be eaten is black. It can be shown that these probabilities are rational, and we ask you to print them modulo 10^9 + 7, as described in Notes.
Constraints
* All values in input are integers.
* 1 \leq B,W \leq 10^{5}
Input
Input is given from Standard Input in the following format:
B W
Output
Print the answers in B+W lines. In the i-th line, print the probability that the color of the i-th piece to be eaten is black, modulo 10^{9}+7.
Examples
Input
2 1
Output
500000004
750000006
750000006
Input
3 2
Output
500000004
500000004
625000005
187500002
187500002
Input
6 9
Output
500000004
500000004
500000004
500000004
500000004
500000004
929687507
218750002
224609377
303710940
633300786
694091802
172485353
411682132
411682132 | ```python
MOD = 10**9+7
MAX = 2*(10**5)+1
fac = [1 for i in range(MAX)]
finv = [1 for i in range(MAX)]
inv = [1 for i in range(MAX)]
b,w = map(int,input().split())
if (b >= w):
flag = 0
else:
flag = 1
b,w = w,b
for i in range(2,MAX):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD // i)%MOD
finv[i]=finv[i-1]*inv[i]%MOD
def com(n,k):
if(n < k): return 0
return fac[n]*(finv[k]*finv[n-k]%MOD)%MOD
def pow(n,k,m):#n^k mod m
ans = 1
while k>0:
if(k & 1):ans = (ans*n) % m
n = (n*n)%m
k >>= 1
return ans
for i in range(w):
print(inv[2])
p1 = 1
p2 = 0
for i in range(1,w+1):
p2 = (p2+ com(w,i)) % MOD
deno = pow(inv[2],w,MOD)
denodeno = pow(2,w,MOD)
for i in range(b-w):
p1 = (p1*2)%MOD
deno = (deno* inv[2]) % MOD
denodeno = (denodeno*2) % MOD
if(flag == 0):print(((p1+p2)*deno)%MOD)
else : print(((denodeno-p1-p2)*deno)%MOD)
p2 = (p2*2-com(w+i,i+1)) % MOD
p1 = (p1+com(w+i,i+1)) % MOD
p2 -= 1
for i in range(b+1,b+w+1):
p1 *= 2
deno = (deno* inv[2]) % MOD
denodeno = (denodeno*2) % MOD
if(flag == 0):print(((p1+p2)*deno)%MOD)
else : print(((denodeno-p1-p2)*deno)%MOD)
p1 = (p1+com(i-1,w-1)) % MOD
p2 = (p2*2-com(i-1,w-1)-com(i-1,i-b)) % MOD
``` |
p03228 Tenka1 Programmer Beginner Contest - Exchange | In the beginning, Takahashi has A cookies, and Aoki has B cookies. They will perform the following operation alternately, starting from Takahashi:
* If the number of cookies in his hand is odd, eat one of those cookies; if the number is even, do nothing. Then, give one-half of the cookies in his hand to the other person.
Find the numbers of cookies Takahashi and Aoki respectively have after performing K operations in total.
Constraints
* 1 \leq A,B \leq 10^9
* 1 \leq K \leq 100
* A,B and K are integers.
Input
Input is given from Standard Input in the following format:
A B K
Output
Print the number of cookies Takahashi has, and the number of cookies Aoki has, in this order, after performing K operations in total.
Examples
Input
5 4 2
Output
5 3
Input
3 3 3
Output
1 3
Input
314159265 358979323 84
Output
448759046 224379523 | ```python
A, B, K = map(int,input().split())
for i in range(K):
if i % 2 == 0:
A -= (A % 2 == 1)
A, B = A//2, B+A//2
else:
B -= (B % 2 == 1)
A, B = A + B//2, B//2
print(A, B)
``` |
p03376 AtCoder Regular Contest 096 - Sweet Alchemy | Akaki, a patissier, can make N kinds of doughnut using only a certain powder called "Okashi no Moto" (literally "material of pastry", simply called Moto below) as ingredient. These doughnuts are called Doughnut 1, Doughnut 2, ..., Doughnut N. In order to make one Doughnut i (1 ≤ i ≤ N), she needs to consume m_i grams of Moto. She cannot make a non-integer number of doughnuts, such as 0.5 doughnuts.
The recipes of these doughnuts are developed by repeated modifications from the recipe of Doughnut 1. Specifically, the recipe of Doughnut i (2 ≤ i ≤ N) is a direct modification of the recipe of Doughnut p_i (1 ≤ p_i < i).
Now, she has X grams of Moto. She decides to make as many doughnuts as possible for a party tonight. However, since the tastes of the guests differ, she will obey the following condition:
* Let c_i be the number of Doughnut i (1 ≤ i ≤ N) that she makes. For each integer i such that 2 ≤ i ≤ N, c_{p_i} ≤ c_i ≤ c_{p_i} + D must hold. Here, D is a predetermined value.
At most how many doughnuts can be made here? She does not necessarily need to consume all of her Moto.
Constraints
* 2 ≤ N ≤ 50
* 1 ≤ X ≤ 10^9
* 0 ≤ D ≤ 10^9
* 1 ≤ m_i ≤ 10^9 (1 ≤ i ≤ N)
* 1 ≤ p_i < i (2 ≤ i ≤ N)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N X D
m_1
m_2 p_2
:
m_N p_N
Output
Print the maximum number of doughnuts that can be made under the condition.
Examples
Input
3 100 1
15
10 1
20 1
Output
7
Input
3 100 10
15
10 1
20 1
Output
10
Input
5 1000000000 1000000
123
159 1
111 1
135 3
147 3
Output
7496296 | ```python
N, X, D = map(int, input().split())
M = [0]*N
M[0] = int(input())
P = [0]*N
for i in range(N-1):
M[i+1], P[i+1] = map(int, input().split())
C = [1]*N
for i in range(N-1, 0, -1):
p = P[i]-1
C[p] += C[i]
M[p] += M[i]
L = [D]*N
L[0] = X
from collections import deque
def solve(N, W, ws, vs, ms):
V0 = max(vs)
V = sum(v * min(V0, m) for v, m in zip(vs, ms))
dp = [W+1]*(V + 1)
dp[0] = 0
for i in range(N):
v = vs[i]; w = ws[i]; m = ms[i]
c = min(V0, m)
ms[i] -= c
for k in range(v):
que = deque()
push = que.append
popf = que.popleft; popb = que.pop
for j in range((V-k)//v+1):
a = dp[k + j*v] - j * w
while que and a <= que[-1][1]:
popb()
push((j, a))
p, b = que[0]
dp[k + j*v] = b + j * w
if que and p <= j-c:
popf()
*I, = range(N)
I.sort(key=lambda x: ws[x]/vs[x])
*S, = [(vs[i], ws[i], ms[i]) for i in I]
def greedy():
yield 0
for i in range(V + 1):
if dp[i] > W:
continue
rest = W - dp[i]
r = i
for v, w, m in S:
m = min(m, rest // w)
r += m * v
rest -= m * w
yield r
return max(greedy())
print(solve(N, X, M, C, L))
``` |
p03543 AtCoder Beginner Contest 079 - Good Integer | We call a 4-digit integer with three or more consecutive same digits, such as 1118, good.
You are given a 4-digit integer N. Answer the question: Is N good?
Constraints
* 1000 ≤ N ≤ 9999
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
If N is good, print `Yes`; otherwise, print `No`.
Examples
Input
1118
Output
Yes
Input
7777
Output
Yes
Input
1234
Output
No | ```python
n = int(input())
n1 = n//10
n2 = n%1000
print('No' if n1%111 and n2%111 else 'Yes')
``` |
p03697 AtCoder Beginner Contest 063 - Restricted | You are given two integers A and B as the input. Output the value of A + B.
However, if A + B is 10 or greater, output `error` instead.
Constraints
* A and B are integers.
* 1 ≤ A, B ≤ 9
Input
Input is given from Standard Input in the following format:
A B
Output
If A + B is 10 or greater, print the string `error` (case-sensitive); otherwise, print the value of A + B.
Examples
Input
6 3
Output
9
Input
6 4
Output
error | ```python
a,s=map(int,input().split())
if a+s>=10:
print("error")
else:
print(a+s)
``` |
p03852 AtCoder Beginner Contest 049 - UOIAUAI | Given a lowercase English letter c, determine whether it is a vowel. Here, there are five vowels in the English alphabet: `a`, `e`, `i`, `o` and `u`.
Constraints
* c is a lowercase English letter.
Input
The input is given from Standard Input in the following format:
c
Output
If c is a vowel, print `vowel`. Otherwise, print `consonant`.
Examples
Input
a
Output
vowel
Input
z
Output
consonant
Input
s
Output
consonant | ```python
print(["consonant","vowel"][input() in "aiueo"])
``` |
p04019 AtCoder Grand Contest 003 - Wanna go back home | Snuke lives on an infinite two-dimensional plane. He is going on an N-day trip. At the beginning of Day 1, he is at home. His plan is described in a string S of length N. On Day i(1 ≦ i ≦ N), he will travel a positive distance in the following direction:
* North if the i-th letter of S is `N`
* West if the i-th letter of S is `W`
* South if the i-th letter of S is `S`
* East if the i-th letter of S is `E`
He has not decided each day's travel distance. Determine whether it is possible to set each day's travel distance so that he will be back at home at the end of Day N.
Constraints
* 1 ≦ | S | ≦ 1000
* S consists of the letters `N`, `W`, `S`, `E`.
Input
The input is given from Standard Input in the following format:
S
Output
Print `Yes` if it is possible to set each day's travel distance so that he will be back at home at the end of Day N. Otherwise, print `No`.
Examples
Input
SENW
Output
Yes
Input
NSNNSNSN
Output
Yes
Input
NNEW
Output
No
Input
W
Output
No | ```python
s=set(input());print("YNeos"[1 in[(len(s&set(t)))for t in["NS","WE"]]::2])
``` |
p00103 Baseball Simulation | Ichiro likes baseball and has decided to write a program which simulates baseball.
The program reads events in an inning and prints score in that inning. There are only three events as follows:
Single hit
* put a runner on the first base.
* the runner in the first base advances to the second base and the runner in the second base advances to the third base.
* the runner in the third base advances to the home base (and go out of base) and a point is added to the score.
Home run
* all the runners on base advance to the home base.
* points are added to the score by an amount equal to the number of the runners plus one.
Out
* The number of outs is increased by 1.
* The runners and the score remain stationary.
* The inning ends with three-out.
Ichiro decided to represent these events using "HIT", "HOMERUN" and "OUT", respectively.
Write a program which reads events in an inning and prints score in that inning. You can assume that the number of events is less than or equal to 100.
Input
The input consists of several datasets. In the first line, the number of datasets n is given. Each dataset consists of a list of events (strings) in an inning.
Output
For each dataset, prints the score in the corresponding inning.
Example
Input
2
HIT
OUT
HOMERUN
HIT
HIT
HOMERUN
HIT
OUT
HIT
HIT
HIT
HIT
OUT
HIT
HIT
OUT
HIT
OUT
OUT
Output
7
0 | ```python
n = int(input())
for i in range(n):
out_cnt = 0
score = 0
runner = [0,0,0,0]
while True:
event = input()
if event=="OUT":
out_cnt += 1
if out_cnt == 3:
break
elif event=="HIT":
if 1 in runner:
for ind in range(len(runner)-1,-1,-1):
if runner[ind] == 1:
if ind != 3:
runner[ind] = 0
runner[ind+1] = 1
if not 1 in runner[:ind]:
break
if runner[-1]==1:
runner[-1] = 0
score += 1
runner[0] = 1
else:
runner[0] = 1
elif event=="HOMERUN":
score += sum(runner)+1
runner = [0,0,0,0]
print(score)
``` |
p00613 A Piece of Cake | In the city, there are two pastry shops. One shop was very popular because its cakes are pretty tasty. However, there was a man who is displeased at the shop. He was an owner of another shop. Although cause of his shop's unpopularity is incredibly awful taste of its cakes, he never improved it. He was just growing hate, ill, envy, and jealousy.
Finally, he decided to vandalize the rival.
His vandalize is to mess up sales record of cakes. The rival shop sells K kinds of cakes and sales quantity is recorded for each kind. He calculates sum of sales quantities for all pairs of cakes. Getting K(K-1)/2 numbers, then he rearranges them randomly, and replace an original sales record with them.
An owner of the rival shop is bothered. Could you write, at least, a program that finds total sales quantity of all cakes for the pitiful owner?
Constraints
* Judge data contains at most 100 data sets.
* 2 ≤ K ≤ 100
* 0 ≤ ci ≤ 100
Input
Input file contains several data sets. A single data set has following format:
K
c1 c2 ... cK×(K-1)/2
K is an integer that denotes how many kinds of cakes are sold. ci is an integer that denotes a number written on the card.
The end of input is denoted by a case where K = 0. You should output nothing for this case.
Output
For each data set, output the total sales quantity in one line.
Example
Input
2
2
3
5 4 3
0
Output
2
6 | ```python
while True:
K = int(input())
if K == 0:
break
c = [int(i) for i in input().split()]
S = 0
for i in range(len(c)):
S = S + c[i]
print(int(S/(K-1)))
``` |
p00889 Find the Multiples | You are given a sequence a0a1...aN-1 digits and a prime number Q. For each i ≤ j with ai ≠ 0, the subsequence aiai+1...aj can be read as a decimal representation of a positive integer. Subsequences with leading zeros are not considered. Your task is to count the number of pairs (i, j) such that the corresponding subsequence is a multiple of Q.
Input
The input consists of at most 50 datasets. Each dataset is represented by a line containing four integers N, S, W, and Q, separated by spaces, where 1 ≤ N ≤ 105, 1 ≤ S ≤ 109, 1 ≤ W ≤ 109, and Q is a prime number less than 108. The sequence a0...aN-1 of length N is generated by the following code, in which ai is written as a[i].
int g = S;
for(int i=0; i<N; i++) {
a[i] = (g/7) % 10;
if( g%2 == 0 ) { g = (g/2); }
else { g = (g/2) ^ W; }
}
Note: the operators /, %, and ^ are the integer division, the modulo, and the bitwise exclusiveor, respectively. The above code is meant to be a random number generator. The intended solution does not rely on the way how the sequence is generated.
The end of the input is indicated by a line containing four zeros separated by spaces.
Output
For each dataset, output the answer in a line. You may assume that the answer is less than 230.
Example
Input
3 32 64 7
4 35 89 5
5 555 442 3
5 777 465 11
100000 666 701622763 65537
0 0 0 0
Output
2
4
6
3
68530 | ```python
from collections import defaultdict
def gen(N, S, W):
g = S
for i in range(N):
yield (g//7) % 10
if g % 2 == 0:
g //= 2
else:
g = (g//2) ^ W
def solve():
N, S, W, Q = map(int, input().split())
if N == 0:
return False
bs = list(gen(N, S, W))
ans = 0
if Q == 2 or Q == 5:
cnt = 0
for i in range(N):
b = bs[i]
if b != 0:
cnt += 1
if b % Q == 0:
ans += cnt
else:
rev10 = pow(10, Q-2, Q)
D = defaultdict(int)
D[0] = 1
s = 0; v = 1
first = 1
for i in range(N):
b = bs[i]
if first and b == 0:
continue
s = (s + v * b) % Q
v = v * rev10 % Q
ans += D[s]
if i < N-1 and bs[i+1] != 0:
D[s] += 1
first = 0
print(ans)
return True
while solve():
...
``` |
p01461 Multi Ending Story | You are a programmer who loves bishojo games (a sub-genre of dating simulation games). A game, which is titled "I * C * P * C!" and was released yesterday, has arrived to you just now. This game has multiple endings. When you complete all of those endings, you can get a special figure of the main heroine, Sakuya. So, you want to hurry and play the game! But, let's calm down a bit and think how to complete all of the endings in the shortest time first.
In fact, you have a special skill that allows you to know the structure of branching points of games. By using the skill, you have found out that all of the branching points in this game are to select two choices "Yes" or "No", and once a different choice is taken the branched stories flow to different endings; they won't converge any more, like a binary tree. You also noticed that it takes exactly one minute to proceed the game from a branching point to another branching point or to an ending. In addition, you can assume it only takes negligible time to return to the beginning of the game (``reset'') and to play from the beginning to the first branching point.
The game has an additional feature called "Quick Save", which can significantly reduce the playing time for completion. The feature allows you to record the point where you are currently playing and return there at any time later. You can record any number of times, but you can hold only the last recorded point. That is, when you use Quick Save, you overwrite the previous record. If you want to return to the overwritten point, you must play the game from the beginning once again.
Well, let's estimate how long it will take for completing all of the endings in the shortest time.
Input
A data set is given in the following format.
The first line of the data set contains one integer N (2 \leq N \leq 500{,}000), which denotes the number of the endings in this game. The following N-1 lines describe the branching points. The i-th line describes the branching point of ID number i and contains two integers Yes_i and No_i (i + 1 \leq Yes_i, No_i \leq N), which denote the ID numbers of the next branching points when you select Yes or No respectively. Yes_i = N means that you can reach an ending if you select Yes, and so for No_i = N. The branching point with ID 1 is the first branching point. The branching points with ID between 2 and N-1 (inclusive) appear exactly once in Yes_i's and No_i's.
Output
Print the shortest time in a line.
Examples
Input
4
2 3
4 4
4 4
Output
6
Input
5
5 2
3 5
5 4
5 5
Output
8 | ```python
from collections import deque
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
N = int(readline())
A = [0]*N
B = [0]*N
for i in range(N-1):
a, b = map(int, readline().split())
if not a <= b:
a, b = b, a
A[i] = a-1
B[i] = b-1
que = deque([0])
vs = []
dist = [0]*N
while que:
v = que.popleft()
vs.append(v)
d = dist[v]
if A[v] != N-1:
w = A[v]
que.append(w)
dist[w] = d+1
if B[v] != N-1:
w = B[v]
que.append(w)
dist[w] = d+1
sz = [0]*N
dp = [[0, 0] for i in range(N)]
vs.reverse()
for v in vs:
a = A[v]; b = B[v]
if a == N-1:
dp[v][0] = 2
dp[v][1] = dist[v] + 2
sz[v] = 2
elif b == N-1:
dp[v][0] = dp[a][0] + sz[a] + 1
dp[v][1] = dp[a][1] + 1
sz[v] = sz[a] + 1
else:
dp[v][0] = dp[a][0] + dp[b][0] + sz[a] + sz[b]
dp[v][1] = min(dp[a][0] + dp[b][1] + sz[a], dp[a][1] + dp[b][0] + sz[b], dp[a][1] + dp[b][1])
sz[v] = sz[a] + sz[b]
write("%d\n" % dp[0][1])
solve()
``` |
p01620 King's Inspection | A great king of a certain country suddenly decided to visit the land of a friendly country. The country is famous for trains, and the king visits various stations.
There are 52 train stations, each with a single uppercase or lowercase alphabetic name (no overlapping names). The line of this train is circular, with station a next to station b, station b next to station c, then station z next to station A, then station B, and so on. Proceed in order, and after Z station, it becomes a station and returns to the original. It is a single track, and there are no trains running in the opposite direction.
One day, a newspaper reporter got a list of the stations the King would visit.
"DcdkIlkP ..."
It is said that they will visit d station first, then c station, then d station, and so on. With this, when I thought that I could follow up on the king of a great country, I discovered something unexpected. The list was encrypted for counter-terrorism! A fellow reporter reportedly obtained the key to break the code. The reporter immediately gave him the key and started to modify the list. The key consists of a sequence of numbers.
"3 1 4 5 3"
This number means that the first station you visit is the one three stations before the one on the list. The station you visit second is the station in front of the second station on the list, which indicates how many stations you actually visit are in front of the stations on the list. The reporter started to fix it, but when I asked my friends what to do because the number of keys was smaller than the number of stations to visit, if you use the last key, use the first key again. It seems to be good. And the reporter was finally able to revise the list.
"AbZfFijL ..."
With this, there would be nothing scary anymore, and as soon as I thought so, an unexpected situation was discovered. The Great King stayed for days, and there was a list and keys for each date. The reporter was instructed by his boss to decrypt the entire list, but the amount was not enough for him alone. Your job is to help him and create a program that will automatically decrypt this list.
Input
The input consists of multiple datasets. The format of each data set is as follows.
n
k1 k2 ... kn
s
n is an integer representing the number of keys and can be assumed to be between 1 and 100. The following line contains a list of keys. ki indicates the i-th key. It can be assumed that it is 1 or more and 52 or less. s is a character string consisting of uppercase and lowercase letters, and indicates a list of stations to visit. It may be assumed that it is 1 or more and 100 or less. n = 0 indicates the end of input. This is not included in the dataset.
Output
Print the decrypted list for each dataset on one line each.
Sample Input
2
1 2
bdd
3
3 2 1
DDDA
Five
3 1 4 5 3
dcdkIlkP
0
Output for Sample Input
abc
ABCx
abZfFijL
Example
Input
2
1 2
bdd
3
3 2 1
DDDA
5
3 1 4 5 3
dcdkIlkP
0
Output
abc
ABCx
abZfFijL | ```python
def horizontal_input(T=str):
return list(map(T,input().split()))
def vertical_input(n,T=str,sep=False,septype=tuple):
data=[]
if sep:
for i in range(n):
data.append(septype(map(T,input().split())))
else:
for i in range(n):
data.append(T(input()))
return data
d='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
while 1:
n=int(input())
if n==0:
break
data=horizontal_input(int)
s=input()
ans=[]
i=0
for c in s:
ans.append(d[d.find(c)-data[i]])
i=(i+1)%len(data)
print(''.join(ans))
``` |
p01907 Fractal Tree | problem
AOR Ika likes rooted trees with a fractal (self-similar) structure. Consider using the weighted rooted tree $ T $ consisting of $ N $ vertices to represent the rooted tree $ T'$ with the following fractal structure.
* $ T'$ is the addition of a tree rooted at $ x $ and having a tree structure similar to $ T $ (same cost) for each vertex $ x $ of $ T $.
* The root of $ T'$ is the same as that of $ T $.
The tree represented in this way is, for example, as shown in the figure below.
<image>
AOR Ika is trying to do a depth-first search for $ T'$, but finds that it takes a lot of time to trace all the vertices. Therefore, we decided to skip some node visits by performing a depth-first search with a policy of transitioning with a probability of $ p $ and not transitioning with a probability of $ 1-p $ at the time of transition during a depth-first search. Given $ T $ and the probability $ p $, find the expected value of the sum of the costs of all edges to follow when performing a depth-first search for $ T'$. The information of $ T $ is given by the number of vertices $ N $ and the information of the edges of $ N-1 $, and the vertex $ 1 $ is the root. Each vertex is labeled $ 1,2, \ dots, N $, and the $ i \ (1 \ le i \ le N-1) $ th edge costs the vertices $ x_i $ and $ y_i $ $ c_i $ It is tied with. The non-deterministic algorithm of the depth-first search that transitions to a child with a probability of $ p $, which is dealt with in this problem, is expressed as follows. The sum of the costs of the edges that the output $ \ mathrm {answer} $ follows.
1. Prepare an empty stack $ S $.
2. Set $ \ mathrm {answer} = 0 $
3. Push the root vertex of $ T'$ to $ S $.
4. Extract the first element of $ S $ and make it $ x $.
5. For each child $ c $ of $ x $, do the following with probability $ p $ and do nothing with probability $ 1-p $.
* Add vertex $ c $ to $ S $. Then add the weight of the edge connecting $ x $ to $ c $ to $ \ mathrm {answer} $.
6. If S is not empty, transition to 3.
7. Output $ \ mathrm {answer} $.
output
Print the answer in one line. If the relative or absolute error is less than $ 10 ^ {-6} $, then AC. Also, output a line break at the end.
Example
Input
0.75
4
1 2 1
2 3 3
3 4 10
Output
24.8569335938 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LS(): return input().split()
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def main():
p = F()
n = I()
d = collections.defaultdict(list)
for _ in range(n-1):
x,y,c = LI()
d[x-1].append((y-1,c))
d[y-1].append((x-1,c))
f = [None] * n
f[0] = (0,0)
q = [(0,0)]
while q:
x,b = q[0]
q = q[1:]
for y,c in d[x]:
if f[y]:
continue
q.append((y,b+1))
f[y] = (b+1, c)
s = 0
for b,c in f:
s += p**b * c
r = s
for b,c in f:
r += p**b * s
return r
print(main())
``` |
p02330 Coin Combination Problem II | You have N coins each of which has a value ai. Find the number of combinations that result when you choose K different coins in such a way that the total value of the coins is greater than or equal to L and less than or equal to R.
Constraints
* 1 ≤ K ≤ N ≤ 40
* 1 ≤ ai ≤ 1016
* 1 ≤ L ≤ R ≤ 1016
* All input values are given in integers
Input
The input is given in the following format.
N K L R
a1 a2 ... aN
Output
Print the number of combinations in a line.
Examples
Input
2 2 1 9
5 1
Output
1
Input
5 2 7 19
3 5 4 2 2
Output
5 | ```python
from bisect import bisect_left, bisect_right
from itertools import combinations
if __name__ == "__main__":
N, K, L, R = map(lambda x: int(x), input().split())
coins = list(map(lambda x: int(x), input().split()))
N_half = N // 2
c1 = [list(map(sum, combinations(coins[:N_half], i))) for i in range(0, N_half + 1)]
c2 = [list(map(sum, combinations(coins[N_half:], i)))
for i in range(0, N - N_half + 1)]
for i in range(0, N - N_half + 1):
c2[i].sort()
ans = 0
for i in range(0, K + 1):
if K - i < 0 or K - i > N - N_half or i > N_half:
continue
for a in c1[i]:
low = bisect_left(c2[K - i], L - a) # type: ignore
high = bisect_right(c2[K - i], R - a) # type: ignore
ans += high - low
print(ans)
``` |
p02475 Division of Big Integers | Division of Big Integers
Given two integers $A$ and $B$, compute the quotient, $\frac{A}{B}$. Round down to the nearest decimal.
Input
Two integers $A$ and $B$ separated by a space character are given in a line.
Output
Print the quotient in a line.
Constraints
* $-1 \times 10^{1000} \leq A, B \leq 10^{1000}$
* $B \ne 0$
Sample Input 1
5 8
Sample Output 1
0
Sample Input 2
100 25
Sample Output 2
4
Sample Input 3
-1 3
Sample Output 3
0
Sample Input 4
12 -3
Sample Output 4
-4
Example
Input
5 8
Output
0 | ```python
a,b = map(int,input().split())
if(a*b<0):
print(abs(a)//abs(b)*-1)
else:
print(abs(a)//abs(b))
``` |
1040_B. Shashlik Cooking | Long story short, shashlik is Miroslav's favorite food. Shashlik is prepared on several skewers simultaneously. There are two states for each skewer: initial and turned over.
This time Miroslav laid out n skewers parallel to each other, and enumerated them with consecutive integers from 1 to n in order from left to right. For better cooking, he puts them quite close to each other, so when he turns skewer number i, it leads to turning k closest skewers from each side of the skewer i, that is, skewers number i - k, i - k + 1, ..., i - 1, i + 1, ..., i + k - 1, i + k (if they exist).
For example, let n = 6 and k = 1. When Miroslav turns skewer number 3, then skewers with numbers 2, 3, and 4 will come up turned over. If after that he turns skewer number 1, then skewers number 1, 3, and 4 will be turned over, while skewer number 2 will be in the initial position (because it is turned again).
As we said before, the art of cooking requires perfect timing, so Miroslav wants to turn over all n skewers with the minimal possible number of actions. For example, for the above example n = 6 and k = 1, two turnings are sufficient: he can turn over skewers number 2 and 5.
Help Miroslav turn over all n skewers.
Input
The first line contains two integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ 1000) — the number of skewers and the number of skewers from each side that are turned in one step.
Output
The first line should contain integer l — the minimum number of actions needed by Miroslav to turn over all n skewers. After than print l integers from 1 to n denoting the number of the skewer that is to be turned over at the corresponding step.
Examples
Input
7 2
Output
2
1 6
Input
5 1
Output
2
1 4
Note
In the first example the first operation turns over skewers 1, 2 and 3, the second operation turns over skewers 4, 5, 6 and 7.
In the second example it is also correct to turn over skewers 2 and 5, but turning skewers 2 and 4, or 1 and 5 are incorrect solutions because the skewer 3 is in the initial state after these operations. | ```python
n,k=map(int,input().split())
if n%(2*k+1)==0:
print(n//(2*k+1))
for i in range(k+1,n+1,2*k+1):
print(i,end=" ")
else:
if n%(2*k+1)>=k+1:
print(n//(2*k+1)+1)
for i in range(k+1,n+1,2*k+1):
print(i,end=" ")
else:
print(n//(2*k+1)+1)
for i in range(n%(2*k+1),n+1,2*k+1):
print(i,end=" ")
``` |
1063_B. Labyrinth | You are playing some computer game. One of its levels puts you in a maze consisting of n lines, each of which contains m cells. Each cell either is free or is occupied by an obstacle. The starting cell is in the row r and column c. In one step you can move one square up, left, down or right, if the target cell is not occupied by an obstacle. You can't move beyond the boundaries of the labyrinth.
Unfortunately, your keyboard is about to break, so you can move left no more than x times and move right no more than y times. There are no restrictions on the number of moves up and down since the keys used to move up and down are in perfect condition.
Now you would like to determine for each cell whether there exists a sequence of moves that will put you from the starting cell to this particular one. How many cells of the board have this property?
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 2000) — the number of rows and the number columns in the labyrinth respectively.
The second line contains two integers r, c (1 ≤ r ≤ n, 1 ≤ c ≤ m) — index of the row and index of the column that define the starting cell.
The third line contains two integers x, y (0 ≤ x, y ≤ 109) — the maximum allowed number of movements to the left and to the right respectively.
The next n lines describe the labyrinth. Each of them has length of m and consists only of symbols '.' and '*'. The j-th character of the i-th line corresponds to the cell of labyrinth at row i and column j. Symbol '.' denotes the free cell, while symbol '*' denotes the cell with an obstacle.
It is guaranteed, that the starting cell contains no obstacles.
Output
Print exactly one integer — the number of cells in the labyrinth, which are reachable from starting cell, including the starting cell itself.
Examples
Input
4 5
3 2
1 2
.....
.***.
...**
*....
Output
10
Input
4 4
2 2
0 1
....
..*.
....
....
Output
7
Note
Cells, reachable in the corresponding example, are marked with '+'.
First example:
+++..
+***.
+++**
*+++.
Second example:
.++.
.+*.
.++.
.++.
| ```python
from collections import deque
def move(tx, ty, s, left=False):
if 0 <= tx < n and 0 <= ty < m:
if smap[tx][ty] == '.' and mp[tx][ty] == -1:
mp[tx][ty] = s
if left:
q.appendleft((tx, ty))
else:
q.append((tx, ty))
[n, m] = map(int, input().split())
[sx, sy] = map(int, input().split())
[ll, rr] = map(int, input().split())
smap = [input() for i in range(n)]
q = deque()
mp = [[-1]*m for i in range(n)]
sx, sy = sx-1, sy-1
mp[sx][sy] = 0
ans = 0
q.append((sx, sy))
while q:
px, py = q.popleft()
s = mp[px][py]
ans += s + py - sy <= rr * 2 and s - py + sy <= ll * 2
move(px + 1, py, s, left=True)
move(px - 1, py, s, left=True)
move(px, py - 1, s + 1)
move(px, py + 1, s + 1)
print(ans)
``` |
1085_A. Right-Left Cipher | Polycarp loves ciphers. He has invented his own cipher called Right-Left.
Right-Left cipher is used for strings. To encrypt the string s=s_{1}s_{2} ... s_{n} Polycarp uses the following algorithm:
* he writes down s_1,
* he appends the current word with s_2 (i.e. writes down s_2 to the right of the current result),
* he prepends the current word with s_3 (i.e. writes down s_3 to the left of the current result),
* he appends the current word with s_4 (i.e. writes down s_4 to the right of the current result),
* he prepends the current word with s_5 (i.e. writes down s_5 to the left of the current result),
* and so on for each position until the end of s.
For example, if s="techno" the process is: "t" → "te" → "cte" → "cteh" → "ncteh" → "ncteho". So the encrypted s="techno" is "ncteho".
Given string t — the result of encryption of some string s. Your task is to decrypt it, i.e. find the string s.
Input
The only line of the input contains t — the result of encryption of some string s. It contains only lowercase Latin letters. The length of t is between 1 and 50, inclusive.
Output
Print such string s that after encryption it equals t.
Examples
Input
ncteho
Output
techno
Input
erfdcoeocs
Output
codeforces
Input
z
Output
z | ```python
s=str(input())
if len(s)<=2: print(s)
else:
first=(len(s)-1)//2
s1=(s[first-1::-1])
s2=list(s[first:])
#print(s1,s2)
k=2
for i in range(len(s1)):
s2.insert(k,s1[i])
k+=2
print(''.join(s2))
``` |
1104_D. Game with modulo | This is an interactive problem.
Vasya and Petya are going to play the following game: Petya has some positive integer number a. After that Vasya should guess this number using the following questions. He can say a pair of non-negative integer numbers (x, y). Petya will answer him:
* "x", if (x mod a) ≥ (y mod a).
* "y", if (x mod a) < (y mod a).
We define (x mod a) as a remainder of division x by a.
Vasya should guess the number a using no more, than 60 questions.
It's guaranteed that Petya has a number, that satisfies the inequality 1 ≤ a ≤ 10^9.
Help Vasya playing this game and write a program, that will guess the number a.
Interaction
Your program should play several games.
Before the start of any game your program should read the string:
* "start" (without quotes) — the start of the new game.
* "mistake" (without quotes) — in the previous game, you found the wrong answer. Your program should terminate after reading this string and it will get verdict "Wrong answer".
* "end" (without quotes) — all games finished. Your program should terminate after reading this string.
After reading the string "start" (without quotes) the new game starts.
At the beginning, your program should ask several questions about pairs of non-negative integer numbers (x, y). You can only ask the numbers, that satisfy the inequalities 0 ≤ x, y ≤ 2 ⋅ 10^9. To ask a question print "? x y" (without quotes). As the answer, you should read one symbol:
* "x" (without quotes), if (x mod a) ≥ (y mod a).
* "y" (without quotes), if (x mod a) < (y mod a).
* "e" (without quotes) — you asked more than 60 questions. Your program should terminate after reading this string and it will get verdict "Wrong answer".
After your program asked several questions your program should print the answer in form "! a" (without quotes). You should print the number a satisfying the inequalities 1 ≤ a ≤ 10^9. It's guaranteed that Petya's number a satisfied this condition. After that, the current game will finish.
We recall that your program can't ask more than 60 questions during one game.
If your program doesn't terminate after reading "mistake" (without quotes), "end" (without quotes) or "e" (without quotes), it can get any verdict, because it will continue reading from closed input. Also, if your program prints answer or question in the incorrect format it can get any verdict, too. Be careful.
Don't forget to flush the output after printing questions and answers.
To flush the output, you can use:
* fflush(stdout) in C++.
* System.out.flush() in Java.
* stdout.flush() in Python.
* flush(output) in Pascal.
* See the documentation for other languages.
It's guaranteed that you should play at least 1 and no more than 100 games.
Hacks:
In hacks, you can use only one game. To hack a solution with Petya's number a (1 ≤ a ≤ 10^9) in the first line you should write a single number 1 and in the second line you should write a single number a.
Example
Input
start
x
x
start
x
x
y
start
x
x
y
y
end
Output
? 0 0
? 10 1
! 1
? 0 0
? 3 4
? 2 5
! 2
? 2 4
? 2 5
? 3 10
? 9 1
! 3
Note
In the first test, you should play 3 games with Petya's numbers 1, 2 and 3.
In the first game, Petya will answer "x" (without quotes) to any question, because (x mod 1) = 0 for any integer x.
In the second game, if you will ask pair (0, 0), the answer will be "x" (without quotes), because (0 mod 2) ≥ (0 mod 2). But if you will ask pair (2, 5), the answer will be "y" (without quotes), because (2 mod 2) < (5 mod 2), because (2 mod 2) = 0 and (5 mod 2) = 1. | ```python
import sys
while True:
S = input()
if S=='end':
sys.exit()
if S=='mistake':
sys.exit()
if S=='start':
while True:
i=0
print('?',0,1)
sys.stdout.flush()
T=input()
if T=='x':
print('!',1)
break
while i<32:
print('?',2**i,2**(i+1))
sys.stdout.flush()
T=input()
if T=='x':
b=2**i
break
i+=1
mi=2**i
ma=2**(i+1)
#print('?',0,mi)
#sys.stdout.flush()
#T=input()
#if T=='x':
#print('!',mi)
#break
while ma-mi>1:
mid=(ma+mi)//2
print('?',mi,mid)
sys.stdout.flush()
T = input()
if T=='x':
ma=mid
elif T=='y':
mi=mid
elif T=='e':
sys.exit()
print('!',ma)
break
``` |
1132_B. Discounts | You came to a local shop and want to buy some chocolate bars. There are n bars in the shop, i-th of them costs a_i coins (and you want to buy all of them).
You have m different coupons that allow you to buy chocolate bars. i-th coupon allows you to buy q_i chocolate bars while you have to pay only for the q_i - 1 most expensive ones (so, the cheapest bar of those q_i bars is for free).
You can use only one coupon; if you use coupon i, you have to choose q_i bars and buy them using the coupon, and buy all the remaining n - q_i bars without any discounts.
To decide which coupon to choose, you want to know what will be the minimum total amount of money you have to pay if you use one of the coupons optimally.
Input
The first line contains one integer n (2 ≤ n ≤ 3 ⋅ 10^5) — the number of chocolate bars in the shop.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the cost of i-th chocolate bar.
The third line contains one integer m (1 ≤ m ≤ n - 1) — the number of coupons you have.
The fourth line contains m integers q_1, q_2, ..., q_m (2 ≤ q_i ≤ n), where q_i is the number of chocolate bars you have to buy using i-th coupon so that the least expensive of them will be for free. All values of q_i are pairwise distinct.
Output
Print m integers, i-th of them should be the minimum amount of money you have to pay if you buy q_i bars with i-th coupon, and all the remaining bars one by one for their full price.
Example
Input
7
7 1 3 1 4 10 8
2
3 4
Output
27
30
Note
Consider the first example.
If we use the first coupon, we may choose chocolate bars having indices 1, 6 and 7, and we pay 18 coins for them and 9 coins for all other bars.
If we use the second coupon, we may choose chocolate bars having indices 1, 5, 6 and 7, and we pay 25 coins for them and 5 coins for all other bars. | ```python
n = int(input())
ar = sorted(list(map(int, input().split())))
r = sum(ar)
m = int(input())
br = list(map(int, input().split()))
for i in br:
print(r - ar[-i])
``` |
1152_E. Neko and Flashback | A permutation of length k is a sequence of k integers from 1 to k containing each integer exactly once. For example, the sequence [3, 1, 2] is a permutation of length 3.
When Neko was five, he thought of an array a of n positive integers and a permutation p of length n - 1. Then, he performed the following:
* Constructed an array b of length n-1, where b_i = min(a_i, a_{i+1}).
* Constructed an array c of length n-1, where c_i = max(a_i, a_{i+1}).
* Constructed an array b' of length n-1, where b'_i = b_{p_i}.
* Constructed an array c' of length n-1, where c'_i = c_{p_i}.
For example, if the array a was [3, 4, 6, 5, 7] and permutation p was [2, 4, 1, 3], then Neko would have constructed the following arrays:
* b = [3, 4, 5, 5]
* c = [4, 6, 6, 7]
* b' = [4, 5, 3, 5]
* c' = [6, 7, 4, 6]
Then, he wrote two arrays b' and c' on a piece of paper and forgot about it. 14 years later, when he was cleaning up his room, he discovered this old piece of paper with two arrays b' and c' written on it. However he can't remember the array a and permutation p he used.
In case Neko made a mistake and there is no array a and permutation p resulting in such b' and c', print -1. Otherwise, help him recover any possible array a.
Input
The first line contains an integer n (2 ≤ n ≤ 10^5) — the number of elements in array a.
The second line contains n-1 integers b'_1, b'_2, …, b'_{n-1} (1 ≤ b'_i ≤ 10^9).
The third line contains n-1 integers c'_1, c'_2, …, c'_{n-1} (1 ≤ c'_i ≤ 10^9).
Output
If Neko made a mistake and there is no array a and a permutation p leading to the b' and c', print -1. Otherwise, print n positive integers a_i (1 ≤ a_i ≤ 10^9), denoting the elements of the array a.
If there are multiple possible solutions, print any of them.
Examples
Input
5
4 5 3 5
6 7 4 6
Output
3 4 6 5 7
Input
3
2 4
3 2
Output
-1
Input
8
2 3 1 1 2 4 3
3 4 4 2 5 5 4
Output
3 4 5 2 1 4 3 2
Note
The first example is explained is the problem statement.
In the third example, for a = [3, 4, 5, 2, 1, 4, 3, 2], a possible permutation p is [7, 1, 5, 4, 3, 2, 6]. In that case, Neko would have constructed the following arrays:
* b = [3, 4, 2, 1, 1, 3, 2]
* c = [4, 5, 5, 2, 4, 4, 3]
* b' = [2, 3, 1, 1, 2, 4, 3]
* c' = [3, 4, 4, 2, 5, 5, 4] | ```python
from collections import defaultdict, Counter
from sys import exit
N = int(input())
B = list(map(int, input().split()))
C = list(map(int, input().split()))
Edge = defaultdict(list)
Edc = defaultdict(int)
for b, c in zip(B, C):
if b > c:
print(-1)
exit()
Edge[b].append(c)
Edc[(b, c)] += 1
if b != c:
Edge[c].append(b)
Deg = Counter(B + C)
eul = 0
st = []
for k, v in Deg.items():
if v % 2:
eul += 1
st.append(k)
s, e = B[0], B[0]
if eul and eul != 2:
print(-1)
exit()
if eul:
s, e = st[0], st[1]
ans = [s]
while True:
vn = ans[-1]
while True:
vf = Edge[vn][-1]
if Deg[vf] != 0 and Edc[(vn, vf) if vn < vf else (vf, vn)]:
break
Edge[vn].pop()
vf = Edge[vn].pop()
Deg[vn] -= 1
Deg[vf] -= 1
Edc[(vn, vf) if vn < vf else (vf, vn)] -= 1
ans.append(vf)
if not Deg[vf]:
break
loop = defaultdict(list)
for a in ans:
if Deg[a]:
loopa = [a]
while Deg[a]:
vn = loopa[-1]
while True:
vf = Edge[vn][-1]
if Deg[vf] != 0 and Edc[(vn, vf) if vn < vf else (vf, vn)]:
break
Edge[vn].pop()
vf = Edge[vn].pop()
Deg[vn] -= 1
Deg[vf] -= 1
Edc[(vn, vf) if vn < vf else (vf, vn)] -= 1
loopa.append(vf)
if not Deg[vf]:
break
loop[a] = loopa
Ans = []
for a in ans:
if loop[a]:
Ans.extend(loop[a])
loop[a] = []
else:
Ans.append(a)
if len(Ans) != N:
print(-1)
exit()
print(*Ans)
``` |
1174_C. Ehab and a Special Coloring Problem | You're given an integer n. For every integer i from 2 to n, assign a positive integer a_i such that the following conditions hold:
* For any pair of integers (i,j), if i and j are coprime, a_i ≠ a_j.
* The maximal value of all a_i should be minimized (that is, as small as possible).
A pair of integers is called [coprime](https://en.wikipedia.org/wiki/Coprime_integers) if their [greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor) is 1.
Input
The only line contains the integer n (2 ≤ n ≤ 10^5).
Output
Print n-1 integers, a_2, a_3, …, a_n (1 ≤ a_i ≤ n).
If there are multiple solutions, print any of them.
Examples
Input
4
Output
1 2 1
Input
3
Output
2 1
Note
In the first example, notice that 3 and 4 are coprime, so a_3 ≠ a_4. Also, notice that a=[1,2,3] satisfies the first condition, but it's not a correct answer because its maximal value is 3. | ```python
def main():
buf = input()
n = int(buf)
prime_map = dict()
a = []
for i in range(2, n+1):
first_prime = first_prime_factor(i)
if first_prime not in prime_map:
prime_map[first_prime] = len(prime_map)+1
a.append(prime_map[first_prime])
print(' '.join(list(map(str, a))))
def first_prime_factor(x):
n = x
i = 2
while i * i <= n:
if n % i == 0:
return i
i += 1
return x
if __name__ == '__main__':
main()
``` |
1210_A. Anadi and Domino | Anadi has a set of dominoes. Every domino has two parts, and each part contains some dots. For every a and b such that 1 ≤ a ≤ b ≤ 6, there is exactly one domino with a dots on one half and b dots on the other half. The set contains exactly 21 dominoes. Here is an exact illustration of his set:
<image>
Also, Anadi has an undirected graph without self-loops and multiple edges. He wants to choose some dominoes and place them on the edges of this graph. He can use at most one domino of each type. Each edge can fit at most one domino. It's not necessary to place a domino on each edge of the graph.
When placing a domino on an edge, he also chooses its direction. In other words, one half of any placed domino must be directed toward one of the endpoints of the edge and the other half must be directed toward the other endpoint. There's a catch: if there are multiple halves of dominoes directed toward the same vertex, each of these halves must contain the same number of dots.
How many dominoes at most can Anadi place on the edges of his graph?
Input
The first line contains two integers n and m (1 ≤ n ≤ 7, 0 ≤ m ≤ (n⋅(n-1))/(2)) — the number of vertices and the number of edges in the graph.
The next m lines contain two integers each. Integers in the i-th line are a_i and b_i (1 ≤ a, b ≤ n, a ≠ b) and denote that there is an edge which connects vertices a_i and b_i.
The graph might be disconnected. It's however guaranteed that the graph doesn't contain any self-loops, and that there is at most one edge between any pair of vertices.
Output
Output one integer which denotes the maximum number of dominoes which Anadi can place on the edges of the graph.
Examples
Input
4 4
1 2
2 3
3 4
4 1
Output
4
Input
7 0
Output
0
Input
3 1
1 3
Output
1
Input
7 21
1 2
1 3
1 4
1 5
1 6
1 7
2 3
2 4
2 5
2 6
2 7
3 4
3 5
3 6
3 7
4 5
4 6
4 7
5 6
5 7
6 7
Output
16
Note
Here is an illustration of Anadi's graph from the first sample test:
<image>
And here is one of the ways to place a domino on each of its edges:
<image>
Note that each vertex is faced by the halves of dominoes with the same number of dots. For instance, all halves directed toward vertex 1 have three dots. | ```python
def gns():
return list(map(int, input().split()))
def ps(st, c, ans):
if len(st) == 0:
ans.append(tuple(c))
nxt = set(st)
for ci in st:
c.append(ci)
nxt.remove(ci)
ps(nxt, c, ans)
c.pop()
nxt.add(ci)
st = set(range(6))
c = []
mine = []
ps(st, c, mine)
# x=(1,2,0,3,4,5)
# print(x in mine)
# mine=[[1,2,0,3,4,5]]
n, k = gns()
st = set()
for i in range(k):
a, b = gns()
a -= 1
b -= 1
a, b = min(a, b), max(a, b)
st.add((a, b))
ans = 0
for mi in mine:
for i in range(7):
# if m==(1,2,0,3,4,5)and i==2:
# xxxxxx=0
m = mi[:i] + (0,) + mi[i:]
nd = set()
for i in range(7):
for j in range(i, 7):
ij = (i, j)
if ij in st:
di, dj = m[i], m[j]
di, dj = min(di, dj), max(di, dj)
nd.add((di, dj))
# x = nd.intersection(st)
l = len(nd)
# if x!=16:
# xxxxx=0
ans = max(l, ans)
print(ans)
``` |
1230_E. Kamil and Making a Stream | Kamil likes streaming the competitive programming videos. His MeTube channel has recently reached 100 million subscribers. In order to celebrate this, he posted a video with an interesting problem he couldn't solve yet. Can you help him?
You're given a tree — a connected undirected graph consisting of n vertices connected by n - 1 edges. The tree is rooted at vertex 1. A vertex u is called an ancestor of v if it lies on the shortest path between the root and v. In particular, a vertex is an ancestor of itself.
Each vertex v is assigned its beauty x_v — a non-negative integer not larger than 10^{12}. This allows us to define the beauty of a path. Let u be an ancestor of v. Then we define the beauty f(u, v) as the greatest common divisor of the beauties of all vertices on the shortest path between u and v. Formally, if u=t_1, t_2, t_3, ..., t_k=v are the vertices on the shortest path between u and v, then f(u, v) = \gcd(x_{t_1}, x_{t_2}, ..., x_{t_k}). Here, \gcd denotes the greatest common divisor of a set of numbers. In particular, f(u, u) = \gcd(x_u) = x_u.
Your task is to find the sum
$$$ ∑_{u is an ancestor of v} f(u, v). $$$
As the result might be too large, please output it modulo 10^9 + 7.
Note that for each y, \gcd(0, y) = \gcd(y, 0) = y. In particular, \gcd(0, 0) = 0.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of vertices in the tree.
The following line contains n integers x_1, x_2, ..., x_n (0 ≤ x_i ≤ 10^{12}). The value x_v denotes the beauty of vertex v.
The following n - 1 lines describe the edges of the tree. Each of them contains two integers a, b (1 ≤ a, b ≤ n, a ≠ b) — the vertices connected by a single edge.
Output
Output the sum of the beauties on all paths (u, v) such that u is ancestor of v. This sum should be printed modulo 10^9 + 7.
Examples
Input
5
4 5 6 0 8
1 2
1 3
1 4
4 5
Output
42
Input
7
0 2 3 0 0 0 0
1 2
1 3
2 4
2 5
3 6
3 7
Output
30
Note
The following figure shows all 10 possible paths for which one endpoint is an ancestor of another endpoint. The sum of beauties of all these paths is equal to 42:
<image> | ```python
from math import gcd
from collections import deque
from bisect import bisect_left
from sys import setrecursionlimit
MOD = 1000000007
def main():
n = int(input())
setrecursionlimit(n+100)
xx = [0] + [int(x) for x in input().split()]
edges = []
neighbors = [[] for _ in range(n+1)]
for _ in range(n-1):
v1, v2 = [int(x) for x in input().split()]
neighbors[v1].append(v2)
neighbors[v2].append(v1)
visited = [False] * (n+1)
dq = deque()
dq.append((1,[]))
sum = 0
while dq:
u,gcds = dq.popleft()
gcdns = [[xx[u], 1]]
sum = (sum + xx[u]) % MOD
for g, c in gcds:
gcdn = gcd(xx[u], g)
sum = (sum + gcdn*c) % MOD
if gcdn == gcdns[-1][0]:
gcdns[-1][1] += c
else:
gcdns.append([gcdn, c])
visited[u] = True
for v in neighbors[u]:
if not visited[v]:
dq.append((v, gcdns))
print(sum)
if __name__ == "__main__":
main()
``` |
1272_A. Three Friends | Three friends are going to meet each other. Initially, the first friend stays at the position x = a, the second friend stays at the position x = b and the third friend stays at the position x = c on the coordinate axis Ox.
In one minute each friend independently from other friends can change the position x by 1 to the left or by 1 to the right (i.e. set x := x - 1 or x := x + 1) or even don't change it.
Let's introduce the total pairwise distance — the sum of distances between each pair of friends. Let a', b' and c' be the final positions of the first, the second and the third friend, correspondingly. Then the total pairwise distance is |a' - b'| + |a' - c'| + |b' - c'|, where |x| is the absolute value of x.
Friends are interested in the minimum total pairwise distance they can reach if they will move optimally. Each friend will move no more than once. So, more formally, they want to know the minimum total pairwise distance they can reach after one minute.
You have to answer q independent test cases.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 1000) — the number of test cases.
The next q lines describe test cases. The i-th test case is given as three integers a, b and c (1 ≤ a, b, c ≤ 10^9) — initial positions of the first, second and third friend correspondingly. The positions of friends can be equal.
Output
For each test case print the answer on it — the minimum total pairwise distance (the minimum sum of distances between each pair of friends) if friends change their positions optimally. Each friend will move no more than once. So, more formally, you have to find the minimum total pairwise distance they can reach after one minute.
Example
Input
8
3 3 4
10 20 30
5 5 5
2 4 3
1 1000000000 1000000000
1 1000000000 999999999
3 2 5
3 2 6
Output
0
36
0
0
1999999994
1999999994
2
4 | ```python
for _ in range(int(input())):
a,b,c=[int(x) for x in input().split()]
m=max(a,b,c)-min(a,b,c)
if m>1:print((m-2)*2)
else:print('0')
``` |
1295_B. Infinite Prefixes | You are given string s of length n consisting of 0-s and 1-s. You build an infinite string t as a concatenation of an infinite number of strings s, or t = ssss ... For example, if s = 10010, then t = 100101001010010...
Calculate the number of prefixes of t with balance equal to x. The balance of some string q is equal to cnt_{0, q} - cnt_{1, q}, where cnt_{0, q} is the number of occurrences of 0 in q, and cnt_{1, q} is the number of occurrences of 1 in q. The number of such prefixes can be infinite; if it is so, you must say that.
A prefix is a string consisting of several first letters of a given string, without any reorders. An empty prefix is also a valid prefix. For example, the string "abcd" has 5 prefixes: empty string, "a", "ab", "abc" and "abcd".
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of test cases.
Next 2T lines contain descriptions of test cases — two lines per test case. The first line contains two integers n and x (1 ≤ n ≤ 10^5, -10^9 ≤ x ≤ 10^9) — the length of string s and the desired balance, respectively.
The second line contains the binary string s (|s| = n, s_i ∈ \{0, 1\}).
It's guaranteed that the total sum of n doesn't exceed 10^5.
Output
Print T integers — one per test case. For each test case print the number of prefixes or -1 if there is an infinite number of such prefixes.
Example
Input
4
6 10
010010
5 3
10101
1 0
0
2 0
01
Output
3
0
1
-1
Note
In the first test case, there are 3 good prefixes of t: with length 28, 30 and 32. | ```python
import math
tt=int(input())
for i in range(tt):
n,x=map(int,input().split())
s=input()
a=1
b={}
def bind(x):
return -((2*x)-1)
if x<0:
a=-1
x=-x
sbal=0
for i in s:
sbal+=(bind(int(i))*a)
b[sbal]=b.get(sbal,0)+1
ans=0
if sbal==0:
if b.get(x,0) != 0:
print(-1)
else:
print(0)
continue
elif sbal>0:
add = x - max(b)
if add > 0:
x-=math.ceil(add/sbal)*sbal
for i in range(x,min(b)-sbal,-sbal):
ans+=b.get(i,0)
else:
dec = min(b) - x
if dec > 0:
x+=math.ceil(dec/sbal)*sbal
for i in range(x,max(b)-sbal,-sbal):
ans+=b.get(i,0)
if x==0:
ans+=1
print(ans)
``` |
1316_B. String Modification | Vasya has a string s of length n. He decides to make the following modification to the string:
1. Pick an integer k, (1 ≤ k ≤ n).
2. For i from 1 to n-k+1, reverse the substring s[i:i+k-1] of s. For example, if string s is qwer and k = 2, below is the series of transformations the string goes through:
* qwer (original string)
* wqer (after reversing the first substring of length 2)
* weqr (after reversing the second substring of length 2)
* werq (after reversing the last substring of length 2)
Hence, the resulting string after modifying s with k = 2 is werq.
Vasya wants to choose a k such that the string obtained after the above-mentioned modification is lexicographically smallest possible among all choices of k. Among all such k, he wants to choose the smallest one. Since he is busy attending Felicity 2020, he asks for your help.
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
Each test contains multiple test cases.
The first line contains the number of test cases t (1 ≤ t ≤ 5000). The description of the test cases follows.
The first line of each test case contains a single integer n (1 ≤ n ≤ 5000) — the length of the string s.
The second line of each test case contains the string s of n lowercase latin letters.
It is guaranteed that the sum of n over all test cases does not exceed 5000.
Output
For each testcase output two lines:
In the first line output the lexicographically smallest string s' achievable after the above-mentioned modification.
In the second line output the appropriate value of k (1 ≤ k ≤ n) that you chose for performing the modification. If there are multiple values of k that give the lexicographically smallest string, output the smallest value of k among them.
Example
Input
6
4
abab
6
qwerty
5
aaaaa
6
alaska
9
lfpbavjsm
1
p
Output
abab
1
ertyqw
3
aaaaa
1
aksala
6
avjsmbpfl
5
p
1
Note
In the first testcase of the first sample, the string modification results for the sample abab are as follows :
* for k = 1 : abab
* for k = 2 : baba
* for k = 3 : abab
* for k = 4 : baba
The lexicographically smallest string achievable through modification is abab for k = 1 and 3. Smallest value of k needed to achieve is hence 1. | ```python
from sys import stdin, stdout
input = stdin.readline
for _ in " " * int(input()):
n = int(input())
s = list(input())[:-1]
ans = list(s)
ind = 0
for k in range(n):
if (n - k) % 2:
st = s[k:] + s[:k][::-1]
else:
st = s[k:] + s[:k]
if st < ans:
ind = k
ans = list(st)
print("".join(ans))
print(ind + 1)
``` |
1337_D. Xenia and Colorful Gems | Xenia is a girl being born a noble. Due to the inflexibility and harshness of her family, Xenia has to find some ways to amuse herself.
<image>
Recently Xenia has bought n_r red gems, n_g green gems and n_b blue gems. Each of the gems has a weight.
Now, she is going to pick three gems.
Xenia loves colorful things, so she will pick exactly one gem of each color.
Xenia loves balance, so she will try to pick gems with little difference in weight.
Specifically, supposing the weights of the picked gems are x, y and z, Xenia wants to find the minimum value of (x-y)^2+(y-z)^2+(z-x)^2. As her dear friend, can you help her?
Input
The first line contains a single integer t (1≤ t ≤ 100) — the number of test cases. Then t test cases follow.
The first line of each test case contains three integers n_r,n_g,n_b (1≤ n_r,n_g,n_b≤ 10^5) — the number of red gems, green gems and blue gems respectively.
The second line of each test case contains n_r integers r_1,r_2,…,r_{n_r} (1≤ r_i ≤ 10^9) — r_i is the weight of the i-th red gem.
The third line of each test case contains n_g integers g_1,g_2,…,g_{n_g} (1≤ g_i ≤ 10^9) — g_i is the weight of the i-th green gem.
The fourth line of each test case contains n_b integers b_1,b_2,…,b_{n_b} (1≤ b_i ≤ 10^9) — b_i is the weight of the i-th blue gem.
It is guaranteed that ∑ n_r ≤ 10^5, ∑ n_g ≤ 10^5, ∑ n_b ≤ 10^5 (the sum for all test cases).
Output
For each test case, print a line contains one integer — the minimum value which Xenia wants to find.
Example
Input
5
2 2 3
7 8
6 3
3 1 4
1 1 1
1
1
1000000000
2 2 2
1 2
5 4
6 7
2 2 2
1 2
3 4
6 7
3 4 1
3 2 1
7 3 3 4
6
Output
14
1999999996000000002
24
24
14
Note
In the first test case, Xenia has the following gems:
<image>
If she picks the red gem with weight 7, the green gem with weight 6, and the blue gem with weight 4, she will achieve the most balanced selection with (x-y)^2+(y-z)^2+(z-x)^2=(7-6)^2+(6-4)^2+(4-7)^2=14. | ```python
import bisect
def nearest_with_leader(reds, greens, blues):
minimum = 10**19*3
for g in greens:
bi = bisect.bisect_left(blues, g)
ri = bisect.bisect_right(reds, g)
if ri == 0 or bi == len(blues):
continue
b = blues[bi]
r = reds[ri-1]
minimum = min(minimum, (g-b)**2 + (b-r)**2 + (g-r)**2)
return minimum
t = int(input())
for _ in range(t):
r, g, b = [int(x) for x in input().split()]
reds = sorted([int(x) for x in input().split()])
greens = sorted([int(x) for x in input().split()])
blues = sorted([int(x) for x in input().split()])
print(min(
nearest_with_leader(reds, greens, blues),
nearest_with_leader(blues, greens, reds),
nearest_with_leader(greens, blues, reds),
nearest_with_leader(reds, blues, greens),
nearest_with_leader(blues, reds, greens),
nearest_with_leader(greens, reds, blues),
))
``` |
135_B. Rectangle and Square | Little Petya very much likes rectangles and especially squares. Recently he has received 8 points on the plane as a gift from his mother. The points are pairwise distinct. Petya decided to split them into two sets each containing 4 points so that the points from the first set lay at the vertexes of some square and the points from the second set lay at the vertexes of a rectangle. Each point of initial 8 should belong to exactly one set. It is acceptable for a rectangle from the second set was also a square. If there are several partitions, Petya will be satisfied by any of them. Help him find such partition. Note that the rectangle and the square from the partition should have non-zero areas. The sides of the figures do not have to be parallel to the coordinate axes, though it might be the case.
Input
You are given 8 pairs of integers, a pair per line — the coordinates of the points Petya has. The absolute value of all coordinates does not exceed 104. It is guaranteed that no two points coincide.
Output
Print in the first output line "YES" (without the quotes), if the desired partition exists. In the second line output 4 space-separated numbers — point indexes from the input, which lie at the vertexes of the square. The points are numbered starting from 1. The numbers can be printed in any order. In the third line print the indexes of points lying at the vertexes of a rectangle in the similar format. All printed numbers should be pairwise distinct.
If the required partition does not exist, the first line should contain the word "NO" (without the quotes), after which no output is needed.
Examples
Input
0 0
10 11
10 0
0 11
1 1
2 2
2 1
1 2
Output
YES
5 6 7 8
1 2 3 4
Input
0 0
1 1
2 2
3 3
4 4
5 5
6 6
7 7
Output
NO
Input
0 0
4 4
4 0
0 4
1 2
2 3
3 2
2 1
Output
YES
1 2 3 4
5 6 7 8
Note
Pay attention to the third example: the figures do not necessarily have to be parallel to the coordinate axes. | ```python
from math import *
def a(x1,y1,x2,y2,x3,y3,x4,y4):
b=sorted([[x1,y1],[x2,y2],[x3,y3],[x4,y4]])
x1,y1=b[0]
x2,y2=b[1]
x3,y3=b[2]
x4,y4=b[3]
a1=sqrt((x1-x2)**2+(y1-y2)**2)
a2=sqrt((x4-x2)**2+(y4-y2)**2)
a3=sqrt((x4-x3)**2+(y4-y3)**2)
a4=sqrt((x1-x3)**2+(y1-y3)**2)
return a1==a2==a3==a4 and a1!=0 and a4!=0 and abs(abs(degrees(asin((y2-y1)/a1)-asin((y3-y1)/a4)))-90)<=10**(-8)
def b(x1,y1,x2,y2,x3,y3,x4,y4):
b=sorted([[x1,y1],[x2,y2],[x3,y3],[x4,y4]])
x1,y1=b[0]
x2,y2=b[1]
x3,y3=b[2]
x4,y4=b[3]
a1=sqrt((x1-x2)**2+(y1-y2)**2)
a2=sqrt((x4-x2)**2+(y4-y2)**2)
a3=sqrt((x4-x3)**2+(y4-y3)**2)
a4=sqrt((x1-x3)**2+(y1-y3)**2)
return a1==a3 and a2==a4 and a1!=0 and a4!=0 and abs(abs(degrees(asin((y2-y1)/a1)-asin((y3-y1)/a4)))-90)<=10**(-8)
c=[list(map(int,input().split())) for i in range(8)]
z=False
for i in range(5):
for j in range(i+1,6):
for k in range(j+1,7):
for l in range(k+1,8):
if a(*c[i]+c[j]+c[k]+c[l]):
d=[]
e=[]
for m in range(8):
if m not in [i,j,k,l]:
d+=c[m]
e.append(m+1)
if b(*d):
print('YES')
print(i+1,j+1,k+1,l+1)
print(*e)
z=True
break
if z:
break
if z:
break
if z:
break
if not(z):
print('NO')
``` |
137_C. History | Polycarpus likes studying at school a lot and he is always diligent about his homework. Polycarpus has never had any problems with natural sciences as his great-great-grandfather was the great physicist Seinstein. On the other hand though, Polycarpus has never had an easy time with history.
Everybody knows that the World history encompasses exactly n events: the i-th event had continued from the year ai to the year bi inclusive (ai < bi). Polycarpus easily learned the dates when each of n events started and ended (Polycarpus inherited excellent memory from his great-great-granddad). But the teacher gave him a more complicated task: Polycaprus should know when all events began and ended and he should also find out for each event whether it includes another event. Polycarpus' teacher thinks that an event j includes an event i if aj < ai and bi < bj. Your task is simpler: find the number of events that are included in some other event.
Input
The first input line contains integer n (1 ≤ n ≤ 105) which represents the number of events. Next n lines contain descriptions of the historical events, one event per line. The i + 1 line contains two integers ai and bi (1 ≤ ai < bi ≤ 109) — the beginning and the end of the i-th event. No two events start or finish in the same year, that is, ai ≠ aj, ai ≠ bj, bi ≠ aj, bi ≠ bj for all i, j (where i ≠ j). Events are given in arbitrary order.
Output
Print the only integer — the answer to the problem.
Examples
Input
5
1 10
2 9
3 8
4 7
5 6
Output
4
Input
5
1 100
2 50
51 99
52 98
10 60
Output
4
Input
1
1 1000000000
Output
0
Note
In the first example the fifth event is contained in the fourth. Similarly, the fourth event is contained in the third, the third — in the second and the second — in the first.
In the second example all events except the first one are contained in the first.
In the third example only one event, so the answer is 0. | ```python
import sys
import math
n=int(input())
k=[]
for i in range(n):
a,b=map(int,input().split())
k.append((a,b))
k.sort()
t,con=0,0
for (a,b) in k:
if(b<t):
con+=1
else:
t=b
print(con)
``` |
13_C. Sequence | Little Petya likes to play very much. And most of all he likes to play the following game:
He is given a sequence of N integer numbers. At each step it is allowed to increase the value of any number by 1 or to decrease it by 1. The goal of the game is to make the sequence non-decreasing with the smallest number of steps. Petya is not good at math, so he asks for your help.
The sequence a is called non-decreasing if a1 ≤ a2 ≤ ... ≤ aN holds, where N is the length of the sequence.
Input
The first line of the input contains single integer N (1 ≤ N ≤ 5000) — the length of the initial sequence. The following N lines contain one integer each — elements of the sequence. These numbers do not exceed 109 by absolute value.
Output
Output one integer — minimum number of steps required to achieve the goal.
Examples
Input
5
3 2 -1 2 11
Output
4
Input
5
2 1 1 1 1
Output
1 | ```python
from bisect import insort
def min_steps_N(arr):
pri_q = []
ans = 0
for n in arr:
if pri_q:
if pri_q[-1] > n:
ans += pri_q[-1] - n
pri_q.pop()
insort(pri_q, n)
insort(pri_q, n)
return ans
if __name__ == '__main__':
N = input()
arr = list(map(int, input().split(' ')))
print(min_steps_N(arr))
``` |
1443_E. Long Permutation | A permutation is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] — are permutations, and [1, 1], [4, 3, 1], [2, 3, 4] — no.
Permutation a is lexicographically smaller than permutation b (they have the same length n), if in the first index i in which they differ, a[i] < b[i]. For example, the permutation [1, 3, 2, 4] is lexicographically smaller than the permutation [1, 3, 4, 2], because the first two elements are equal, and the third element in the first permutation is smaller than in the second.
The next permutation for a permutation a of length n — is the lexicographically smallest permutation b of length n that lexicographically larger than a. For example:
* for permutation [2, 1, 4, 3] the next permutation is [2, 3, 1, 4];
* for permutation [1, 2, 3] the next permutation is [1, 3, 2];
* for permutation [2, 1] next permutation does not exist.
You are given the number n — the length of the initial permutation. The initial permutation has the form a = [1, 2, …, n]. In other words, a[i] = i (1 ≤ i ≤ n).
You need to process q queries of two types:
* 1 l r: query for the sum of all elements on the segment [l, r]. More formally, you need to find a[l] + a[l + 1] + … + a[r].
* 2 x: x times replace the current permutation with the next permutation. For example, if x=2 and the current permutation has the form [1, 3, 4, 2], then we should perform such a chain of replacements [1, 3, 4, 2] → [1, 4, 2, 3] → [1, 4, 3, 2].
For each query of the 1-st type output the required sum.
Input
The first line contains two integers n (2 ≤ n ≤ 2 ⋅ 10^5) and q (1 ≤ q ≤ 2 ⋅ 10^5), where n — the length of the initial permutation, and q — the number of queries.
The next q lines contain a single query of the 1-st or 2-nd type. The 1-st type query consists of three integers 1, l and r (1 ≤ l ≤ r ≤ n), the 2-nd type query consists of two integers 2 and x (1 ≤ x ≤ 10^5).
It is guaranteed that all requests of the 2-nd type are possible to process.
Output
For each query of the 1-st type, output on a separate line one integer — the required sum.
Example
Input
4 4
1 2 4
2 3
1 1 2
1 3 4
Output
9
4
6
Note
Initially, the permutation has the form [1, 2, 3, 4]. Queries processing is as follows:
1. 2 + 3 + 4 = 9;
2. [1, 2, 3, 4] → [1, 2, 4, 3] → [1, 3, 2, 4] → [1, 3, 4, 2];
3. 1 + 3 = 4;
4. 4 + 2 = 6 | ```python
from math import factorial
def short_perm_to_num(perm, n): # O(n**2), but n <= 70
result = 0
is_used = {}
for i in range(n):
for j in range(perm[i]):
if not (j in is_used):
result += factorial(n-1-i)
is_used[perm[i]] = True
return result
def perm_to_num(perm, n):
max_len = 15
if n <= max_len:
return short_perm_to_num(perm, n)
else:
last_part = [x - (n-max_len) for x in perm[n-max_len:]]
return short_perm_to_num(last_part, max_len)
def short_num_to_perm(num, n):
is_used = {}
perm = []
for i in range(n):
deg = num // factorial(n-1-i)
num %= factorial(n-1-i)
j = 0
while j in is_used:
j += 1
# now j is 1st unused item
deg_of_j = 0
while (deg_of_j < deg) or (j in is_used):
if not (j in is_used):
deg_of_j += 1
j += 1
perm.append(j)
is_used[j] = True
return perm
def num_to_perm(num, n): # RETURNS ONLY LAST 15 SYMBOLS
max_len = 15
if n <= max_len:
return short_num_to_perm(num, n)
else:
last_part_low = short_num_to_perm(num, max_len)
last_part = [x + (n-max_len) for x in last_part_low]
return last_part
[n, q] = [int(x) for x in input().split()]
full_perm = [i for i in range(0, n)] # full permutation as an array, but don't forget to add 1 when printing
num_of_perm = 0
# 70! is just above 10**100, so elements before the last 70 are still 1, 2, 3, ... n-7
for quarry_num in range(q):
quarry = [int(x) for x in input().split()]
if quarry[0] == 1:
perm = num_to_perm(num_of_perm, n)
l = quarry[1]
r = quarry[2]
if n <= 15:
print(sum(perm[l-1:r]) + r-l+1)
else: # n-15, n-14, ... n-1 are in the perm; we must compute sum(perm[l-1:r])
if l-1 >= n-15:
print(sum(perm[l-1-n+15:r-n+15]) + r-l+1)
else: # l-1 < n-15
if r < n-15:
s = ((l-1) + r-1) * (r-1 - l+1 + 1) // 2
print(s + r-l+1)
else:
s = ((l-1) + n-16) * (n-16 - l + 2) // 2
rest = sum(perm[:r-n+15])
print(s + rest + r-l+1)
if quarry[0] == 2:
num_of_perm += quarry[1]
``` |
1468_N. Waste Sorting | The progress is not standing still in Berland. Recently all garbage containers in Bertown, the capital of Berland, were replaced by differentiated recycling bins, each accepting some category of waste. While this will definitely improve the ecological situation, for some citizens it's difficult to get used to the habit of sorting waste.
Monocarp is one of those citizens who tries to get used to waste sorting. Today he has to take out the trash from his house. There are three containers near the Monocarp's house, the first one accepts paper waste, the second one accepts plastic waste, and the third one — all other types of waste. It is possible to fit c_1 items into the first container, c_2 items into the second container and c_3 items into the third container.
Monocarp has a lot of items to throw into containers. Some are made of paper, so Monocarp has to put them into the first container (he has a_1 such items), some are made of plastic, so he has to put them into the second container (he has a_2 such items), and some are neither paper nor plastic — so Monocarp has to put them into the third container (he has a_3 such items).
Unfortunately, there are also two categories of items that Monocarp is unsure of: he has a_4 items which are partially made of paper, so he will put each of these items either into the first container or into the third container. Similarly, he has a_5 items partially made of plastic, so he has to put each of them either into the second container or into the third container. Obviously, this choice is made separately for each item — for example, Monocarp can throw several partially-plastic items into the second container, and all other partially-plastic items — into the third one.
Now Monocarp wonders: is it possible to put each item into some container so that the first container will hold no more than c_1 items, the second one — no more than c_2 items, and the third one — no more than c_3 items?
Input
The first line contains one integer t (1 ≤ t ≤ 3 ⋅ 10^4) — the number of test cases.
Each test case consists of two lines. The first line of each test case contains three integers c_1, c_2, c_3 (0 ≤ c_1, c_2, c_3 ≤ 10^8) — the capacities of the containers.
The second line of each test case contains five integers a_1, a_2, a_3, a_4, a_5 (0 ≤ a_i ≤ 10^8), where a_i is the number of items of the i-th category Monocarp has to throw out (i = 1 is paper waste, i = 2 is plastic waste, i = 3 is general waste, i = 4 is partially-paper waste, i = 5 is partially-plastic waste).
Output
For each test case, print either YES if it is possible to fit all items into containers, or NO otherwise. You may print each letter in any case (for example, YES, Yes, yes, yEs will all be recognized as positive answer).
Example
Input
7
1 2 3
1 2 3 0 0
2 2 3
1 2 3 1 0
2 2 3
1 2 3 0 1
1 2 5
1 2 3 1 1
0 0 0
0 0 0 0 0
0 0 4
1 0 0 0 0
13 37 42
0 0 0 40 47
Output
YES
YES
NO
YES
YES
NO
YES
Note
Explanations for the example test cases:
1. Monocarp can put 1 item of paper waste into the first container, 2 items of plastic waste into the second container, and 3 items of general waste into the third container;
2. Monocarp can put 1 item of paper waste and 1 item of partially-paper waste into the first container, 2 items of plastic waste into the second container, and 3 items of general waste into the third container;
3. there is no answer since either the second container should contain 3 items, or the third container should contain 4 items;
4. Monocarp can put 1 item of paper waste into the first container, 2 items of plastic waste into the second container, and 3 items of general waste, 1 item of partially-paper waste and 1 item of partially-plastic waste into the third container;
5. there is no waste at all, so all containers can be left empty;
6. there's no answer since it's impossible to put a paper item into the third container;
7. Monocarp can put 10 items of partially-paper waste into the first container, 37 items of partially-plastic waste into the second container, and 30 items of partially-paper waste and 10 items of partially-plastic waste into the third container. | ```python
def check(c1, c2, c3, v13, v23):
if c1 < 0 or c2 < 0 or c3 < 0:
return False
v13 -= min(v13, c1)
v23 -= min(v23, c2)
return v13 + v23 <= c3
for i in range(int(input())):
c1, c2, c3 = map(int, input().split())
a1, a2, a3, a4, a5 = map(int, input().split())
c1 -= a1
c2 -= a2
c3 -= a3
if check(c1, c2, c3, a4, a5):
print("YES")
else:
print("NO")
``` |
1494_B. Berland Crossword | Berland crossword is a puzzle that is solved on a square grid with n rows and n columns. Initially all the cells are white.
To solve the puzzle one has to color some cells on the border of the grid black in such a way that:
* exactly U cells in the top row are black;
* exactly R cells in the rightmost column are black;
* exactly D cells in the bottom row are black;
* exactly L cells in the leftmost column are black.
Note that you can color zero cells black and leave every cell white.
Your task is to check if there exists a solution to the given puzzle.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases.
Then the descriptions of t testcases follow.
The only line of each testcase contains 5 integers n, U, R, D, L (2 ≤ n ≤ 100; 0 ≤ U, R, D, L ≤ n).
Output
For each testcase print "YES" if the solution exists and "NO" otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
4
5 2 5 3 1
3 0 0 0 0
4 4 1 4 0
2 1 1 1 1
Output
YES
YES
NO
YES
Note
Here are possible solutions to testcases 1, 2 and 4:
<image> | ```python
def solve():
n, u, r, d, l = map(int, input().split())
for i in range(16):
ur = i & 1
dr = bool(i & 1<<1)
dl = bool(i & 1<<2)
ul = bool(i & 1<<3)
uu=u
rr=r
dd=d
ll=l
uu -= ur + ul
rr -= ur + dr
dd -= dr + dl
ll -= dl + ul
for side in (uu, rr, dd, ll):
if side<0 or side>n-2:
break
else:
print("YES")
return
print("NO")
def main():
for i in range(int(input())):
solve()
if __name__ == '__main__':
main()
``` |
1517_A. Sum of 2050 | A number is called 2050-number if it is 2050, 20500, ..., (2050 ⋅ 10^k for integer k ≥ 0).
Given a number n, you are asked to represent n as the sum of some (not necessarily distinct) 2050-numbers. Compute the minimum number of 2050-numbers required for that.
Input
The first line contains a single integer T (1≤ T≤ 1 000) denoting the number of test cases.
The only line of each test case contains a single integer n (1≤ n≤ 10^{18}) denoting the number to be represented.
Output
For each test case, output the minimum number of 2050-numbers in one line.
If n cannot be represented as the sum of 2050-numbers, output -1 instead.
Example
Input
6
205
2050
4100
20500
22550
25308639900
Output
-1
1
2
1
2
36
Note
In the third case, 4100 = 2050 + 2050.
In the fifth case, 22550 = 20500 + 2050. | ```python
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
#from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
#from bisect import bisect_right as br #c++ upperbound br(array,element)
def main():
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
for _ in range(int(input())):
n=int(input())
nums=[2050*(10**x) for x in range(20)]
nums.reverse()
ans=0
low=0
while low<len(nums):
while n-nums[low]>=0:
n-=nums[low]
ans+=1
low+=1
if n==0:
print(ans)
else:
print(-1)
#-----------------------------BOSS-------------------------------------!
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
``` |
1543_E. The Final Pursuit | Finally, you have defeated Razor and now, you are the Most Wanted street racer. Sergeant Cross has sent the full police force after you in a deadly pursuit. Fortunately, you have found a hiding spot but you fear that Cross and his force will eventually find you. To increase your chances of survival, you want to tune and repaint your BMW M3 GTR.
The car can be imagined as a permuted n-dimensional hypercube. A simple n-dimensional hypercube is an undirected unweighted graph built recursively as follows:
* Take two simple (n-1)-dimensional hypercubes one having vertices numbered from 0 to 2^{n-1}-1 and the other having vertices numbered from 2^{n-1} to 2^{n}-1. A simple 0-dimensional Hypercube is just a single vertex.
* Add an edge between the vertices i and i+2^{n-1} for each 0≤ i < 2^{n-1}.
A permuted n-dimensional hypercube is formed by permuting the vertex numbers of a simple n-dimensional hypercube in any arbitrary manner.
Examples of a simple and permuted 3-dimensional hypercubes are given below:
<image>
Note that a permuted n-dimensional hypercube has the following properties:
* There are exactly 2^n vertices.
* There are exactly n⋅ 2^{n-1} edges.
* Each vertex is connected to exactly n other vertices.
* There are no self-loops or duplicate edges.
Let's denote the permutation used to generate the permuted n-dimensional hypercube, representing your car, from a simple n-dimensional hypercube by P. Before messing up the functionalities of the car, you want to find this permutation so that you can restore the car if anything goes wrong. But the job isn't done yet.
You have n different colours numbered from 0 to n-1. You want to colour the vertices of this permuted n-dimensional hypercube in such a way that for each and every vertex u satisfying 0≤ u < 2^n and for each and every colour c satisfying 0≤ c < n, there is at least one vertex v adjacent to u having a colour c. In other words, from each and every vertex, it must be possible to reach a vertex of any colour by just moving to an adjacent vertex.
Given the permuted n-dimensional hypercube, find any valid permutation P and colouring.
Input
The first line of input contains a single integer t (1≤ t≤ 4096) — the number of test cases.
For each test case, the first line contains a single integer n (1≤ n≤ 16).
Each of the next n⋅ 2^{n-1} lines contain two integers u and v (0≤ u, v < 2^n) denoting that there is an edge between the vertices numbered u and v.
It is guaranteed that the graph described in the input is a permuted n-dimensional hypercube.
Additionally, it is guaranteed that the sum of 2^n over all test cases does not exceed 2^{16}=65 536.
Output
For each test case, print two lines.
In the first line, output any permutation P of length 2^n that can be used to transform a simple n-dimensional hypercube to the permuted n-dimensional hypercube given in the input. Two permuted hypercubes are considered the same if they have the same set of edges. If there are multiple answers, output any of them.
In the second line, print the colouring. If there is no way to colour the vertices satisfying the conditions, output -1. Otherwise, output a single line containing 2^n space separated integers. The i-th integer must be the colour of the vertex numbered (i-1) in the permuted n-dimensional hypercube. If there are multiple answers, output any of them.
Example
Input
3
1
0 1
2
0 1
1 2
2 3
3 0
3
0 1
0 5
0 7
1 2
1 4
2 5
2 6
3 5
3 6
3 7
4 6
4 7
Output
0 1
0 0
0 1 3 2
0 0 1 1
5 3 0 7 2 6 1 4
-1
Note
The colouring and the permuted hypercube for the first test case is shown below:
<image>
The colouring and the permuted hypercube for the second test case is shown below:
<image>
The permuted hypercube for the third test case is given in the problem statement. However, it can be shown that there exists no way to colour that cube satifying all the conditions. Note that some other permutations like [0, 5, 7, 3, 1, 2, 4, 6] and [0, 1, 5, 2, 7, 4, 3, 6] will also give the same permuted hypercube. | ```python
from collections import deque
from sys import stdin
import sys
tt = int(stdin.readline())
for loop in range(tt):
n = int(stdin.readline())
lis = [ [] for i in range(2**n)]
for i in range(n*(2**(n-1))):
u,v = map(int,stdin.readline().split())
lis[u].append(v)
lis[v].append(u)
rp = [0] * (2**n)
d = [float("inf")] * (2**n)
d[0] = 0
q = deque()
for i in range(n):
nexv = lis[0][i]
rp[nexv] = 2**i
d[nexv] = 1
q.append(nexv)
while q:
v = q.popleft()
for nexv in lis[v]:
if d[nexv] == float("inf"):
d[nexv] = d[v] + 1
q.append(nexv)
if d[nexv] > d[v]:
rp[nexv] |= rp[v]
p = [None] * (2**n)
for i in range(2**n):
p[rp[i]] = i
print (*p)
if (2**n) % n == 0:
c = [None] * (2**n)
for i in range(2**n):
now = 0
for j in range(n):
if 2**j & i > 0:
now ^= j
c[p[i]] = now
print (*c)
else:
print (-1)
``` |
171_G. Mysterious numbers - 2 |
Input
The only line of input contains three integers a1, a2, a3 (1 ≤ a1, a2, a3 ≤ 20), separated by spaces.
Output
Output a single integer.
Examples
Input
2 3 2
Output
5
Input
13 14 1
Output
14
Input
14 5 9
Output
464
Input
17 18 3
Output
53 | ```python
f = [0] * 22
f[0], f[1], idx = [int(x) for x in input().split()]
for i in range (2, 22) : f[i] = f[i - 1] + f[i - 2]
print(f[idx])
``` |
215_E. Periodical Numbers | A non-empty string s is called binary, if it consists only of characters "0" and "1". Let's number the characters of binary string s from 1 to the string's length and let's denote the i-th character in string s as si.
Binary string s with length n is periodical, if there is an integer 1 ≤ k < n such that:
* k is a divisor of number n
* for all 1 ≤ i ≤ n - k, the following condition fulfills: si = si + k
For example, binary strings "101010" and "11" are periodical and "10" and "10010" are not.
A positive integer x is periodical, if its binary representation (without leading zeroes) is a periodic string.
Your task is to calculate, how many periodic numbers are in the interval from l to r (both ends are included).
Input
The single input line contains two integers l and r (1 ≤ l ≤ r ≤ 1018). The numbers are separated by a space.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single integer, showing how many periodic numbers are in the interval from l to r (both ends are included).
Examples
Input
1 10
Output
3
Input
25 38
Output
2
Note
In the first sample periodic numbers are 3, 7 and 10.
In the second sample periodic numbers are 31 and 36. | ```python
from itertools import combinations
from fractions import gcd
#Numeros primos hasta el 59
primos = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]
#Para obtener la cadena binaria de x.
def ToBinary(x):
if x == 0:
return "0"
if x == 1:
return "1"
if x % 2 == 0:
return ToBinary(x>>1)+ "0"
else:
return ToBinary(x>>1)+ "1"
#Obtiene la cantidad de numeros periodicos con longitud de cadena binaria
#igual a "length".
def CountPeriodic(length):
#Contiene los numeros primos que dividen a "length".
p = [x for x in primos if length % x == 0]
ans = 0
for x in p:
#"d" cantidad de repeticiones en las variaciones de "0" y "1", y "x" cantidad de subcadenas.
d = length/x
#Se agrega a la respuesta la cantidad de variaciones de "0" y "1" con "d-1" repeticiones
#porque el primer elemento siempre es "1".
ans += 2**(d-1)
for x,y in combinations(p,2):
#Se calcula el mcd de todos los primos 2 a 2.
d = gcd(length/x, length/y)
#Se elimina de la respuesta el total de variaciones con cantidad de repeticiones igual al
#"mcd -1", mcd de dos primos diferentes dichas variaciones se contaron doble, es decir,
#una vez por cada uno de los primos.
ans -= 2**(d-1)
for x,y,z in combinations(p,3):
d = gcd(gcd(length/x, length/y), length/z)
#Aplicando el principio de inclusion-exclusion, si en el paso anterior se sustrajo
#el total de variaciones de "0" y "1" con cantidad de repeticiones asociadas al mismo mcd de tres primos distintos, significa que se quitaron
#dos veces, luego se debe agregar a la respuesta la cardinalidad del conjunto de esas
#variaciones (solo una vez).
ans += 2**(d-1)
return ans
#Chequea las variaciones para las cadenas binarias cuyos numeros son mayores o iguales
#que el de la cadena "l".
def L(l,x,d):
ans = 0
d = int(d)
x = int(x)
p = 1
while True:
#"q" es la posicion de "0" en el substring "l[p:d]".
q = l[p:d].find('0')
if q == -1:
break
#Se añade a la respuesta el total de variacines de "0" y "1" con "d" repeticiones, pero con todas las
#posiciones fijadas desde la primera hasta la del "p"-esimo "0" encontrado en el substring.
ans += 2**(d-(p+q)-1)
p += q+1
for k in range(1,x):
#Si todos los digitos en el substring "l[0:d]" son mayores que los del siguente k substring, se debe
#aumentar la respuesta en 1 porque es posible crear una cadena binaria de periodo "x" con "l[0:d]".
if l[0:d] > l[d*k:d*(k+1)]:
return ans+1
elif l[0:d] == l[d*k:d*(k+1)]:
continue
else:
#No es posible obtener una cadena binaria de periodo "x" con "l[0:d]".
return ans
#Si el programa llega hasta aqui implica que todos los substring son iguales
#por tanto la cadena binaria pertenece a un numero periodico entonces hay que
#aumentar la respuesta en 1.
return ans+1
def CountPeriodicL(l):
length = len(l)
p = [x for x in primos if length % x == 0]
ans = 0
for x in p:
d = length/x
ans += L(l,x,d)
for x,y in combinations(p,2):
d = gcd(length/x, length/y)
ans -= L(l,length/d,d)
for x,y,z in combinations(p,3):
d = gcd(gcd(length/x, length/y), length/z)
ans += L(l,length/d,d)
return ans
#Chequea las variaciones para las cadenas binarias cuyos numeros son menores o iguales
#que el de la cadena "r".
def R(r,x,d,eq=False):
ans = 0
d = int(d)
x = int(x)
p = 1
while True:
q = r[p:d].find('1')
if q == -1:
break
ans += 2**(d-(p+q)-1)
p += q+1
for k in range(1,x):
if r[0:d] < r[d*k:d*(k+1)]:
return ans+1
elif r[0:d] == r[d*k:d*(k+1)]:
continue
else:
return ans
return ans+(1 if not eq else 0)
def CountPeriodicR(r,eq=False):
length = len(r)
p = [x for x in primos if length % x == 0]
ans = 0
for x in p:
d = length/x
ans += R(r,x,d,eq)
for x,y in combinations(p,2):
d = gcd(length/x, length/y)
ans -= R(r,length/d,d,eq)
for x,y,z in combinations(p,3):
d = gcd(gcd(length/x, length/y), length/z)
ans += R(r,length/d,d,eq)
return ans
l,r = map(int,input().split())
l_binary = ToBinary(l)
r_binary = ToBinary(r)
ans = 0
#Chequea la cantidad de numeros periodicos cuya longitud de cadena binaria se encuentra en el
#interior del intervalo conformado por las longitudes de las cadenas binaras de los numeros del intervalo del
#ejercicio.
for i in range(len(l_binary)+1,len(r_binary)):
ans += CountPeriodic(i)
#Chequea la cantidad de numeros periodicos con longitud de cadenas binarias igual a la de los extremos
#del intervalo del ejercicio, en el caso del extremo izquierdo solo se calculan aquellos numeros mayores o
#iguales a "l", y en el caso del derecho los menores o iguales a "r".
if len(l_binary)==len(r_binary):
ans += CountPeriodicR(r_binary)
ans -= CountPeriodicR(l_binary,True)
else:
ans += CountPeriodicL(l_binary)
ans += CountPeriodicR(r_binary)
print(int(ans))
``` |
288_C. Polo the Penguin and XOR operation | Little penguin Polo likes permutations. But most of all he likes permutations of integers from 0 to n, inclusive.
For permutation p = p0, p1, ..., pn, Polo has defined its beauty — number <image>.
Expression <image> means applying the operation of bitwise excluding "OR" to numbers x and y. This operation exists in all modern programming languages, for example, in language C++ and Java it is represented as "^" and in Pascal — as "xor".
Help him find among all permutations of integers from 0 to n the permutation with the maximum beauty.
Input
The single line contains a positive integer n (1 ≤ n ≤ 106).
Output
In the first line print integer m the maximum possible beauty. In the second line print any permutation of integers from 0 to n with the beauty equal to m.
If there are several suitable permutations, you are allowed to print any of them.
Examples
Input
4
Output
20
0 2 1 4 3 | ```python
from bisect import insort,bisect_right,bisect_left
from sys import stdout, stdin, setrecursionlimit
from math import sqrt,ceil,floor,factorial,gcd,log2,log10
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from heapq import heappush, heappop, heapify
from re import *
from os import *
####################################---fast-input-output----#########################################
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
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:
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")
stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
graph, mod, szzz = {}, 10**9 + 7, lambda: sorted(zzz())
def getStr(): return input()
def getInt(): return int(input())
def listStr(): return list(input())
def getStrs(): return input().split()
def isInt(s): return '0' <= s[0] <= '9'
def input(): return stdin.readline().strip()
def zzz(): return [int(i) for i in input().split()]
def output(answer, end='\n'): stdout.write(str(answer) + end)
def lcd(xnum1, xnum2): return (xnum1 * xnum2 // gcd(xnum1, xnum2))
def getPrimes(N = 10**5):
SN = int(sqrt(N))
sieve = [i for i in range(N+1)]
sieve[1] = 0
for i in sieve:
if i > SN:
break
if i == 0:
continue
for j in range(2*i, N+1, i):
sieve[j] = 0
prime = [i for i in range(N+1) if sieve[i] != 0]
return prime
def primeFactor(n,prime=getPrimes()):
lst = []
mx=int(sqrt(n))+1
for i in prime:
if i>mx:break
while n%i==0:
lst.append(i)
n//=i
if n>1:
lst.append(n)
return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
#################################################---Some Rule For Me To Follow---#################################
"""
--instants of Reading problem continuously try to understand them.
--If you Know some-one , Then you probably don't know him !
--Try & again try, maybe you're just one statement away!
"""
##################################################---START-CODING---###############################################
s = n = getInt()+1
lst,new=[],list(range(n))[::-1]
k = 2**20
while s:
while k>=2*s:k//=2
lst=new[n-s:n+s-k]+lst
s=k-s
print(n*(n-1))
for i in lst:
output(i)
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.