index
int64 0
5.16k
| difficulty
int64 7
12
| question
stringlengths 126
7.12k
| solution
stringlengths 30
18.6k
| test_cases
dict |
|---|---|---|---|---|
1,200 | 11 | A superhero fights with a monster. The battle consists of rounds, each of which lasts exactly n minutes. After a round ends, the next round starts immediately. This is repeated over and over again.
Each round has the same scenario. It is described by a sequence of n numbers: d_1, d_2, ..., d_n (-10^6 ≤ d_i ≤ 10^6). The i-th element means that monster's hp (hit points) changes by the value d_i during the i-th minute of each round. Formally, if before the i-th minute of a round the monster's hp is h, then after the i-th minute it changes to h := h + d_i.
The monster's initial hp is H. It means that before the battle the monster has H hit points. Print the first minute after which the monster dies. The monster dies if its hp is less than or equal to 0. Print -1 if the battle continues infinitely.
Input
The first line contains two integers H and n (1 ≤ H ≤ 10^{12}, 1 ≤ n ≤ 2⋅10^5). The second line contains the sequence of integers d_1, d_2, ..., d_n (-10^6 ≤ d_i ≤ 10^6), where d_i is the value to change monster's hp in the i-th minute of a round.
Output
Print -1 if the superhero can't kill the monster and the battle will last infinitely. Otherwise, print the positive integer k such that k is the first minute after which the monster is dead.
Examples
Input
1000 6
-100 -200 -300 125 77 -4
Output
9
Input
1000000000000 5
-1 0 0 0 0
Output
4999999999996
Input
10 4
-3 -6 5 4
Output
-1 | def rint(): return int(input())
def rlist(): return map(int, input().split())
h, n = rlist()
d = list(rlist())
m = 0; s = 0; ans = 0
for c in d:
s += c
m = min(m, s)
if h+m > 0 and s >= 0: print(-1); exit(0)
s = abs(s)
if s: ans = (max(0, h+m) + s - 1) // s
h -= s * ans
ans = ans * n
for c in d:
if h <= 0: break
ans += 1
h += c
print(ans) | {
"input": [
"1000 6\n-100 -200 -300 125 77 -4\n",
"10 4\n-3 -6 5 4\n",
"1000000000000 5\n-1 0 0 0 0\n"
],
"output": [
"9\n",
"-1\n",
"4999999999996\n"
]
} |
1,201 | 10 | You have given tree consist of n vertices. Select a vertex as root vertex that satisfies the condition below.
* For all vertices v_{1} and v_{2}, if distance(root, v_{1}) = distance(root, v_{2}) then degree(v_{1}) = degree(v_{2}), where degree means the number of vertices connected to that vertex, and distance means the number of edges between two vertices.
Determine and find if there is such root vertex in the tree. If there are multiple answers, find any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^{5}) — the number of vertices.
Each of the next n-1 lines contains two integers v_{i} and u_{i} (1 ≤ v_{i} < u_{i} ≤ n) — it means there is an edge exist between v_{i} and u_{i}. It is guaranteed that the graph forms tree.
Output
If there is such root vertex exists, print any of them. Otherwise, print -1.
Examples
Input
7
1 2
2 3
3 4
4 5
3 6
6 7
Output
3
Input
6
1 3
2 3
3 4
4 5
4 6
Output
-1
Note
This is the picture for the first example. 1, 5, 7 also can be a valid answer.
<image>
This is the picture for the second example. You can see that it's impossible to find such root vertex.
<image> | import sys
from collections import Counter
N = int(input())
Edge = [[] for _ in range(N)]
Dim = [0]*N
for _ in range(N-1):
a, b = map(int, sys.stdin.readline().split())
a -= 1
b -= 1
Edge[a].append(b)
Edge[b].append(a)
Dim[a] += 1
Dim[b] += 1
def dfs(x):
dist = [0]*N
stack = [x]
visited = set([x])
for _ in range(N):
vn = stack.pop()
for vf in Edge[vn]:
if vf not in visited:
visited.add(vf)
dist[vf] = 1 + dist[vn]
stack.append(vf)
return dist
def check(i):
dist = dfs(i)
D = [-1]*N
for i in range(N):
if D[dist[i]] == -1:
D[dist[i]] = Dim[i]
elif D[dist[i]] != Dim[i]:
return False
return True
def getpar(Edge, p):
N = len(Edge)
par = [0]*N
par[p] -1
stack = [p]
visited = set([p])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
return par
def solve():
Leaf = [i for i in range(N) if Dim[i] == 1]
dist0 = dfs(0)
md0 = max(dist0)
p1 = dist0.index(md0)
distp1 = dfs(p1)
mdp1 = max(distp1)
p2 = distp1.index(mdp1)
if check(p1):
return p1 + 1
if check(p2):
return p2 + 1
if mdp1 % 2 == 1:
return -1
distp2 = dfs(p2)
for i in range(N):
if distp1[i] == distp2[i] == mdp1//2:
break
cen = i
distcen = dfs(cen)
if check(cen):
return cen + 1
G = [distcen[l] for l in Leaf]
GC = Counter(G)
if len(GC) == 1:
P = getpar(Edge, cen)
for l in Leaf:
k = P[l]
while k != cen:
if Dim[k] != 2:
break
k = P[k]
else:
if check(l):
return l + 1
else:
return -1
return -1
else:
sl = set(Leaf)
for k, v in GC.items():
if v == 1:
for i, d in enumerate(distcen):
if i in sl and d == k:
if check(i):
return i + 1
return -1
print(solve())
| {
"input": [
"6\n1 3\n2 3\n3 4\n4 5\n4 6\n",
"7\n1 2\n2 3\n3 4\n4 5\n3 6\n6 7\n"
],
"output": [
"-1\n",
"3\n"
]
} |
1,202 | 11 | You are organizing a boxing tournament, where n boxers will participate (n is a power of 2), and your friend is one of them. All boxers have different strength from 1 to n, and boxer i wins in the match against boxer j if and only if i is stronger than j.
The tournament will be organized as follows: n boxers will be divided into pairs; the loser in each pair leaves the tournament, and n/2 winners advance to the next stage, where they are divided into pairs again, and the winners in all pairs advance to the next stage, and so on, until only one boxer remains (who is declared the winner).
Your friend really wants to win the tournament, but he may be not the strongest boxer. To help your friend win the tournament, you may bribe his opponents: if your friend is fighting with a boxer you have bribed, your friend wins even if his strength is lower.
Furthermore, during each stage you distribute the boxers into pairs as you wish.
The boxer with strength i can be bribed if you pay him a_i dollars. What is the minimum number of dollars you have to spend to make your friend win the tournament, provided that you arrange the boxers into pairs during each stage as you wish?
Input
The first line contains one integer n (2 ≤ n ≤ 2^{18}) — the number of boxers. n is a power of 2.
The second line contains n integers a_1, a_2, ..., a_n, where a_i is the number of dollars you have to pay if you want to bribe the boxer with strength i. Exactly one of a_i is equal to -1 — it means that the boxer with strength i is your friend. All other values are in the range [1, 10^9].
Output
Print one integer — the minimum number of dollars you have to pay so your friend wins.
Examples
Input
4
3 9 1 -1
Output
0
Input
8
11 -1 13 19 24 7 17 5
Output
12
Note
In the first test case no matter how you will distribute boxers into pairs, your friend is the strongest boxer and anyway wins the tournament.
In the second test case you can distribute boxers as follows (your friend is number 2):
1 : 2, 8 : 5, 7 : 3, 6 : 4 (boxers 2, 8, 7 and 6 advance to the next stage);
2 : 6, 8 : 7 (boxers 2 and 8 advance to the next stage, you have to bribe the boxer with strength 6);
2 : 8 (you have to bribe the boxer with strength 8); | import sys
from heapq import heappop, heappush
from math import log2
# inf = open('input.txt', 'r')
# reader = (map(int, line.split()) for line in inf)
reader = (map(int, s.split()) for s in sys.stdin)
def bribe(n, a):
if a[-1] < 0:
return 0
fr = a.index(-1)
a[fr] = float('inf')
h = int(log2(n))
k = int(log2(fr + 1))
total = a[-1]
hq = []
for r in range(h - 1, k, -1):
[heappush(hq, a[i]) for i in range(2 ** r - 1, 2 ** (r + 1) - 1)];
opponent = heappop(hq)
total += opponent
return total
n, = next(reader)
a = list(next(reader))
ans = bribe(n, a)
print(ans)
# inf.close()
| {
"input": [
"8\n11 -1 13 19 24 7 17 5\n",
"4\n3 9 1 -1\n"
],
"output": [
"12",
"0"
]
} |
1,203 | 11 | We are committed to the well being of all participants. Therefore, instead of the problem, we suggest you enjoy a piece of cake.
Uh oh. Somebody cut the cake. We told them to wait for you, but they did it anyway. There is still some left, though, if you hurry back. Of course, before you taste the cake, you thought about how the cake was cut.
It is known that the cake was originally a regular n-sided polygon, each vertex of which had a unique number from 1 to n. The vertices were numbered in random order.
Each piece of the cake is a triangle. The cake was cut into n - 2 pieces as follows: each time one cut was made with a knife (from one vertex to another) such that exactly one triangular piece was separated from the current cake, and the rest continued to be a convex polygon. In other words, each time three consecutive vertices of the polygon were selected and the corresponding triangle was cut off.
A possible process of cutting the cake is presented in the picture below.
<image> Example of 6-sided cake slicing.
You are given a set of n-2 triangular pieces in random order. The vertices of each piece are given in random order — clockwise or counterclockwise. Each piece is defined by three numbers — the numbers of the corresponding n-sided cake vertices.
For example, for the situation in the picture above, you could be given a set of pieces: [3, 6, 5], [5, 2, 4], [5, 4, 6], [6, 3, 1].
You are interested in two questions.
* What was the enumeration of the n-sided cake vertices?
* In what order were the pieces cut?
Formally, you have to find two permutations p_1, p_2, ..., p_n (1 ≤ p_i ≤ n) and q_1, q_2, ..., q_{n - 2} (1 ≤ q_i ≤ n - 2) such that if the cake vertices are numbered with the numbers p_1, p_2, ..., p_n in order clockwise or counterclockwise, then when cutting pieces of the cake in the order q_1, q_2, ..., q_{n - 2} always cuts off a triangular piece so that the remaining part forms one convex polygon.
For example, in the picture above the answer permutations could be: p=[2, 4, 6, 1, 3, 5] (or any of its cyclic shifts, or its reversal and after that any cyclic shift) and q=[2, 4, 1, 3].
Write a program that, based on the given triangular pieces, finds any suitable permutations p and q.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Then there are t independent sets of input data.
The first line of each set consists of a single integer n (3 ≤ n ≤ 10^5) — the number of vertices in the cake.
The following n - 2 lines describe the numbers of the pieces vertices: each line consists of three different integers a, b, c (1 ≤ a, b, c ≤ n) — the numbers of the pieces vertices of cake given in random order. The pieces are given in random order.
It is guaranteed that the answer to each of the tests exists. It is also guaranteed that the sum of n for all test cases does not exceed 10^5.
Output
Print 2t lines — answers to given t test cases in the order in which they are written in the input. Each answer should consist of 2 lines.
In the first line of an answer on a test case print n distinct numbers p_1, p_2, ..., p_n(1 ≤ p_i ≤ n) — the numbers of the cake vertices in clockwise or counterclockwise order.
In the second line of an answer on a test case print n - 2 distinct numbers q_1, q_2, ..., q_{n - 2}(1 ≤ q_i ≤ n - 2) — the order of cutting pieces of the cake. The number of a piece of the cake corresponds to its number in the input.
If there are several answers, print any. It is guaranteed that the answer to each of the tests exists.
Example
Input
3
6
3 6 5
5 2 4
5 4 6
6 3 1
6
2 5 6
2 5 1
4 1 2
1 3 5
3
1 2 3
Output
1 6 4 2 5 3
4 2 3 1
1 4 2 6 5 3
3 4 2 1
1 3 2
1 | import os
from io import BytesIO
import sys
import threading
sys.setrecursionlimit(10 ** 9)
threading.stack_size(67108864)
def main():
# input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def ad(i, j):
nonlocal g
if j in g[i]:
g[i].remove(j)
g[j].remove(i)
else:
g[i].add(j)
g[j].add(i)
def dfs(v):
nonlocal used, g, nans
used[v] = True
nans.append(v + 1)
for el in g[v]:
if not used[el]:
dfs(el)
for _ in range(int(input())):
n = int(input())
cnt = [set() for i in range(n)]
g = [set() for i in range(n)]
used = [False] * n
triangles = []
for i in range(n - 2):
a, b, c = map(int, input().split())
a -= 1
b -= 1
c -= 1
cnt[a].add(i)
cnt[b].add(i)
cnt[c].add(i)
triangles.append((a, b, c))
ad(a, b)
ad(b, c)
ad(a, c)
q = []
ones = []
for i in range(n):
if len(cnt[i]) == 1:
ones.append(i)
ans = []
nans = []
for i in range(n - 2):
t = ones.pop()
ind = cnt[t].pop()
ans.append(ind + 1)
cnt[triangles[ind][0]].discard(ind)
cnt[triangles[ind][1]].discard(ind)
cnt[triangles[ind][2]].discard(ind)
if len(cnt[triangles[ind][0]]) == 1:
ones.append(triangles[ind][0])
if len(cnt[triangles[ind][1]]) == 1:
ones.append(triangles[ind][1])
if len(cnt[triangles[ind][2]]) == 1:
ones.append(triangles[ind][2])
dfs(0)
print(*nans)
print(*ans)
tt = threading.Thread(target = main)
tt.start() | {
"input": [
"3\n6\n3 6 5\n5 2 4\n5 4 6\n6 3 1\n6\n2 5 6\n2 5 1\n4 1 2\n1 3 5\n3\n1 2 3\n"
],
"output": [
"1 3 5 2 4 6 \n4 2 1 3 \n1 3 5 6 2 4 \n4 3 2 1 \n1 2 3 \n1 \n"
]
} |
1,204 | 11 | You are given a permutation, p_1, p_2, …, p_n.
Imagine that some positions of the permutation contain bombs, such that there exists at least one position without a bomb.
For some fixed configuration of bombs, consider the following process. Initially, there is an empty set, A.
For each i from 1 to n:
* Add p_i to A.
* If the i-th position contains a bomb, remove the largest element in A.
After the process is completed, A will be non-empty. The cost of the configuration of bombs equals the largest element in A.
You are given another permutation, q_1, q_2, …, q_n.
For each 1 ≤ i ≤ n, find the cost of a configuration of bombs such that there exists a bomb in positions q_1, q_2, …, q_{i-1}.
For example, for i=1, you need to find the cost of a configuration without bombs, and for i=n, you need to find the cost of a configuration with bombs in positions q_1, q_2, …, q_{n-1}.
Input
The first line contains a single integer, n (2 ≤ n ≤ 300 000).
The second line contains n distinct integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n).
The third line contains n distinct integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
Output
Print n space-separated integers, such that the i-th of them equals the cost of a configuration of bombs in positions q_1, q_2, …, q_{i-1}.
Examples
Input
3
3 2 1
1 2 3
Output
3 2 1
Input
6
2 3 6 1 5 4
5 2 1 4 6 3
Output
6 5 5 5 4 1
Note
In the first test:
* If there are no bombs, A is equal to \{1, 2, 3\} at the end of the process, so the cost of the configuration is 3.
* If there is one bomb in position 1, A is equal to \{1, 2\} at the end of the process, so the cost of the configuration is 2;
* If there are two bombs in positions 1 and 2, A is equal to \{1\} at the end of the process, so the cost of the configuration is 1.
In the second test:
Let's consider the process for i = 4. There are three bombs on positions q_1 = 5, q_2 = 2, and q_3 = 1.
At the beginning, A = \{\}.
* Operation 1: Add p_1 = 2 to A, so A is equal to \{2\}. There exists a bomb in position 1, so we should delete the largest element from A. A is equal to \{\}.
* Operation 2: Add p_2 = 3 to A, so A is equal to \{3\}. There exists a bomb in position 2, so we should delete the largest element from A. A is equal to \{\}.
* Operation 3: Add p_3 = 6 to A, so A is equal to \{6\}. There is no bomb in position 3, so we do nothing.
* Operation 4: Add p_4 = 1 to A, so A is equal to \{1, 6\}. There is no bomb in position 4, so we do nothing.
* Operation 5: Add p_5 = 5 to A, so A is equal to \{1, 5, 6\}. There exists a bomb in position 5, so we delete the largest element from A. Now, A is equal to \{1, 5\}.
* Operation 6: Add p_6 = 4 to A, so A is equal to \{1, 4, 5\}. There is no bomb in position 6, so we do nothing.
In the end, we have A = \{1, 4, 5\}, so the cost of the configuration is equal to 5. | import sys
input = sys.stdin.readline
N=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))
seg_el=1<<(N.bit_length()) # Segment treeの台の要素数
SEG=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
LAZY=[0]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def indexes(L,R): # 遅延伝搬すべきノードのリストを下から上の順に返す. （つまり, updateやgetvaluesで見るノードより上にあるノードたち）
INDLIST=[]
R-=1
L>>=1
R>>=1
while L!=R:
if L>R:
INDLIST.append(L)
L>>=1
else:
INDLIST.append(R)
R>>=1
while L!=0:
INDLIST.append(L)
L>>=1
return INDLIST
def adds(l,r,x): # 区間[l,r)を +x 更新
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]: # 遅延伝搬. 上から更新していく. （ただし, 今回はうまくやるとこの部分を省ける. addはクエリの順番によらないので. addではなく, updateの場合必要）
if LAZY[ind]!=0:
plus_lazy=LAZY[ind]
SEG[ind<<1]+=plus_lazy
SEG[1+(ind<<1)]+=plus_lazy
LAZY[ind<<1]+=plus_lazy
LAZY[1+(ind<<1)]+=plus_lazy
LAZY[ind]=0
while L!=R:
if L > R:
SEG[L]+=x
LAZY[L]+=x
L+=1
L//=(L & (-L))
else:
R-=1
SEG[R]+=x
LAZY[R]+=x
R//=(R & (-R))
for ind in UPIND:
SEG[ind]=min(SEG[ind<<1],SEG[1+(ind<<1)]) # 最初の遅延伝搬を省いた場合, ここを変える
def getvalues(l,r): # 区間[l,r)に関するminを調べる
L=l+seg_el
R=r+seg_el
L//=(L & (-L))
R//=(R & (-R))
UPIND=indexes(L,R)
for ind in UPIND[::-1]: # 遅延伝搬
if LAZY[ind]!=0:
plus_lazy=LAZY[ind]
SEG[ind<<1]+=plus_lazy
SEG[1+(ind<<1)]+=plus_lazy
LAZY[ind<<1]+=plus_lazy
LAZY[1+(ind<<1)]+=plus_lazy
LAZY[ind]=0
ANS=1<<31
while L!=R:
if L > R:
ANS=min(ANS , SEG[L])
L+=1
L//=(L & (-L))
else:
R-=1
ANS=min(ANS , SEG[R])
R//=(R & (-R))
return ANS
from operator import itemgetter
NOW=0
P_INV=sorted([(p,i) for i,p in enumerate(P)],key=itemgetter(0),reverse=True)
adds(P_INV[NOW][1],N,1)
ANS=[NOW]
for q in Q[:-1]:
adds(q-1,N,-1)
while True:
if getvalues(0,seg_el-1)<getvalues(N-1,N):
ANS.append(NOW)
break
else:
NOW+=1
adds(P_INV[NOW][1],N,1)
#print([getvalues(i,i+1) for i in range(N)],q,NOW)
print(*[N-a for a in ANS])
| {
"input": [
"6\n2 3 6 1 5 4\n5 2 1 4 6 3\n",
"3\n3 2 1\n1 2 3\n"
],
"output": [
"6 5 5 5 4 1 \n",
"3 2 1 \n"
]
} |
1,205 | 11 | Logical quantifiers are very useful tools for expressing claims about a set. For this problem, let's focus on the set of real numbers specifically. The set of real numbers includes zero and negatives. There are two kinds of quantifiers: universal (∀) and existential (∃). You can read more about them here.
The universal quantifier is used to make a claim that a statement holds for all real numbers. For example:
* ∀ x,x<100 is read as: for all real numbers x, x is less than 100. This statement is false.
* ∀ x,x>x-1 is read as: for all real numbers x, x is greater than x-1. This statement is true.
The existential quantifier is used to make a claim that there exists some real number for which the statement holds. For example:
* ∃ x,x<100 is read as: there exists a real number x such that x is less than 100. This statement is true.
* ∃ x,x>x-1 is read as: there exists a real number x such that x is greater than x-1. This statement is true.
Moreover, these quantifiers can be nested. For example:
* ∀ x,∃ y,x<y is read as: for all real numbers x, there exists a real number y such that x is less than y. This statement is true since for every x, there exists y=x+1.
* ∃ y,∀ x,x<y is read as: there exists a real number y such that for all real numbers x, x is less than y. This statement is false because it claims that there is a maximum real number: a number y larger than every x.
Note that the order of variables and quantifiers is important for the meaning and veracity of a statement.
There are n variables x_1,x_2,…,x_n, and you are given some formula of the form $$$ f(x_1,...,x_n):=(x_{j_1}<x_{k_1})∧ (x_{j_2}<x_{k_2})∧ ⋅⋅⋅∧ (x_{j_m}<x_{k_m}), $$$
where ∧ denotes logical AND. That is, f(x_1,…, x_n) is true if every inequality x_{j_i}<x_{k_i} holds. Otherwise, if at least one inequality does not hold, then f(x_1,…,x_n) is false.
Your task is to assign quantifiers Q_1,…,Q_n to either universal (∀) or existential (∃) so that the statement $$$ Q_1 x_1, Q_2 x_2, …, Q_n x_n, f(x_1,…, x_n) $$$
is true, and the number of universal quantifiers is maximized, or determine that the statement is false for every possible assignment of quantifiers.
Note that the order the variables appear in the statement is fixed. For example, if f(x_1,x_2):=(x_1<x_2) then you are not allowed to make x_2 appear first and use the statement ∀ x_2,∃ x_1, x_1<x_2. If you assign Q_1=∃ and Q_2=∀, it will only be interpreted as ∃ x_1,∀ x_2,x_1<x_2.
Input
The first line contains two integers n and m (2≤ n≤ 2⋅ 10^5; 1≤ m≤ 2⋅ 10^5) — the number of variables and the number of inequalities in the formula, respectively.
The next m lines describe the formula. The i-th of these lines contains two integers j_i,k_i (1≤ j_i,k_i≤ n, j_i≠ k_i).
Output
If there is no assignment of quantifiers for which the statement is true, output a single integer -1.
Otherwise, on the first line output an integer, the maximum possible number of universal quantifiers.
On the next line, output a string of length n, where the i-th character is "A" if Q_i should be a universal quantifier (∀), or "E" if Q_i should be an existential quantifier (∃). All letters should be upper-case. If there are multiple solutions where the number of universal quantifiers is maximum, print any.
Examples
Input
2 1
1 2
Output
1
AE
Input
4 3
1 2
2 3
3 1
Output
-1
Input
3 2
1 3
2 3
Output
2
AAE
Note
For the first test, the statement ∀ x_1, ∃ x_2, x_1<x_2 is true. Answers of "EA" and "AA" give false statements. The answer "EE" gives a true statement, but the number of universal quantifiers in this string is less than in our answer.
For the second test, we can show that no assignment of quantifiers, for which the statement is true exists.
For the third test, the statement ∀ x_1, ∀ x_2, ∃ x_3, (x_1<x_3)∧ (x_2<x_3) is true: We can set x_3=max\\{x_1,x_2\}+1. | import sys
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
def from_file(f):
return f.readline
def build_graph(n, A, reversed=False):
edges = [[] for _ in range(n)]
for i, j in A:
i -= 1
j -= 1
if reversed:
j, i = i, j
edges[i].append(j)
return edges
def fill_min(s, edges, visited_dfs, visited, container):
visited[s] = True
visited_dfs.add(s)
for c in edges[s]:
if c in visited_dfs:
# cycle
return -1
if not visited[c]:
res = fill_min(c, edges, visited_dfs, visited, container)
if res == -1:
return -1
container[s] = min(container[s], container[c])
visited_dfs.remove(s)
return 0
def dfs(s, edges, visited, container):
stack = [s]
colors = {s: 0}
while stack:
v = stack.pop()
if colors[v] == 0:
colors[v] = 1
stack.append(v)
else:
# all children are visited
tmp = [container[c] for c in edges[v]]
if tmp:
container[v] = min(min(tmp), container[v])
colors[v] = 2 # finished
visited[v] = True
for c in edges[v]:
if visited[c]:
continue
if c not in colors:
colors[c] = 0 # white
stack.append(c)
elif colors[c] == 1:
# grey
return -1
return 0
def iterate_topologically(n, edges, container):
visited = [False] * n
for s in range(n):
if not visited[s]:
# visited_dfs = set()
# res = fill_min(s, edges, visited_dfs, visited, container)
res = dfs(s, edges, visited, container)
if res == -1:
return -1
return 0
def solve(n, A):
edges = build_graph(n, A, False)
container_forward = list(range(n))
container_backward = list(range(n))
res = iterate_topologically(n, edges, container_forward)
if res == -1:
return None
edges = build_graph(n, A, True)
iterate_topologically(n, edges, container_backward)
container = [min(i,j) for i,j in zip(container_forward, container_backward)]
res = sum((1 if container[i] == i else 0 for i in range(n)))
s = "".join(["A" if container[i] == i else "E" for i in range(n)])
return res, s
# with open('5.txt') as f:
# input = from_file(f)
n, m = invr()
A = []
for _ in range(m):
i, j = invr()
A.append((i, j))
result = solve(n, A)
if not result:
print (-1)
else:
print(f"{result[0]}")
print(f"{result[1]}")
| {
"input": [
"3 2\n1 3\n2 3\n",
"4 3\n1 2\n2 3\n3 1\n",
"2 1\n1 2\n"
],
"output": [
"2\nAAE\n",
"-1\n",
"1\nAE\n"
]
} |
1,206 | 10 | Polycarp wrote on the board a string s containing only lowercase Latin letters ('a'-'z'). This string is known for you and given in the input.
After that, he erased some letters from the string s, and he rewrote the remaining letters in any order. As a result, he got some new string t. You have to find it with some additional information.
Suppose that the string t has length m and the characters are numbered from left to right from 1 to m. You are given a sequence of m integers: b_1, b_2, …, b_m, where b_i is the sum of the distances |i-j| from the index i to all such indices j that t_j > t_i (consider that 'a'<'b'<...<'z'). In other words, to calculate b_i, Polycarp finds all such indices j that the index j contains a letter that is later in the alphabet than t_i and sums all the values |i-j|.
For example, if t = "abzb", then:
* since t_1='a', all other indices contain letters which are later in the alphabet, that is: b_1=|1-2|+|1-3|+|1-4|=1+2+3=6;
* since t_2='b', only the index j=3 contains the letter, which is later in the alphabet, that is: b_2=|2-3|=1;
* since t_3='z', then there are no indexes j such that t_j>t_i, thus b_3=0;
* since t_4='b', only the index j=3 contains the letter, which is later in the alphabet, that is: b_4=|4-3|=1.
Thus, if t = "abzb", then b=[6,1,0,1].
Given the string s and the array b, find any possible string t for which the following two requirements are fulfilled simultaneously:
* t is obtained from s by erasing some letters (possibly zero) and then writing the rest in any order;
* the array, constructed from the string t according to the rules above, equals to the array b specified in the input data.
Input
The first line contains an integer q (1 ≤ q ≤ 100) — the number of test cases in the test. Then q test cases follow.
Each test case consists of three lines:
* the first line contains string s, which has a length from 1 to 50 and consists of lowercase English letters;
* the second line contains positive integer m (1 ≤ m ≤ |s|), where |s| is the length of the string s, and m is the length of the array b;
* the third line contains the integers b_1, b_2, ..., b_m (0 ≤ b_i ≤ 1225).
It is guaranteed that in each test case an answer exists.
Output
Output q lines: the k-th of them should contain the answer (string t) to the k-th test case. It is guaranteed that an answer to each test case exists. If there are several answers, output any.
Example
Input
4
abac
3
2 1 0
abc
1
0
abba
3
1 0 1
ecoosdcefr
10
38 13 24 14 11 5 3 24 17 0
Output
aac
b
aba
codeforces
Note
In the first test case, such strings t are suitable: "aac', "aab".
In the second test case, such trings t are suitable: "a", "b", "c".
In the third test case, only the string t equals to "aba" is suitable, but the character 'b' can be from the second or third position. | from collections import Counter
def solve(t, m, b):
c = Counter(t)
letters = list(sorted(c))
ix = len(letters) - 1
res = [None] * m
solved = 0
while solved < m:
zeros = [i for (i, v) in enumerate(b) if not res[i] and not v]
lz = len(zeros)
while c[letters[ix]] < lz:
ix -= 1
ll = letters[ix]
ix -= 1
for z in zeros:
res[z] = ll
solved += lz
for i in range(m):
if not res[i]:
for z in zeros:
b[i] -= abs(z - i)
return "".join(res)
q = int(input())
for i_q in range(q):
t = input()
m = int(input())
b = list(map(int, input().split(" ")))
print(solve(t, m, b)) | {
"input": [
"4\nabac\n3\n2 1 0\nabc\n1\n0\nabba\n3\n1 0 1\necoosdcefr\n10\n38 13 24 14 11 5 3 24 17 0\n"
],
"output": [
"aac\nc\naba\ncodeforces\n"
]
} |
1,207 | 10 | Captain Fint is involved in another treasure hunt, but have found only one strange problem. The problem may be connected to the treasure's location or may not. That's why captain Flint decided to leave the solving the problem to his crew and offered an absurdly high reward: one day off. The problem itself sounds like this...
There are two arrays a and b of length n. Initially, an ans is equal to 0 and the following operation is defined:
1. Choose position i (1 ≤ i ≤ n);
2. Add a_i to ans;
3. If b_i ≠ -1 then add a_i to a_{b_i}.
What is the maximum ans you can get by performing the operation on each i (1 ≤ i ≤ n) exactly once?
Uncle Bogdan is eager to get the reward, so he is asking your help to find the optimal order of positions to perform the operation on them.
Input
The first line contains the integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of arrays a and b.
The second line contains n integers a_1, a_2, …, a_n (−10^6 ≤ a_i ≤ 10^6).
The third line contains n integers b_1, b_2, …, b_n (1 ≤ b_i ≤ n or b_i = -1).
Additional constraint: it's guaranteed that for any i (1 ≤ i ≤ n) the sequence b_i, b_{b_i}, b_{b_{b_i}}, … is not cyclic, in other words it will always end with -1.
Output
In the first line, print the maximum ans you can get.
In the second line, print the order of operations: n different integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n). The p_i is the position which should be chosen at the i-th step. If there are multiple orders, print any of them.
Examples
Input
3
1 2 3
2 3 -1
Output
10
1 2 3
Input
2
-1 100
2 -1
Output
99
2 1
Input
10
-10 -1 2 2 5 -2 -3 -4 2 -6
-1 -1 2 2 -1 5 5 7 7 9
Output
-9
3 5 6 1 9 4 10 7 8 2 | from collections import deque
n=int(input())
a=list(map(int,input().split()))
b=[int(i)-1 for i in input().split()]
tr=[[] for i in range(n)]
ts=[[] for i in range(n)]
for i in range(n):
if b[i]!=-2:tr[b[i]].append(i)
ans=0
deg=[0 for i in range(n)]
def dfs(i):
q=deque([i])
w=[]
an=0
while q:
x=q.pop()
w.append(x)
for y in tr[x]:
q.append(y)
for i in range(len(w)-1,-1,-1):
x=w[i]
an+=a[x]
if a[x]>=0 and b[x]!=-2:
a[b[x]]+=a[x]
ts[x].append(b[x])
deg[b[x]]+=1
else:
if b[x]!=-2:
ts[b[x]].append(x)
deg[x]+=1
return(an)
for i in range(n):
if b[i]==-2:
ans+=dfs(i)
print(ans)
pos=[]
q=deque([])
for i in range(n):
if deg[i]==0:q.append(i)
while q:
x=q.popleft()
pos.append(x+1)
for y in ts[x]:
deg[y]-=1
if deg[y]==0:
q.append(y)
print(*pos) | {
"input": [
"3\n1 2 3\n2 3 -1\n",
"10\n-10 -1 2 2 5 -2 -3 -4 2 -6\n-1 -1 2 2 -1 5 5 7 7 9\n",
"2\n-1 100\n2 -1\n"
],
"output": [
"10\n1 2 3 \n",
"-9\n3 4 2 9 5 7 10 8 6 1\n",
"99\n2 1\n"
]
} |
1,208 | 8 | You are given four integers a, b, x and y. Initially, a ≥ x and b ≥ y. You can do the following operation no more than n times:
* Choose either a or b and decrease it by one. However, as a result of this operation, value of a cannot become less than x, and value of b cannot become less than y.
Your task is to find the minimum possible product of a and b (a ⋅ b) you can achieve by applying the given operation no more than n times.
You have to answer t independent test cases.
Input
The first line of the input contains one integer t (1 ≤ t ≤ 2 ⋅ 10^4) — the number of test cases. Then t test cases follow.
The only line of the test case contains five integers a, b, x, y and n (1 ≤ a, b, x, y, n ≤ 10^9). Additional constraint on the input: a ≥ x and b ≥ y always holds.
Output
For each test case, print one integer: the minimum possible product of a and b (a ⋅ b) you can achieve by applying the given operation no more than n times.
Example
Input
7
10 10 8 5 3
12 8 8 7 2
12343 43 4543 39 123212
1000000000 1000000000 1 1 1
1000000000 1000000000 1 1 1000000000
10 11 2 1 5
10 11 9 1 10
Output
70
77
177177
999999999000000000
999999999
55
10
Note
In the first test case of the example, you need to decrease b three times and obtain 10 ⋅ 7 = 70.
In the second test case of the example, you need to decrease a one time, b one time and obtain 11 ⋅ 7 = 77.
In the sixth test case of the example, you need to decrease a five times and obtain 5 ⋅ 11 = 55.
In the seventh test case of the example, you need to decrease b ten times and obtain 10 ⋅ 1 = 10. | def f(a,b,x,y):return max(x,a-n)*max(y,b-max(n-a+x,0))
for s in[*open(0)][1:]:a,b,x,y,n=map(int,s.split());print(min(f(a,b,x,y),f(b,a,y,x))) | {
"input": [
"7\n10 10 8 5 3\n12 8 8 7 2\n12343 43 4543 39 123212\n1000000000 1000000000 1 1 1\n1000000000 1000000000 1 1 1000000000\n10 11 2 1 5\n10 11 9 1 10\n"
],
"output": [
"70\n77\n177177\n999999999000000000\n999999999\n55\n10\n"
]
} |
1,209 | 8 | Gildong has an interesting machine that has an array a with n integers. The machine supports two kinds of operations:
1. Increase all elements of a suffix of the array by 1.
2. Decrease all elements of a suffix of the array by 1.
A suffix is a subsegment (contiguous elements) of the array that contains a_n. In other words, for all i where a_i is included in the subsegment, all a_j's where i < j ≤ n must also be included in the subsegment.
Gildong wants to make all elements of a equal — he will always do so using the minimum number of operations necessary. To make his life even easier, before Gildong starts using the machine, you have the option of changing one of the integers in the array to any other integer. You are allowed to leave the array unchanged. You want to minimize the number of operations Gildong performs. With your help, what is the minimum number of operations Gildong will perform?
Note that even if you change one of the integers in the array, you should not count that as one of the operations because Gildong did not perform it.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains two lines. The first line of each test case consists of an integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements of the array a.
The second line of each test case contains n integers. The i-th integer is a_i (-5 ⋅ 10^8 ≤ a_i ≤ 5 ⋅ 10^8).
It is guaranteed that the sum of n in all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print one integer — the minimum number of operations Gildong has to perform in order to make all elements of the array equal.
Example
Input
7
2
1 1
3
-1 0 2
4
99 96 97 95
4
-3 -5 -2 1
6
1 4 3 2 4 1
5
5 0 0 0 5
9
-367741579 319422997 -415264583 -125558838 -300860379 420848004 294512916 -383235489 425814447
Output
0
1
3
4
6
5
2847372102
Note
In the first case, all elements of the array are already equal. Therefore, we do not change any integer and Gildong will perform zero operations.
In the second case, we can set a_3 to be 0, so that the array becomes [-1,0,0]. Now Gildong can use the 2-nd operation once on the suffix starting at a_2, which means a_2 and a_3 are decreased by 1, making all elements of the array -1.
In the third case, we can set a_1 to 96, so that the array becomes [96,96,97,95]. Now Gildong needs to:
* Use the 2-nd operation on the suffix starting at a_3 once, making the array [96,96,96,94].
* Use the 1-st operation on the suffix starting at a_4 2 times, making the array [96,96,96,96].
In the fourth case, we can change the array into [-3,-3,-2,1]. Now Gildong needs to:
* Use the 2-nd operation on the suffix starting at a_4 3 times, making the array [-3,-3,-2,-2].
* Use the 2-nd operation on the suffix starting at a_3 once, making the array [-3,-3,-3,-3]. |
def readline():
return map(int,input().split())
if __name__ == "__main__":
#code goes below
for _ in range(int(input())):
n=int(input())
a=[0]+list(readline())
ans=0
for i in range(2,n+1):
ans+=abs(a[i]-a[i-1])
mx=max(abs(a[2]-a[1]),abs(a[n]-a[n-1]))
for i in range(2,n):
mx=max(mx,abs(a[i]-a[i-1])+abs(a[i+1]-a[i])-abs(a[i+1]-a[i-1]))
print(ans-mx) | {
"input": [
"7\n2\n1 1\n3\n-1 0 2\n4\n99 96 97 95\n4\n-3 -5 -2 1\n6\n1 4 3 2 4 1\n5\n5 0 0 0 5\n9\n-367741579 319422997 -415264583 -125558838 -300860379 420848004 294512916 -383235489 425814447\n"
],
"output": [
"\n0\n1\n3\n4\n6\n5\n2847372102\n"
]
} |
1,210 | 10 | There is a deck of n cards. The i-th card has a number a_i on the front and a number b_i on the back. Every integer between 1 and 2n appears exactly once on the cards.
A deck is called sorted if the front values are in increasing order and the back values are in decreasing order. That is, if a_i< a_{i+1} and b_i> b_{i+1} for all 1≤ i<n.
To flip a card i means swapping the values of a_i and b_i. You must flip some subset of cards (possibly, none), then put all the cards in any order you like. What is the minimum number of cards you must flip in order to sort the deck?
Input
The first line contains a single integer n (1≤ n≤ 2⋅ 10^5) — the number of cards.
The next n lines describe the cards. The i-th of these lines contains two integers a_i, b_i (1≤ a_i, b_i≤ 2n). Every integer between 1 and 2n appears exactly once.
Output
If it is impossible to sort the deck, output "-1". Otherwise, output the minimum number of flips required to sort the deck.
Examples
Input
5
3 10
6 4
1 9
5 8
2 7
Output
2
Input
2
1 2
3 4
Output
-1
Input
3
1 2
3 6
4 5
Output
-1
Note
In the first test case, we flip the cards (1, 9) and (2, 7). The deck is then ordered (3,10), (5,8), (6,4), (7,2), (9,1). It is sorted because 3<5<6<7<9 and 10>8>4>2>1.
In the second test case, it is impossible to sort the deck. | import sys,io,os
try:Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
except:Z=lambda:sys.stdin.readline().encode()
def sol(n,d,F):
L=[[0]*(n+2),[0]*(n+2)];L[0][-1]=L[1][0]=2*n+1
q=[1];nq=[];m=g=f=t=0;l=1;h=n+1;u=[0]*(2*n+1);u[1]=1;p=1
while l!=h:
if not q:
t+=min(f,g-f)
f=g=m=0
while u[p]:p+=1
q=[p];u[p]=1
else:
while q:
v=q.pop();g+=1;f+=F[v];u[d[v]]=1
if m:
if L[0][h-1]!=0:return -1
L[0][h-1]=v;L[1][h-1]=d[v]
if v>L[0][h] or d[v]<L[1][h]:return -1
for i in range(L[1][h]+1,d[v]):
if not u[i]:nq.append(i);u[i]=1
h-=1
else:
if L[0][l]!=0:return -1
L[0][l]=v;L[1][l]=d[v]
if v<L[0][l-1] or d[v]>L[1][l-1]:return -1
for i in range(L[1][l-1]-1,d[v],-1):
if not u[i]:nq.append(i);u[i]=1
l+=1
m,q,nq=1-m,nq[::-1],[]
for i in range(1,n+2):
if L[0][i]<L[0][i-1] or L[1][i]>L[1][i-1]:return -1
return t+min(f,g-f)
n=int(Z());d=[0]*(2*n+1);F=[0]*(2*n+1)
for _ in range(n):a,b=map(int,Z().split());d[a]=b;d[b]=a;F[a]=1
print(sol(n,d,F)) | {
"input": [
"2\n1 2\n3 4\n",
"3\n1 2\n3 6\n4 5\n",
"5\n3 10\n6 4\n1 9\n5 8\n2 7\n"
],
"output": [
"\n-1\n",
"\n-1\n",
"\n2\n"
]
} |
1,211 | 8 | The only difference between the easy and hard versions is that the given string s in the easy version is initially a palindrome, this condition is not always true for the hard version.
A palindrome is a string that reads the same left to right and right to left. For example, "101101" is a palindrome, while "0101" is not.
Alice and Bob are playing a game on a string s of length n consisting of the characters '0' and '1'. Both players take alternate turns with Alice going first.
In each turn, the player can perform one of the following operations:
1. Choose any i (1 ≤ i ≤ n), where s[i] = '0' and change s[i] to '1'. Pay 1 dollar.
2. Reverse the whole string, pay 0 dollars. This operation is only allowed if the string is currently not a palindrome, and the last operation was not reverse. That is, if Alice reverses the string, then Bob can't reverse in the next move, and vice versa.
Reversing a string means reordering its letters from the last to the first. For example, "01001" becomes "10010" after reversing.
The game ends when every character of string becomes '1'. The player who spends minimum dollars till this point wins the game and it is a draw if both spend equal dollars. If both players play optimally, output whether Alice wins, Bob wins, or if it is a draw.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^3). Then t test cases follow.
The first line of each test case contains a single integer n (1 ≤ n ≤ 10^3).
The second line of each test case contains the string s of length n, consisting of the characters '0' and '1'. It is guaranteed that the string s contains at least one '0'.
Note that there is no limit on the sum of n over test cases.
Output
For each test case print a single word in a new line:
* "ALICE", if Alice will win the game,
* "BOB", if Bob will win the game,
* "DRAW", if the game ends in a draw.
Example
Input
3
3
110
2
00
4
1010
Output
ALICE
BOB
ALICE
Note
In the first test case of example,
* in the 1-st move, Alice will use the 2-nd operation to reverse the string, since doing the 1-st operation will result in her loss anyway. This also forces Bob to use the 1-st operation.
* in the 2-nd move, Bob has to perform the 1-st operation, since the 2-nd operation cannot be performed twice in a row. All characters of the string are '1', game over.
Alice spends 0 dollars while Bob spends 1 dollar. Hence, Alice wins.
In the second test case of example,
* in the 1-st move Alice has to perform the 1-st operation, since the string is currently a palindrome.
* in the 2-nd move Bob reverses the string.
* in the 3-rd move Alice again has to perform the 1-st operation. All characters of the string are '1', game over.
Alice spends 2 dollars while Bob spends 0 dollars. Hence, Bob wins. | def palin(s):
for i in range((len(s)+1)//2):
if (s[i] != s[len(s)-i-1]):
return False
return True
t = int(input())
for _ in range(t):
n = int(input())
s = input()
a = s.count('0')
if (palin(s)):
if (a%2 == 0):
print("BOB")
else:
if a == 1:
print("BOB")
else:
print("ALICE")
else:
if (a == 2 and len(s)%2 == 1 and s[len(s)//2] == '0'):
print("DRAW")
else:
print("ALICE")
| {
"input": [
"3\n3\n110\n2\n00\n4\n1010\n"
],
"output": [
"\nALICE\nBOB\nALICE\n"
]
} |
1,212 | 7 | Polycarpus has a hobby — he develops an unusual social network. His work is almost completed, and there is only one more module to implement — the module which determines friends. Oh yes, in this social network one won't have to add friends manually! Pairs of friends are deduced in the following way. Let's assume that user A sent user B a message at time t1, and user B sent user A a message at time t2. If 0 < t2 - t1 ≤ d, then user B's message was an answer to user A's one. Users A and B are considered to be friends if A answered at least one B's message or B answered at least one A's message.
You are given the log of messages in chronological order and a number d. Find all pairs of users who will be considered to be friends.
Input
The first line of the input contains two integers n and d (1 ≤ n, d ≤ 1000). The next n lines contain the messages log. The i-th line contains one line of the log formatted as "Ai Bi ti" (without the quotes), which means that user Ai sent a message to user Bi at time ti (1 ≤ i ≤ n). Ai and Bi are non-empty strings at most 20 characters long, consisting of lowercase letters ('a' ... 'z'), and ti is an integer (0 ≤ ti ≤ 10000). It is guaranteed that the lines are given in non-decreasing order of ti's and that no user sent a message to himself. The elements in the lines are separated by single spaces.
Output
In the first line print integer k — the number of pairs of friends. In the next k lines print pairs of friends as "Ai Bi" (without the quotes). You can print users in pairs and the pairs themselves in any order. Each pair must be printed exactly once.
Examples
Input
4 1
vasya petya 1
petya vasya 2
anya ivan 2
ivan anya 4
Output
1
petya vasya
Input
1 1000
a b 0
Output
0
Note
In the first sample test case Vasya and Petya are friends because their messages' sending times are one second apart. Anya and Ivan are not, because their messages' sending times differ by more than one second. | def readln(): return tuple(map(int, input().split()))
n, d = readln()
a = []
b = []
for _ in range(n):
p, q, t = input().split()
t = int(t)
if p > q:
a.append((p, q, t))
else:
b.append((q, p, t))
ans = set()
for p, q, t in a:
for p1, q1, t1 in b:
if p == p1 and q == q1 and 0 < abs(t - t1) <= d:
ans.add(p + ' ' + q)
print(len(ans))
print('\n'.join(ans))
| {
"input": [
"1 1000\na b 0\n",
"4 1\nvasya petya 1\npetya vasya 2\nanya ivan 2\nivan anya 4\n"
],
"output": [
"0\n",
"1\npetya vasya\n"
]
} |
1,213 | 10 | The Smart Beaver from ABBYY loves puzzles. One of his favorite puzzles is the magic square. He has recently had an idea to automate the solution of this puzzle. The Beaver decided to offer this challenge to the ABBYY Cup contestants.
The magic square is a matrix of size n × n. The elements of this matrix are integers. The sum of numbers in each row of the matrix is equal to some number s. The sum of numbers in each column of the matrix is also equal to s. In addition, the sum of the elements on the main diagonal is equal to s and the sum of elements on the secondary diagonal is equal to s. Examples of magic squares are given in the following figure:
<image> Magic squares
You are given a set of n2 integers ai. It is required to place these numbers into a square matrix of size n × n so that they form a magic square. Note that each number must occur in the matrix exactly the same number of times as it occurs in the original set.
It is guaranteed that a solution exists!
Input
The first input line contains a single integer n. The next line contains n2 integers ai ( - 108 ≤ ai ≤ 108), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 3
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 4
* It is guaranteed that there are no more than 9 distinct numbers among ai.
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 4
Output
The first line of the output should contain a single integer s. In each of the following n lines print n integers, separated by spaces and describing the resulting magic square. In the resulting magic square the sums in the rows, columns and diagonals must be equal to s. If there are multiple solutions, you are allowed to print any of them.
Examples
Input
3
1 2 3 4 5 6 7 8 9
Output
15
2 7 6
9 5 1
4 3 8
Input
3
1 0 -1 0 2 -1 -2 0 1
Output
0
1 0 -1
-2 0 2
1 0 -1
Input
2
5 5 5 5
Output
10
5 5
5 5 | import sys, random
def f(b):
global a
a = [[0] * n for o in range(n)]
for i in range(n):
for j in range(n):
a[i][j] = b[i * n + j]
rez = 0
for i in range(n):
ns = 0
for j in range(n):
ns += a[i][j]
rez += abs(su - ns)
for j in range(n):
ns = 0
for i in range(n):
ns += a[i][j]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][i]
rez += abs(su - ns)
ns = 0
for i in range(n):
ns += a[i][n - i - 1]
rez += abs(su - ns)
return rez
input = sys.stdin.readline
n = int(input())
d = list(map(int, input().split()))
su = sum(d) // n
p = f(d)
while p:
random.shuffle(d)
p = f(d)
for k in range(1000):
i = random.randint(0, n*n-1)
j = random.randint(0, n*n-1)
while i == j:
j = random.randint(0, n*n-1)
if i > j:
i, j = j, i
d[i], d[j] = d[j], d[i]
q = f(d)
if q < p:
p = q
else:
d[i], d[j] = d[j], d[i]
p = f(d)
print(su)
for i in a:
print(*i)
| {
"input": [
"2\n5 5 5 5\n",
"3\n1 0 -1 0 2 -1 -2 0 1\n",
"3\n1 2 3 4 5 6 7 8 9\n"
],
"output": [
"10\n5 5 \n5 5 \n",
"0\n-1 0 1\n2 0 -2\n-1 0 1\n",
"15\n2 7 6\n9 5 1\n4 3 8\n"
]
} |
1,214 | 10 | Recently, Valery have come across an entirely new programming language. Most of all the language attracted him with template functions and procedures. Let us remind you that templates are tools of a language, designed to encode generic algorithms, without reference to some parameters (e.g., data types, buffer sizes, default values).
Valery decided to examine template procedures in this language in more detail. The description of a template procedure consists of the procedure name and the list of its parameter types. The generic type T parameters can be used as parameters of template procedures.
A procedure call consists of a procedure name and a list of variable parameters. Let's call a procedure suitable for this call if the following conditions are fulfilled:
* its name equals to the name of the called procedure;
* the number of its parameters equals to the number of parameters of the procedure call;
* the types of variables in the procedure call match the corresponding types of its parameters. The variable type matches the type of a parameter if the parameter has a generic type T or the type of the variable and the parameter are the same.
You are given a description of some set of template procedures. You are also given a list of variables used in the program, as well as direct procedure calls that use the described variables. For each call you need to count the number of procedures that are suitable for this call.
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of template procedures. The next n lines contain the description of the procedures specified in the following format:
"void procedureName (type_1, type_2, ..., type_t)" (1 ≤ t ≤ 5), where void is the keyword, procedureName is the procedure name, type_i is the type of the next parameter. Types of language parameters can be "int", "string", "double", and the keyword "T", which denotes the generic type.
The next line contains a single integer m (1 ≤ m ≤ 1000) — the number of used variables. Next m lines specify the description of the variables in the following format:
"type variableName", where type is the type of variable that can take values "int", "string", "double", variableName — the name of the variable.
The next line contains a single integer k (1 ≤ k ≤ 1000) — the number of procedure calls. Next k lines specify the procedure calls in the following format:
"procedureName (var_1, var_2, ..., var_t)" (1 ≤ t ≤ 5), where procedureName is the name of the procedure, var_i is the name of a variable.
The lines describing the variables, template procedures and their calls may contain spaces at the beginning of the line and at the end of the line, before and after the brackets and commas. Spaces may be before and after keyword void. The length of each input line does not exceed 100 characters. The names of variables and procedures are non-empty strings of lowercase English letters and numbers with lengths of not more than 10 characters. Note that this is the only condition at the names. Only the specified variables are used in procedure calls. The names of the variables are distinct. No two procedures are the same. Two procedures are the same, if they have identical names and identical ordered sets of types of their parameters.
Output
On each of k lines print a single number, where the i-th number stands for the number of suitable template procedures for the i-th call.
Examples
Input
4
void f(int,T)
void f(T, T)
void foo123 ( int, double, string,string )
void p(T,double)
3
int a
string s
double x123
5
f(a, a)
f(s,a )
foo (a,s,s)
f ( s ,x123)
proc(a)
Output
2
1
0
1
0
Input
6
void f(string,double,int)
void f(int)
void f ( T )
void procedure(int,double)
void f (T, double,int)
void f(string, T,T)
4
int a
int x
string t
double val
5
f(t, a, a)
f(t,val,a)
f(val,a, val)
solve300(val, val)
f (x)
Output
1
3
0
0
2 | I=input
R=str.replace
P=range
D=lambda:P(int(I()))
T={}
d={}
def rf(s):
print(s.split())
for _ in D():s=R(R(I(),'void',''),' ','');t=s.find('(');k=s[:t];d[k]=d.get(k,[])+[s[t+1:-1].split(',')]
for _ in D():a,b=I().split();T[b]=a
for _ in D():
s=R(I(),' ','');t=s.find('(');s,v=s[:t],s[t+1:-1].split(',');r=0
for p in d.get(s,[]):
if len(v)==len(p):
for i in P(len(v)):
if p[i]!='T'and p[i]!=T[v[i]]:break
else:r+=1
print(r) | {
"input": [
"6\nvoid f(string,double,int)\nvoid f(int)\n void f ( T )\nvoid procedure(int,double)\nvoid f (T, double,int) \nvoid f(string, T,T)\n4\n int a\n int x\nstring t\ndouble val \n5\nf(t, a, a)\nf(t,val,a)\nf(val,a, val)\n solve300(val, val)\nf (x)\n",
"4\nvoid f(int,T)\nvoid f(T, T)\n void foo123 ( int, double, string,string ) \n void p(T,double)\n3\nint a\n string s\ndouble x123 \n5\nf(a, a)\n f(s,a )\nfoo (a,s,s)\n f ( s ,x123)\nproc(a)\n"
],
"output": [
"1\n3\n0\n0\n2\n",
"2\n1\n0\n1\n0\n"
]
} |
1,215 | 9 | You've got an n × m pixel picture. Each pixel can be white or black. Your task is to change the colors of as few pixels as possible to obtain a barcode picture.
A picture is a barcode if the following conditions are fulfilled:
* All pixels in each column are of the same color.
* The width of each monochrome vertical line is at least x and at most y pixels. In other words, if we group all neighbouring columns of the pixels with equal color, the size of each group can not be less than x or greater than y.
Input
The first line contains four space-separated integers n, m, x and y (1 ≤ n, m, x, y ≤ 1000; x ≤ y).
Then follow n lines, describing the original image. Each of these lines contains exactly m characters. Character "." represents a white pixel and "#" represents a black pixel. The picture description doesn't have any other characters besides "." and "#".
Output
In the first line print the minimum number of pixels to repaint. It is guaranteed that the answer exists.
Examples
Input
6 5 1 2
##.#.
.###.
###..
#...#
.##.#
###..
Output
11
Input
2 5 1 1
#####
.....
Output
5
Note
In the first test sample the picture after changing some colors can looks as follows:
.##..
.##..
.##..
.##..
.##..
.##..
In the second test sample the picture after changing some colors can looks as follows:
.#.#.
.#.#.
| def mem(ind,cnt,f):
if(ind == m):
if(cnt >= x): return 0
else: return 1e18
if(dp[ind][cnt][f] != -1): return dp[ind][cnt][f]
ans = 1e18
if(f == 0):
val = n-ct[ind]
else:
val = ct[ind]
if(cnt >= x):
ans = min(ans,mem(ind+1,1,f^1)+n-val)
if(cnt < y):
ans = min(ans,mem(ind+1,cnt+1,f)+val)
dp[ind][cnt][f] = ans
return dp[ind][cnt][f]
n,m,x,y = map(int,input().split())
s = []
for i in range(n):
s.append(input())
dp = [[[-1,-1] for i in range(y+1)] for j in range(m)]
ct = [0 for i in range(m)]
for i in range(n):
for j in range(m):
if(s[i][j] == '.'):
ct[j] += 1
print(min(mem(0,0,0),mem(0,0,1)))
| {
"input": [
"6 5 1 2\n##.#.\n.###.\n###..\n#...#\n.##.#\n###..\n",
"2 5 1 1\n#####\n.....\n"
],
"output": [
"11",
"5"
]
} |
1,216 | 7 | Nowadays the one-way traffic is introduced all over the world in order to improve driving safety and reduce traffic jams. The government of Berland decided to keep up with new trends. Formerly all n cities of Berland were connected by n two-way roads in the ring, i. e. each city was connected directly to exactly two other cities, and from each city it was possible to get to any other city. Government of Berland introduced one-way traffic on all n roads, but it soon became clear that it's impossible to get from some of the cities to some others. Now for each road is known in which direction the traffic is directed at it, and the cost of redirecting the traffic. What is the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other?
Input
The first line contains integer n (3 ≤ n ≤ 100) — amount of cities (and roads) in Berland. Next n lines contain description of roads. Each road is described by three integers ai, bi, ci (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ ci ≤ 100) — road is directed from city ai to city bi, redirecting the traffic costs ci.
Output
Output single integer — the smallest amount of money the government should spend on the redirecting of roads so that from every city you can get to any other.
Examples
Input
3
1 3 1
1 2 1
3 2 1
Output
1
Input
3
1 3 1
1 2 5
3 2 1
Output
2
Input
6
1 5 4
5 3 8
2 4 15
1 6 16
2 3 23
4 6 42
Output
39
Input
4
1 2 9
2 3 8
3 4 7
4 1 5
Output
0 | A = set()
B = set()
cost1 = 0
cost2 = 0
def swap(a,b):
a,b = b,a
return a,b
n = int(input())
for i in range(n):
a,b,c = map(int,input().split())
if (a in A) or (b in B):
a,b = swap(a,b)
cost1 += c
else:
cost2 += c
A.add(a)
B.add(b)
print(min(cost1,cost2)) | {
"input": [
"3\n1 3 1\n1 2 1\n3 2 1\n",
"3\n1 3 1\n1 2 5\n3 2 1\n",
"6\n1 5 4\n5 3 8\n2 4 15\n1 6 16\n2 3 23\n4 6 42\n",
"4\n1 2 9\n2 3 8\n3 4 7\n4 1 5\n"
],
"output": [
"1\n",
"2\n",
"39\n",
"0\n"
]
} |
1,217 | 8 | A tree is a graph with n vertices and exactly n - 1 edges; this graph should meet the following condition: there exists exactly one shortest (by number of edges) path between any pair of its vertices.
A subtree of a tree T is a tree with both vertices and edges as subsets of vertices and edges of T.
You're given a tree with n vertices. Consider its vertices numbered with integers from 1 to n. Additionally an integer is written on every vertex of this tree. Initially the integer written on the i-th vertex is equal to vi. In one move you can apply the following operation:
1. Select the subtree of the given tree that includes the vertex with number 1.
2. Increase (or decrease) by one all the integers which are written on the vertices of that subtree.
Calculate the minimum number of moves that is required to make all the integers written on the vertices of the given tree equal to zero.
Input
The first line of the input contains n (1 ≤ n ≤ 105). Each of the next n - 1 lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi) indicating there's an edge between vertices ai and bi. It's guaranteed that the input graph is a tree.
The last line of the input contains a list of n space-separated integers v1, v2, ..., vn (|vi| ≤ 109).
Output
Print the minimum number of operations needed to solve the task.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
1 2
1 3
1 -1 1
Output
3 | from collections import defaultdict
from sys import stdin,setrecursionlimit
setrecursionlimit(10**6)
import threading
def dfs(g,node,parent,cr,req):
l=[0,0]
for i in g[node]:
if i!=parent:
t=dfs(g,i,node,cr,req)
# print(t)
l[0]=max(t[0],l[0])
l[1]=max(t[1],l[1])
if l[0]-l[1]<=req[node]:
l[0]+=req[node]-(l[0]-l[1])
else:
l[1]+=(l[0]-l[1])-req[node]
# print(l)
return l
def main():
n=int(input())
g=defaultdict(list)
for i in range(n-1):
a,b=map(int,input().strip().split())
g[a-1].append(b-1)
g[b-1].append(a-1)
req=list(map(int,input().strip().split()))
cr=[0]
#fol incre and decre
x=dfs(g,0,-1,cr,req)
print(sum(x))
threading.stack_size(10 ** 8)
t = threading.Thread(target=main)
t.start()
t.join() | {
"input": [
"3\n1 2\n1 3\n1 -1 1\n"
],
"output": [
"3\n"
]
} |
1,218 | 8 | 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 ≤ 100). 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 | n=int(input())
intervals={}
idx=0
adj={}
def is_path(s,e):
if s==e:
return True
vis[s]=1
for i in adj[s]:
if not vis[i]:
if is_path(i,e):
return True
return False
for i in range(n):
a,b,c=map(int,input().split())
if a==1:
idx+=1
adj[idx]=[]
for j in intervals:
(d,e)=intervals[j]
if d<b<e or d<c<e:
adj[idx].append(j)
if b<d<c or b<e<c:
adj[j].append(idx)
intervals[idx]=(b,c)
else:
vis=[0]*101
if is_path(b,c):
print("YES")
else:
print("NO")
| {
"input": [
"5\n1 1 5\n1 5 11\n2 1 2\n1 2 9\n2 1 2\n"
],
"output": [
"NO\nYES\n"
]
} |
1,219 | 10 | 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 | 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()]
hash_map = {}
def hash_elem(elem):
if hash_map.get(elem, -1) == -1:
if elem < 1000:
hash_map[elem] = elem//2 + elem * 1134234546677 + int(elem/3) + int(elem**2) + elem<<2 + elem>>7 + int(log(elem)) + int(sqrt(elem)) + elem&213213 + elem^324234211323 + elem|21319423094023
else:
hash_map[elem] = 3 + elem^34# elem<<2 + elem>>7 + elem&243 + elem^324 + elem|434
return elem + hash_map[elem]
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]
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]))
| {
"input": [
"5 3 1\n1 2 3 2 1\n1 2 3\n",
"6 3 2\n1 3 2 2 3 1\n1 2 3\n"
],
"output": [
"2\n1 3 ",
"2\n1 2 "
]
} |
1,220 | 10 | The employees of the R1 company often spend time together: they watch football, they go camping, they solve contests. So, it's no big deal that sometimes someone pays for someone else.
Today is the day of giving out money rewards. The R1 company CEO will invite employees into his office one by one, rewarding each one for the hard work this month. The CEO knows who owes money to whom. And he also understands that if he invites person x to his office for a reward, and then immediately invite person y, who has lent some money to person x, then they can meet. Of course, in such a situation, the joy of person x from his brand new money reward will be much less. Therefore, the R1 CEO decided to invite the staff in such an order that the described situation will not happen for any pair of employees invited one after another.
However, there are a lot of employees in the company, and the CEO doesn't have a lot of time. Therefore, the task has been assigned to you. Given the debt relationships between all the employees, determine in which order they should be invited to the office of the R1 company CEO, or determine that the described order does not exist.
Input
The first line contains space-separated integers n and m <image> — the number of employees in R1 and the number of debt relations. Each of the following m lines contains two space-separated integers ai, bi (1 ≤ ai, bi ≤ n; ai ≠ bi), these integers indicate that the person number ai owes money to a person a number bi. Assume that all the employees are numbered from 1 to n.
It is guaranteed that each pair of people p, q is mentioned in the input data at most once. In particular, the input data will not contain pairs p, q and q, p simultaneously.
Output
Print -1 if the described order does not exist. Otherwise, print the permutation of n distinct integers. The first number should denote the number of the person who goes to the CEO office first, the second number denote the person who goes second and so on.
If there are multiple correct orders, you are allowed to print any of them.
Examples
Input
2 1
1 2
Output
2 1
Input
3 3
1 2
2 3
3 1
Output
2 1 3 | n,m=map(int,input().split())
graph=[]
from sys import *
for _ in range(0,n+2):
graph.append([])
for _ in range(0,m):
a,b=map(int,stdin.readline().split())
graph[b].append(a)
vis=[0]*(n+2)
f=[]
def topo(start):
global f
vis[start]=1
s=[start]
ans=[]
while s:
temp=s[-1]
vis[temp]=1
for i in graph[temp]:
if vis[i]==0:
s.append(i)
break
else:
f.append(s.pop())
#f=f+ans
for i in range(1,n+1):
if vis[i]==0:
topo(i)
f.reverse()
for i in f:
print (i,end=" ") | {
"input": [
"2 1\n1 2\n",
"3 3\n1 2\n2 3\n3 1\n"
],
"output": [
"2 1 ",
"3 2 1 "
]
} |
1,221 | 7 | One day Vasya decided to have a look at the results of Berland 1910 Football Championship’s finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are n lines in that description each of which described one goal. Every goal was marked with the name of the team that had scored it. Help Vasya, learn the name of the team that won the finals. It is guaranteed that the match did not end in a tie.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of lines in the description. Then follow n lines — for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match did not end in a tie and the description contains no more than two different teams.
Output
Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner.
Examples
Input
1
ABC
Output
ABC
Input
5
A
ABA
ABA
A
A
Output
A | n,l=int(input()),[]
def m(L):
return max(set(L), key = L.count)
l=[input() for _ in range(n)]
print(m(l)) | {
"input": [
"1\nABC\n",
"5\nA\nABA\nABA\nA\nA\n"
],
"output": [
"ABC\n",
"A\n"
]
} |
1,222 | 9 | Appleman has a very big sheet of paper. This sheet has a form of rectangle with dimensions 1 × n. Your task is help Appleman with folding of such a sheet. Actually, you need to perform q queries. Each query will have one of the following types:
1. Fold the sheet of paper at position pi. After this query the leftmost part of the paper with dimensions 1 × pi must be above the rightmost part of the paper with dimensions 1 × ([current width of sheet] - pi).
2. Count what is the total width of the paper pieces, if we will make two described later cuts and consider only the pieces between the cuts. We will make one cut at distance li from the left border of the current sheet of paper and the other at distance ri from the left border of the current sheet of paper.
Please look at the explanation of the first test example for better understanding of the problem.
Input
The first line contains two integers: n and q (1 ≤ n ≤ 105; 1 ≤ q ≤ 105) — the width of the paper and the number of queries.
Each of the following q lines contains one of the described queries in the following format:
* "1 pi" (1 ≤ pi < [current width of sheet]) — the first type query.
* "2 li ri" (0 ≤ li < ri ≤ [current width of sheet]) — the second type query.
Output
For each query of the second type, output the answer.
Examples
Input
7 4
1 3
1 2
2 0 1
2 1 2
Output
4
3
Input
10 9
2 2 9
1 1
2 0 1
1 8
2 0 8
1 2
2 1 3
1 4
2 2 4
Output
7
2
10
4
5
Note
The pictures below show the shapes of the paper during the queries of the first example:
<image>
After the first fold operation the sheet has width equal to 4, after the second one the width of the sheet equals to 2. | from itertools import starmap
def main():
n, q = map(int, input().split())
a = list(range(n + 1))
flipped = False
start = 0
end = n
for _ in range(q):
cmd, *args = map(int, input().split())
if cmd == 1:
p = args[0]
if p > end-start-p:
flipped = not flipped
p = end-start-p
if flipped:
a[end-p:end-2*p:-1] = starmap(
lambda a, b: a+n-b,
zip(a[end-p:end-2*p:-1], a[end-p:end])
)
end -= p
else:
start += p
a[start:start+p] = starmap(
lambda a, b: a-b,
zip(a[start:start+p], a[start:start-p:-1])
)
else:
l, r = args
if flipped:
l, r = end-start-r, end-start-l
print(a[start + r] - a[start + l])
if __name__ == '__main__':
main()
| {
"input": [
"10 9\n2 2 9\n1 1\n2 0 1\n1 8\n2 0 8\n1 2\n2 1 3\n1 4\n2 2 4\n",
"7 4\n1 3\n1 2\n2 0 1\n2 1 2\n"
],
"output": [
"7\n2\n10\n4\n5\n",
"4\n3\n"
]
} |
1,223 | 8 | Many computer strategy games require building cities, recruiting army, conquering tribes, collecting resources. Sometimes it leads to interesting problems.
Let's suppose that your task is to build a square city. The world map uses the Cartesian coordinates. The sides of the city should be parallel to coordinate axes. The map contains mines with valuable resources, located at some points with integer coordinates. The sizes of mines are relatively small, i.e. they can be treated as points. The city should be built in such a way that all the mines are inside or on the border of the city square.
Building a city takes large amount of money depending on the size of the city, so you have to build the city with the minimum area. Given the positions of the mines find the minimum possible area of the city.
Input
The first line of the input contains number n — the number of mines on the map (2 ≤ n ≤ 1000). Each of the next n lines contains a pair of integers xi and yi — the coordinates of the corresponding mine ( - 109 ≤ xi, yi ≤ 109). All points are pairwise distinct.
Output
Print the minimum area of the city that can cover all the mines with valuable resources.
Examples
Input
2
0 0
2 2
Output
4
Input
2
0 0
0 3
Output
9 | def main():
n = int(input())
xs, ys = [], []
for _ in range(n):
x, y = map(int, input().split())
xs.append(x)
ys.append(y)
print(max(max(xs)-min(xs), max(ys)-min(ys)) ** 2)
if __name__ == '__main__':
main()
| {
"input": [
"2\n0 0\n2 2\n",
"2\n0 0\n0 3\n"
],
"output": [
"4\n",
"9\n"
]
} |
1,224 | 8 | There are n piles of pebbles on the table, the i-th pile contains ai pebbles. Your task is to paint each pebble using one of the k given colors so that for each color c and any two piles i and j the difference between the number of pebbles of color c in pile i and number of pebbles of color c in pile j is at most one.
In other words, let's say that bi, c is the number of pebbles of color c in the i-th pile. Then for any 1 ≤ c ≤ k, 1 ≤ i, j ≤ n the following condition must be satisfied |bi, c - bj, c| ≤ 1. It isn't necessary to use all k colors: if color c hasn't been used in pile i, then bi, c is considered to be zero.
Input
The first line of the input contains positive integers n and k (1 ≤ n, k ≤ 100), separated by a space — the number of piles and the number of colors respectively.
The second line contains n positive integers a1, a2, ..., an (1 ≤ ai ≤ 100) denoting number of pebbles in each of the piles.
Output
If there is no way to paint the pebbles satisfying the given condition, output "NO" (without quotes) .
Otherwise in the first line output "YES" (without quotes). Then n lines should follow, the i-th of them should contain ai space-separated integers. j-th (1 ≤ j ≤ ai) of these integers should be equal to the color of the j-th pebble in the i-th pile. If there are several possible answers, you may output any of them.
Examples
Input
4 4
1 2 3 4
Output
YES
1
1 4
1 2 4
1 2 3 4
Input
5 2
3 2 4 1 3
Output
NO
Input
5 4
3 2 4 3 5
Output
YES
1 2 3
1 3
1 2 3 4
1 3 4
1 1 2 3 4 | def mi():
return map(int, input().split())
n,m = mi()
a = list(mi())
ma, mi = max(a),min(a)
if ma-mi > m:
print ('NO')
else:
print ('YES')
for i in a:
print (*[1]*mi+list(range(1, i-mi+1)))
| {
"input": [
"5 4\n3 2 4 3 5\n",
"5 2\n3 2 4 1 3\n",
"4 4\n1 2 3 4\n"
],
"output": [
"YES\n1 2 3\n1 2\n1 2 3 4\n1 2 3\n1 2 3 4 1\n",
"NO\n",
"YES\n1\n1 2\n1 2 3\n1 2 3 4\n"
]
} |
1,225 | 9 | Amr loves Chemistry, and specially doing experiments. He is preparing for a new interesting experiment.
Amr has n different types of chemicals. Each chemical i has an initial volume of ai liters. For this experiment, Amr has to mix all the chemicals together, but all the chemicals volumes must be equal first. So his task is to make all the chemicals volumes equal.
To do this, Amr can do two different kind of operations.
* Choose some chemical i and double its current volume so the new volume will be 2ai
* Choose some chemical i and divide its volume by two (integer division) so the new volume will be <image>
Suppose that each chemical is contained in a vessel of infinite volume. Now Amr wonders what is the minimum number of operations required to make all the chemicals volumes equal?
Input
The first line contains one number n (1 ≤ n ≤ 105), the number of chemicals.
The second line contains n space separated integers ai (1 ≤ ai ≤ 105), representing the initial volume of the i-th chemical in liters.
Output
Output one integer the minimum number of operations required to make all the chemicals volumes equal.
Examples
Input
3
4 8 2
Output
2
Input
3
3 5 6
Output
5
Note
In the first sample test, the optimal solution is to divide the second chemical volume by two, and multiply the third chemical volume by two to make all the volumes equal 4.
In the second sample test, the optimal solution is to divide the first chemical volume by two, and divide the second and the third chemical volumes by two twice to make all the volumes equal 1. | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from collections import defaultdict
n = int(input())
A = list(map(int,input().split()))
pattern = set()
for a in A:
p = []
while a > 0:
if a in pattern:
break
p.append(a)
a = a//2
pattern |= set(p)
def check(v):
ret = 0
for a in A:
count = 0
while a != 0:
if v == a or (v % a == 0 and (v//a)&-(v//a) == v//a):
ret += len(bin(v//a))-3
break
if (v%a == 0 and (v//a)&-(v//a) == v//a) and a < v:
return 1e12
a = a//2
ret += 1
else:
return 1e12
return ret
ans = 1e12
for p in pattern:
ret = check(p)
ans = ans if ans < ret else ret
print(ans)
| {
"input": [
"3\n4 8 2\n",
"3\n3 5 6\n"
],
"output": [
"2\n",
"5\n"
]
} |
1,226 | 7 | Olesya loves numbers consisting of n digits, and Rodion only likes numbers that are divisible by t. Find some number that satisfies both of them.
Your task is: given the n and t print an integer strictly larger than zero consisting of n digits that is divisible by t. If such number doesn't exist, print - 1.
Input
The single line contains two numbers, n and t (1 ≤ n ≤ 100, 2 ≤ t ≤ 10) — the length of the number and the number it should be divisible by.
Output
Print one such positive number without leading zeroes, — the answer to the problem, or - 1, if such number doesn't exist. If there are multiple possible answers, you are allowed to print any of them.
Examples
Input
3 2
Output
712 | def main():
n, m = map(int, input().split())
print(int('9' * n) // m * m or -1)
if __name__ == '__main__':
main()
| {
"input": [
"3 2\n"
],
"output": [
"100\n"
]
} |
1,227 | 7 | Carl is a beginner magician. He has a blue, b violet and c orange magic spheres. In one move he can transform two spheres of the same color into one sphere of any other color. To make a spell that has never been seen before, he needs at least x blue, y violet and z orange spheres. Can he get them (possible, in multiple actions)?
Input
The first line of the input contains three integers a, b and c (0 ≤ a, b, c ≤ 1 000 000) — the number of blue, violet and orange spheres that are in the magician's disposal.
The second line of the input contains three integers, x, y and z (0 ≤ x, y, z ≤ 1 000 000) — the number of blue, violet and orange spheres that he needs to get.
Output
If the wizard is able to obtain the required numbers of spheres, print "Yes". Otherwise, print "No".
Examples
Input
4 4 0
2 1 2
Output
Yes
Input
5 6 1
2 7 2
Output
No
Input
3 3 3
2 2 2
Output
Yes
Note
In the first sample the wizard has 4 blue and 4 violet spheres. In his first action he can turn two blue spheres into one violet one. After that he will have 2 blue and 5 violet spheres. Then he turns 4 violet spheres into 2 orange spheres and he ends up with 2 blue, 1 violet and 2 orange spheres, which is exactly what he needs. | def main():
l = list(tuple(map(int, input().split())) for _ in (0, 1))
print(("Yes", "No")[sum((u - v) // (1, 2)[u > v] for u, v in zip(*l)) < 0])
if __name__ == '__main__':
main()
| {
"input": [
"3 3 3\n2 2 2\n",
"5 6 1\n2 7 2\n",
"4 4 0\n2 1 2\n"
],
"output": [
"Yes\n",
"No\n",
"Yes\n"
]
} |
1,228 | 7 | A tennis tournament with n participants is running. The participants are playing by an olympic system, so the winners move on and the losers drop out.
The tournament takes place in the following way (below, m is the number of the participants of the current round):
* let k be the maximal power of the number 2 such that k ≤ m,
* k participants compete in the current round and a half of them passes to the next round, the other m - k participants pass to the next round directly,
* when only one participant remains, the tournament finishes.
Each match requires b bottles of water for each participant and one bottle for the judge. Besides p towels are given to each participant for the whole tournament.
Find the number of bottles and towels needed for the tournament.
Note that it's a tennis tournament so in each match two participants compete (one of them will win and the other will lose).
Input
The only line contains three integers n, b, p (1 ≤ n, b, p ≤ 500) — the number of participants and the parameters described in the problem statement.
Output
Print two integers x and y — the number of bottles and towels need for the tournament.
Examples
Input
5 2 3
Output
20 15
Input
8 2 4
Output
35 32
Note
In the first example will be three rounds:
1. in the first round will be two matches and for each match 5 bottles of water are needed (two for each of the participants and one for the judge),
2. in the second round will be only one match, so we need another 5 bottles of water,
3. in the third round will also be only one match, so we need another 5 bottles of water.
So in total we need 20 bottles of water.
In the second example no participant will move on to some round directly. | def read():
return [int(s) for s in input().split()]
(n, b, p) = read()
print((n-1)*(2*b+1), n*p)
| {
"input": [
"5 2 3\n",
"8 2 4\n"
],
"output": [
"20 15\n",
"35 32\n"
]
} |
1,229 | 8 | A student of z-school found a kind of sorting called z-sort. The array a with n elements are z-sorted if two conditions hold:
1. ai ≥ ai - 1 for all even i,
2. ai ≤ ai - 1 for all odd i > 1.
For example the arrays [1,2,1,2] and [1,1,1,1] are z-sorted while the array [1,2,3,4] isn’t z-sorted.
Can you make the array z-sorted?
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of elements in the array a.
The second line contains n integers ai (1 ≤ ai ≤ 109) — the elements of the array a.
Output
If it's possible to make the array a z-sorted print n space separated integers ai — the elements after z-sort. Otherwise print the only word "Impossible".
Examples
Input
4
1 2 2 1
Output
1 2 1 2
Input
5
1 3 2 2 5
Output
1 5 2 3 2 | def main():
n = int(input())
l = sorted(map(int, input().split()))
res = [0] * n
res[::2], res[1::2] = l[:n - n // 2], l[:-(n // 2) - 1:-1]
print(*res)
if __name__ == '__main__':
main()
| {
"input": [
"5\n1 3 2 2 5\n",
"4\n1 2 2 1\n"
],
"output": [
"1 5 2 3 2 ",
"1 2 1 2 "
]
} |
1,230 | 11 | There are several days left before the fiftieth birthday of a famous Berland's writer Berlbury. In this connection the local library decided to make an exposition of the works of this famous science-fiction writer. It was decided as well that it is necessary to include into the exposition only those books that were published during a particular time period. It is obvious that if the books differ much in size, the visitors will not like it. That was why the organizers came to the opinion, that the difference between the highest and the lowest books in the exposition should be not more than k millimeters.
The library has n volumes of books by Berlbury, arranged in chronological order of their appearance. The height of each book in millimeters is know, it is hi. As Berlbury is highly respected in the city, the organizers want to include into the exposition as many books as possible, and to find out what periods of his creative work they will manage to cover. You are asked to help the organizers cope with this hard task.
Input
The first line of the input data contains two integer numbers separated by a space n (1 ≤ n ≤ 105) and k (0 ≤ k ≤ 106) — the amount of books by Berlbury in the library, and the maximum allowed height difference between the lowest and the highest books. The second line contains n integer numbers separated by a space. Each number hi (1 ≤ hi ≤ 106) is the height of the i-th book in millimeters.
Output
In the first line of the output data print two numbers a and b (separate them by a space), where a is the maximum amount of books the organizers can include into the exposition, and b — the amount of the time periods, during which Berlbury published a books, and the height difference between the lowest and the highest among these books is not more than k milllimeters.
In each of the following b lines print two integer numbers separated by a space — indexes of the first and the last volumes from each of the required time periods of Berlbury's creative work.
Examples
Input
3 3
14 12 10
Output
2 2
1 2
2 3
Input
2 0
10 10
Output
2 1
1 2
Input
4 5
8 19 10 13
Output
2 1
3 4 | n,k=[int(i) for i in input().split()]
h=[int(i) for i in input().split()]
a=0
b=0
l=[]
m=[]
ans=[]
def f():
while l[0][0]<b:
l.pop(0)
while m[0][0]<b:
m.pop(0)
return l[0][1]-m[0][1]>k
for i in range(n):
while len(l)>0 and l[-1][1]<=h[i]:
l.pop()
l.append([i,h[i]])
while len(m)>0 and m[-1][1]>=h[i]:
m.pop()
m.append([i,h[i]])
while f():
b+=1
if i-b+1>a:
a=i-b+1
ans=[i]
elif i-b+1==a:
ans.append(i)
print(a,len(ans))
for i in ans:
print(i-a+2,i+1)
| {
"input": [
"3 3\n14 12 10\n",
"4 5\n8 19 10 13\n",
"2 0\n10 10\n"
],
"output": [
"2 2\n1 2\n2 3\n",
"2 1\n3 4\n",
"2 1\n1 2\n"
]
} |
1,231 | 8 | You are given a text consisting of n lines. Each line contains some space-separated words, consisting of lowercase English letters.
We define a syllable as a string that contains exactly one vowel and any arbitrary number (possibly none) of consonants. In English alphabet following letters are considered to be vowels: 'a', 'e', 'i', 'o', 'u' and 'y'.
Each word of the text that contains at least one vowel can be divided into syllables. Each character should be a part of exactly one syllable. For example, the word "mamma" can be divided into syllables as "ma" and "mma", "mam" and "ma", and "mamm" and "a". Words that consist of only consonants should be ignored.
The verse patterns for the given text is a sequence of n integers p1, p2, ..., pn. Text matches the given verse pattern if for each i from 1 to n one can divide words of the i-th line in syllables in such a way that the total number of syllables is equal to pi.
You are given the text and the verse pattern. Check, if the given text matches the given verse pattern.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of lines in the text.
The second line contains integers p1, ..., pn (0 ≤ pi ≤ 100) — the verse pattern.
Next n lines contain the text itself. Text consists of lowercase English letters and spaces. It's guaranteed that all lines are non-empty, each line starts and ends with a letter and words are separated by exactly one space. The length of each line doesn't exceed 100 characters.
Output
If the given text matches the given verse pattern, then print "YES" (without quotes) in the only line of the output. Otherwise, print "NO" (without quotes).
Examples
Input
3
2 2 3
intel
code
ch allenge
Output
YES
Input
4
1 2 3 1
a
bcdefghi
jklmnopqrstu
vwxyz
Output
NO
Input
4
13 11 15 15
to be or not to be that is the question
whether tis nobler in the mind to suffer
the slings and arrows of outrageous fortune
or to take arms against a sea of troubles
Output
YES
Note
In the first sample, one can split words into syllables in the following way:
in-tel
co-de
ch al-len-ge
Since the word "ch" in the third line doesn't contain vowels, we can ignore it. As the result we get 2 syllabels in first two lines and 3 syllables in the third one. | def main():
t = str.maketrans("aeiouy", "******")
input()
for p in map(int, input().split()):
if p != input().translate(t).count('*'):
print("NO")
return
print("YES")
if __name__ == '__main__':
main()
| {
"input": [
"3\n2 2 3\nintel\ncode\nch allenge\n",
"4\n1 2 3 1\na\nbcdefghi\njklmnopqrstu\nvwxyz\n",
"4\n13 11 15 15\nto be or not to be that is the question\nwhether tis nobler in the mind to suffer\nthe slings and arrows of outrageous fortune\nor to take arms against a sea of troubles\n"
],
"output": [
"YES\n",
"NO\n",
"YES\n"
]
} |
1,232 | 11 | Vladik was bored on his way home and decided to play the following game. He took n cards and put them in a row in front of himself. Every card has a positive integer number not exceeding 8 written on it. He decided to find the longest subsequence of cards which satisfies the following conditions:
* the number of occurrences of each number from 1 to 8 in the subsequence doesn't differ by more then 1 from the number of occurrences of any other number. Formally, if there are ck cards with number k on them in the subsequence, than for all pairs of integers <image> the condition |ci - cj| ≤ 1 must hold.
* if there is at least one card with number x on it in the subsequence, then all cards with number x in this subsequence must form a continuous segment in it (but not necessarily a continuous segment in the original sequence). For example, the subsequence [1, 1, 2, 2] satisfies this condition while the subsequence [1, 2, 2, 1] doesn't. Note that [1, 1, 2, 2] doesn't satisfy the first condition.
Please help Vladik to find the length of the longest subsequence that satisfies both conditions.
Input
The first line contains single integer n (1 ≤ n ≤ 1000) — the number of cards in Vladik's sequence.
The second line contains the sequence of n positive integers not exceeding 8 — the description of Vladik's sequence.
Output
Print single integer — the length of the longest subsequence of Vladik's sequence that satisfies both conditions.
Examples
Input
3
1 1 1
Output
1
Input
8
8 7 6 5 4 3 2 1
Output
8
Input
24
1 8 1 2 8 2 3 8 3 4 8 4 5 8 5 6 8 6 7 8 7 8 8 8
Output
17
Note
In the first sample all the numbers written on the cards are equal, so you can't take more than one card, otherwise you'll violate the first condition. | import copy
def solve():
n = int(input())
a = [int(c)-1 for c in input().split(' ')]
nextcard = [[-1 for i in range(8)] for j in range(n)]
for i in range(n-2, -1, -1):
nextcard[i] = copy.copy(nextcard[i+1])
nextcard[i][a[i+1]] = i+1
jump = [[-1 for i in range(n+1)] for j in range(n)]
for i in range(n):
card = a[i]
cpos = i
j = 1
while cpos != -1:
jump[i][j] = cpos
j+=1
cpos = nextcard[cpos][card]
#Find dp solution for range (val, val+1)
def getLen(val):
dp = [[-1 for i in range(1<<8)] for j in range(n+1)]
dp[0][0] = 0
for i in range(n):
card = a[i]
for comb in range(1<<8):
if (comb & (1<<card)) == 0 and dp[i][comb] != -1:
ncomb = comb + (1<<card)
if jump[i][val] != -1:
j = jump[i][val]+1
dp[j][ncomb] = max(dp[j][ncomb], dp[i][comb] + val)
if jump[i][val+1] != -1:
j = jump[i][val+1]+1
dp[j][ncomb] = max(dp[j][ncomb], dp[i][comb] + val + 1)
dp[i+1][comb] = max(dp[i+1][comb], dp[i][comb])
return dp[n][(1<<8)-1]
appear = [False for i in range(8)]
for c in a:
appear[c] = True
result = 0
for c in appear:
result += int(c)
#Finally binary search to find the result
cur = 0
for lev in range(9, -1, -1):
tpow = (1<<lev)
if cur + tpow < n:
ret = getLen(cur + tpow)
if(ret != -1):
result = max(result, ret)
cur += tpow
return result
print(solve())
| {
"input": [
"3\n1 1 1\n",
"24\n1 8 1 2 8 2 3 8 3 4 8 4 5 8 5 6 8 6 7 8 7 8 8 8\n",
"8\n8 7 6 5 4 3 2 1\n"
],
"output": [
"1",
"17\n",
"8\n"
]
} |
1,233 | 8 | Finally! Vasya have come of age and that means he can finally get a passport! To do it, he needs to visit the passport office, but it's not that simple. There's only one receptionist at the passport office and people can queue up long before it actually opens. Vasya wants to visit the passport office tomorrow.
He knows that the receptionist starts working after ts minutes have passed after midnight and closes after tf minutes have passed after midnight (so that (tf - 1) is the last minute when the receptionist is still working). The receptionist spends exactly t minutes on each person in the queue. If the receptionist would stop working within t minutes, he stops serving visitors (other than the one he already serves).
Vasya also knows that exactly n visitors would come tomorrow. For each visitor Vasya knows the point of time when he would come to the passport office. Each visitor queues up and doesn't leave until he was served. If the receptionist is free when a visitor comes (in particular, if the previous visitor was just served and the queue is empty), the receptionist begins to serve the newcomer immediately.
<image> "Reception 1"
For each visitor, the point of time when he would come to the passport office is positive. Vasya can come to the office at the time zero (that is, at midnight) if he needs so, but he can come to the office only at integer points of time. If Vasya arrives at the passport office at the same time with several other visitors, he yields to them and stand in the queue after the last of them.
Vasya wants to come at such point of time that he will be served by the receptionist, and he would spend the minimum possible time in the queue. Help him!
Input
The first line contains three integers: the point of time when the receptionist begins to work ts, the point of time when the receptionist stops working tf and the time the receptionist spends on each visitor t. The second line contains one integer n — the amount of visitors (0 ≤ n ≤ 100 000). The third line contains positive integers in non-decreasing order — the points of time when the visitors arrive to the passport office.
All times are set in minutes and do not exceed 1012; it is guaranteed that ts < tf. It is also guaranteed that Vasya can arrive at the passport office at such a point of time that he would be served by the receptionist.
Output
Print single non-negative integer — the point of time when Vasya should arrive at the passport office. If Vasya arrives at the passport office at the same time with several other visitors, he yields to them and queues up the last. If there are many answers, you can print any of them.
Examples
Input
10 15 2
2
10 13
Output
12
Input
8 17 3
4
3 4 5 8
Output
2
Note
In the first example the first visitor comes exactly at the point of time when the receptionist begins to work, and he is served for two minutes. At 12 minutes after the midnight the receptionist stops serving the first visitor, and if Vasya arrives at this moment, he will be served immediately, because the next visitor would only come at 13 minutes after midnight.
In the second example, Vasya has to come before anyone else to be served. | #!/usr/bin/env python3
def ri():
return map(int, input().split())
s, f, t = ri()
n = int(input())
if n == 0:
print(s)
exit()
i = list(ri())
p = 0
a = s
m = 10**100
for ii in i:
if ii <= f - t:
if a - ii + 1 < m:
m = a - ii + 1
p = min(ii-1, a)
a = max(a, ii) + t
if a <= f-t:
p = a
print(p)
| {
"input": [
"10 15 2\n2\n10 13\n",
"8 17 3\n4\n3 4 5 8\n"
],
"output": [
"12\n",
"2\n"
]
} |
1,234 | 7 | Bear Limak wants to become the largest of bears, or at least to become larger than his brother Bob.
Right now, Limak and Bob weigh a and b respectively. It's guaranteed that Limak's weight is smaller than or equal to his brother's weight.
Limak eats a lot and his weight is tripled after every year, while Bob's weight is doubled after every year.
After how many full years will Limak become strictly larger (strictly heavier) than Bob?
Input
The only line of the input contains two integers a and b (1 ≤ a ≤ b ≤ 10) — the weight of Limak and the weight of Bob respectively.
Output
Print one integer, denoting the integer number of years after which Limak will become strictly larger than Bob.
Examples
Input
4 7
Output
2
Input
4 9
Output
3
Input
1 1
Output
1
Note
In the first sample, Limak weighs 4 and Bob weighs 7 initially. After one year their weights are 4·3 = 12 and 7·2 = 14 respectively (one weight is tripled while the other one is doubled). Limak isn't larger than Bob yet. After the second year weights are 36 and 28, so the first weight is greater than the second one. Limak became larger than Bob after two years so you should print 2.
In the second sample, Limak's and Bob's weights in next years are: 12 and 18, then 36 and 36, and finally 108 and 72 (after three years). The answer is 3. Remember that Limak wants to be larger than Bob and he won't be satisfied with equal weights.
In the third sample, Limak becomes larger than Bob after the first year. Their weights will be 3 and 2 then. | def l2i(s):
return [int(i) for i in s.split()]
a, b=l2i(input())
t=0
while (a<=b):
a*=3
b*=2
t+=1
print(t) | {
"input": [
"4 9\n",
"1 1\n",
"4 7\n"
],
"output": [
"3\n",
"1\n",
"2\n"
]
} |
1,235 | 9 | Vladik often travels by trains. He remembered some of his trips especially well and I would like to tell you about one of these trips:
Vladik is at initial train station, and now n people (including Vladik) want to get on the train. They are already lined up in some order, and for each of them the city code ai is known (the code of the city in which they are going to).
Train chief selects some number of disjoint segments of the original sequence of people (covering entire sequence by segments is not necessary). People who are in the same segment will be in the same train carriage. The segments are selected in such way that if at least one person travels to the city x, then all people who are going to city x should be in the same railway carriage. This means that they can’t belong to different segments. Note, that all people who travel to the city x, either go to it and in the same railway carriage, or do not go anywhere at all.
Comfort of a train trip with people on segment from position l to position r is equal to XOR of all distinct codes of cities for people on the segment from position l to position r. XOR operation also known as exclusive OR.
Total comfort of a train trip is equal to sum of comfort for each segment.
Help Vladik to know maximal possible total comfort.
Input
First line contains single integer n (1 ≤ n ≤ 5000) — number of people.
Second line contains n space-separated integers a1, a2, ..., an (0 ≤ ai ≤ 5000), where ai denotes code of the city to which i-th person is going.
Output
The output should contain a single integer — maximal possible total comfort.
Examples
Input
6
4 4 2 5 2 3
Output
14
Input
9
5 1 3 1 5 2 4 2 5
Output
9
Note
In the first test case best partition into segments is: [4, 4] [2, 5, 2] [3], answer is calculated as follows: 4 + (2 xor 5) + 3 = 4 + 7 + 3 = 14
In the second test case best partition into segments is: 5 1 [3] 1 5 [2, 4, 2] 5, answer calculated as follows: 3 + (2 xor 4) = 3 + 6 = 9. | def dp():
dparr = [0] * len(sections)
for i in range(len(sections) - 1, -1, -1):
_, curend, curcomfort = sections[i]
nextsection = i + 1
try:
while sections[nextsection][0] <= curend:
nextsection += 1
except IndexError:
# Loop til end
inc = curcomfort
else:
inc = curcomfort + dparr[nextsection]
exc = 0 if i == len(sections) - 1 else dparr[i + 1]
dparr[i] = max(inc, exc)
return dparr[0]
n = int(input())
zs = list(map(int, input().split()))
sections = []
seenstartz = set()
first = {z: i for i, z in reversed(list(enumerate(zs)))}
last = {z: i for i, z in enumerate(zs)}
for start, z in enumerate(zs):
if z in seenstartz:
continue
seenstartz.add(z)
end = last[z]
comfort = 0
i = start
while i <= end:
if first[zs[i]] < start:
break
if i == last[zs[i]]:
comfort ^= zs[i]
end = max(end, last[zs[i]])
i += 1
else:
sections.append((start, end, comfort))
ans = dp()
print(ans)
| {
"input": [
"9\n5 1 3 1 5 2 4 2 5\n",
"6\n4 4 2 5 2 3\n"
],
"output": [
"9\n",
"14\n"
]
} |
1,236 | 11 | Vasya is studying number theory. He has denoted a function f(a, b) such that:
* f(a, 0) = 0;
* f(a, b) = 1 + f(a, b - gcd(a, b)), where gcd(a, b) is the greatest common divisor of a and b.
Vasya has two numbers x and y, and he wants to calculate f(x, y). He tried to do it by himself, but found out that calculating this function the way he wants to do that might take very long time. So he decided to ask you to implement a program that will calculate this function swiftly.
Input
The first line contains two integer numbers x and y (1 ≤ x, y ≤ 1012).
Output
Print f(x, y).
Examples
Input
3 5
Output
3
Input
6 3
Output
1 | def gcd(a,b):
#print(a,b)
if b == 0:return a
return gcd(b,a%b)
def kmm(a,b):
return a*b//gcd(a,b)
a,b = map(int,input().split())
t = 0
while b > 0:
divi=[]
for i in range(1,int(a**0.5)+1):
if a%i == 0:
divi.append(i)
divi.append(a//i)
divi.pop(0)
mods = []
for i in divi:
mods.append(b%i)
m = min(mods)
#km = 1
t += m
b -= m
b2 = b
b //= gcd(a,b)
a //= gcd(a,b2)
#print(a,b)
if a == 1:
t+=b
break
print(t)
| {
"input": [
"3 5\n",
"6 3\n"
],
"output": [
"3\n",
"1\n"
]
} |
1,237 | 7 | For a given positive integer n denote its k-rounding as the minimum positive integer x, such that x ends with k or more zeros in base 10 and is divisible by n.
For example, 4-rounding of 375 is 375·80 = 30000. 30000 is the minimum integer such that it ends with 4 or more zeros and is divisible by 375.
Write a program that will perform the k-rounding of n.
Input
The only line contains two integers n and k (1 ≤ n ≤ 109, 0 ≤ k ≤ 8).
Output
Print the k-rounding of n.
Examples
Input
375 4
Output
30000
Input
10000 1
Output
10000
Input
38101 0
Output
38101
Input
123456789 8
Output
12345678900000000 | n,k=map(int,input().split())
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
print(lcm(n,10**k)) | {
"input": [
"10000 1\n",
"375 4\n",
"38101 0\n",
"123456789 8\n"
],
"output": [
"10000\n",
"30000\n",
"38101\n",
"12345678900000000\n"
]
} |
1,238 | 8 | Two bears are playing tic-tac-toe via mail. It's boring for them to play usual tic-tac-toe game, so they are a playing modified version of this game. Here are its rules.
The game is played on the following field.
<image>
Players are making moves by turns. At first move a player can put his chip in any cell of any small field. For following moves, there are some restrictions: if during last move the opposite player put his chip to cell with coordinates (xl, yl) in some small field, the next move should be done in one of the cells of the small field with coordinates (xl, yl). For example, if in the first move a player puts his chip to lower left cell of central field, then the second player on his next move should put his chip into some cell of lower left field (pay attention to the first test case). If there are no free cells in the required field, the player can put his chip to any empty cell on any field.
You are given current state of the game and coordinates of cell in which the last move was done. You should find all cells in which the current player can put his chip.
A hare works as a postman in the forest, he likes to foul bears. Sometimes he changes the game field a bit, so the current state of the game could be unreachable. However, after his changes the cell where the last move was done is not empty. You don't need to find if the state is unreachable or not, just output possible next moves according to the rules.
Input
First 11 lines contains descriptions of table with 9 rows and 9 columns which are divided into 9 small fields by spaces and empty lines. Each small field is described by 9 characters without spaces and empty lines. character "x" (ASCII-code 120) means that the cell is occupied with chip of the first player, character "o" (ASCII-code 111) denotes a field occupied with chip of the second player, character "." (ASCII-code 46) describes empty cell.
The line after the table contains two integers x and y (1 ≤ x, y ≤ 9). They describe coordinates of the cell in table where the last move was done. Rows in the table are numbered from up to down and columns are numbered from left to right.
It's guaranteed that cell where the last move was done is filled with "x" or "o". Also, it's guaranteed that there is at least one empty cell. It's not guaranteed that current state of game is reachable.
Output
Output the field in same format with characters "!" (ASCII-code 33) on positions where the current player can put his chip. All other cells should not be modified.
Examples
Input
... ... ...
... ... ...
... ... ...
... ... ...
... ... ...
... x.. ...
... ... ...
... ... ...
... ... ...
6 4
Output
... ... ...
... ... ...
... ... ...
... ... ...
... ... ...
... x.. ...
!!! ... ...
!!! ... ...
!!! ... ...
Input
xoo x.. x..
ooo ... ...
ooo ... ...
x.. x.. x..
... ... ...
... ... ...
x.. x.. x..
... ... ...
... ... ...
7 4
Output
xoo x!! x!!
ooo !!! !!!
ooo !!! !!!
x!! x!! x!!
!!! !!! !!!
!!! !!! !!!
x!! x!! x!!
!!! !!! !!!
!!! !!! !!!
Input
o.. ... ...
... ... ...
... ... ...
... xxx ...
... xox ...
... ooo ...
... ... ...
... ... ...
... ... ...
5 5
Output
o!! !!! !!!
!!! !!! !!!
!!! !!! !!!
!!! xxx !!!
!!! xox !!!
!!! ooo !!!
!!! !!! !!!
!!! !!! !!!
!!! !!! !!!
Note
In the first test case the first player made a move to lower left cell of central field, so the second player can put a chip only to cells of lower left field.
In the second test case the last move was done to upper left cell of lower central field, however all cells in upper left field are occupied, so the second player can put his chip to any empty cell.
In the third test case the last move was done to central cell of central field, so current player can put his chip to any cell of central field, which is already occupied, so he can move anywhere. Pay attention that this state of the game is unreachable. | def color(x1, y1, x2, y2):
k = 0
for i in range(x1, x2):
for j in range(y1, min(len(field[i]), y2 + 1)):
if field[i][j] == '.':
field[i][j] = '!'
k += 1
return k != 0
field = [list(input()) for i in range(11)]
x, y = map(int, input().split())
xg = x % 3 + 3 * (x % 3 == 0)
yg = y % 3 + 3 * (y % 3 == 0)
x2 = 4 * xg - 1
y2 = 4 * yg - 1
x1 = x2 - 3
y1 = y2 - 3
if not(color(x1, y1, x2, y2)):
color(0, 0, 11, 10)
for i in range(len(field)):
for j in range(len(field[i])):
print(field[i][j], end = '')
print() | {
"input": [
"xoo x.. x..\nooo ... ...\nooo ... ...\n\nx.. x.. x..\n... ... ...\n... ... ...\n\nx.. x.. x..\n... ... ...\n... ... ...\n7 4\n",
"... ... ...\n... ... ...\n... ... ...\n\n... ... ...\n... ... ...\n... x.. ...\n\n... ... ...\n... ... ...\n... ... ...\n6 4\n",
"o.. ... ...\n... ... ...\n... ... ...\n\n... xxx ...\n... xox ...\n... ooo ...\n\n... ... ...\n... ... ...\n... ... ...\n5 5\n"
],
"output": [
"xoo x!! x!! \nooo !!! !!! \nooo !!! !!! \n\nx!! x!! x!! \n!!! !!! !!! \n!!! !!! !!! \n\nx!! x!! x!! \n!!! !!! !!! \n!!! !!! !!! \n\n",
"... ... ... \n... ... ... \n... ... ... \n\n... ... ... \n... ... ... \n... x.. ... \n\n!!! ... ... \n!!! ... ... \n!!! ... ... \n\n",
"o!! !!! !!! \n!!! !!! !!! \n!!! !!! !!! \n\n!!! xxx !!! \n!!! xox !!! \n!!! ooo !!! \n\n!!! !!! !!! \n!!! !!! !!! \n!!! !!! !!! \n\n"
]
} |
1,239 | 7 | Overlooking the captivating blend of myriads of vernal hues, Arkady the painter lays out a long, long canvas.
Arkady has a sufficiently large amount of paint of three colours: cyan, magenta, and yellow. On the one-dimensional canvas split into n consecutive segments, each segment needs to be painted in one of the colours.
Arkady has already painted some (possibly none or all) segments and passes the paintbrush to you. You are to determine whether there are at least two ways of colouring all the unpainted segments so that no two adjacent segments are of the same colour. Two ways are considered different if and only if a segment is painted in different colours in them.
Input
The first line contains a single positive integer n (1 ≤ n ≤ 100) — the length of the canvas.
The second line contains a string s of n characters, the i-th of which is either 'C' (denoting a segment painted in cyan), 'M' (denoting one painted in magenta), 'Y' (one painted in yellow), or '?' (an unpainted one).
Output
If there are at least two different ways of painting, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5
CY??Y
Output
Yes
Input
5
C?C?Y
Output
Yes
Input
5
?CYC?
Output
Yes
Input
5
C??MM
Output
No
Input
3
MMY
Output
No
Note
For the first example, there are exactly two different ways of colouring: CYCMY and CYMCY.
For the second example, there are also exactly two different ways of colouring: CMCMY and CYCMY.
For the third example, there are four ways of colouring: MCYCM, MCYCY, YCYCM, and YCYCY.
For the fourth example, no matter how the unpainted segments are coloured, the existing magenta segments will prevent the painting from satisfying the requirements. The similar is true for the fifth example. | import sys
def p(s):
print(s)
sys.exit(0)
n = int(input())
s = input()
if 'CC' in s or 'YY' in s or 'MM' in s:
p('No')
if s[0]=='?' or s[-1]=='?':
p('Yes')
if '??' in s:
p('Yes')
if 'C?C' in s or 'Y?Y' in s or 'M?M' in s:
p('Yes')
p('No')
| {
"input": [
"5\n?CYC?\n",
"5\nCY??Y\n",
"5\nC?C?Y\n",
"5\nC??MM\n",
"3\nMMY\n"
],
"output": [
"Yes",
"Yes",
"Yes",
"No",
"No"
]
} |
1,240 | 7 | You're given a row with n chairs. We call a seating of people "maximal" if the two following conditions hold:
1. There are no neighbors adjacent to anyone seated.
2. It's impossible to seat one more person without violating the first rule.
The seating is given as a string consisting of zeros and ones (0 means that the corresponding seat is empty, 1 — occupied). The goal is to determine whether this seating is "maximal".
Note that the first and last seats are not adjacent (if n ≠ 2).
Input
The first line contains a single integer n (1 ≤ n ≤ 1000) — the number of chairs.
The next line contains a string of n characters, each of them is either zero or one, describing the seating.
Output
Output "Yes" (without quotation marks) if the seating is "maximal". Otherwise print "No".
You are allowed to print letters in whatever case you'd like (uppercase or lowercase).
Examples
Input
3
101
Output
Yes
Input
4
1011
Output
No
Input
5
10001
Output
No
Note
In sample case one the given seating is maximal.
In sample case two the person at chair three has a neighbour to the right.
In sample case three it is possible to seat yet another person into chair three. | def main() :
n=int(input())
s=input().strip()
if "11" in s or "000" in s or s =="0" or s.startswith("00") or s.endswith("00") :
print("No")
else :
print("Yes")
main()
| {
"input": [
"3\n101\n",
"5\n10001\n",
"4\n1011\n"
],
"output": [
"Yes\n",
"No\n",
"No\n"
]
} |
1,241 | 9 | You are given an array a consisting of n integers. You can perform the following operations with it:
1. Choose some positions i and j (1 ≤ i, j ≤ n, i ≠ j), write the value of a_i ⋅ a_j into the j-th cell and remove the number from the i-th cell;
2. Choose some position i and remove the number from the i-th cell (this operation can be performed no more than once and at any point of time, not necessarily in the beginning).
The number of elements decreases by one after each operation. However, the indexing of positions stays the same. Deleted numbers can't be used in the later operations.
Your task is to perform exactly n - 1 operations with the array in such a way that the only number that remains in the array is maximum possible. This number can be rather large, so instead of printing it you need to print any sequence of operations which leads to this maximum number. Read the output format to understand what exactly you need to print.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array.
The second line contains n integers a_1, a_2, ..., a_n (-10^9 ≤ a_i ≤ 10^9) — the elements of the array.
Output
Print n - 1 lines. The k-th line should contain one of the two possible operations.
The operation of the first type should look like this: 1~ i_k~ j_k, where 1 is the type of operation, i_k and j_k are the positions of the chosen elements.
The operation of the second type should look like this: 2~ i_k, where 2 is the type of operation, i_k is the position of the chosen element. Note that there should be no more than one such operation.
If there are multiple possible sequences of operations leading to the maximum number — print any of them.
Examples
Input
5
5 -2 0 1 -3
Output
2 3
1 1 2
1 2 4
1 4 5
Input
5
5 2 0 4 0
Output
1 3 5
2 5
1 1 2
1 2 4
Input
2
2 -1
Output
2 2
Input
4
0 -10 0 0
Output
1 1 2
1 2 3
1 3 4
Input
4
0 0 0 0
Output
1 1 2
1 2 3
1 3 4
Note
Let X be the removed number in the array. Let's take a look at all the examples:
The first example has, for example, the following sequence of transformations of the array: [5, -2, 0, 1, -3] → [5, -2, X, 1, -3] → [X, -10, X, 1, -3] → [X, X, X, -10, -3] → [X, X, X, X, 30]. Thus, the maximum answer is 30. Note, that other sequences that lead to the answer 30 are also correct.
The second example has, for example, the following sequence of transformations of the array: [5, 2, 0, 4, 0] → [5, 2, X, 4, 0] → [5, 2, X, 4, X] → [X, 10, X, 4, X] → [X, X, X, 40, X]. The following answer is also allowed:
1 5 3
1 4 2
1 2 1
2 3
Then the sequence of transformations of the array will look like this: [5, 2, 0, 4, 0] → [5, 2, 0, 4, X] → [5, 8, 0, X, X] → [40, X, 0, X, X] → [40, X, X, X, X].
The third example can have the following sequence of transformations of the array: [2, -1] → [2, X].
The fourth example can have the following sequence of transformations of the array: [0, -10, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0].
The fifth example can have the following sequence of transformations of the array: [0, 0, 0, 0] → [X, 0, 0, 0] → [X, X, 0, 0] → [X, X, X, 0]. | from bisect import bisect
def main():
input()
l = sorted((a, i) for i, a in enumerate(map(int, input().split()), 1))
i, j = bisect(l, (0, -1)), bisect(l, (1, -1))
l = [i for _, i in l]
nn, zz, pp = l[:i], l[i:j], l[j:]
r, t = [], 0
if zz:
t = zz.pop()
for a in zz:
r.append(f'1 {a} {t}')
if len(nn) & 1:
if t:
r.append(f'1 {nn.pop()} {t}')
else:
t = nn.pop()
nn+=pp
if nn:
if t:
r.append(f'2 {t}')
t = nn.pop()
for a in nn:
r.append(f'1 {a} {t}')
print('\n'.join(r))
if __name__ == '__main__':
main()
| {
"input": [
"4\n0 0 0 0\n",
"5\n5 2 0 4 0\n",
"2\n2 -1\n",
"5\n5 -2 0 1 -3\n",
"4\n0 -10 0 0\n"
],
"output": [
"1 1 2\n1 2 3\n1 3 4\n",
"1 3 5\n2 5\n1 1 2\n1 2 4\n",
"2 2\n",
"2 3\n1 1 2\n1 2 4\n1 4 5\n",
"1 1 3\n1 3 4\n1 4 2\n"
]
} |
1,242 | 8 | Vasya has got an undirected graph consisting of n vertices and m edges. This graph doesn't contain any self-loops or multiple edges. Self-loop is an edge connecting a vertex to itself. Multiple edges are a pair of edges such that they connect the same pair of vertices. Since the graph is undirected, the pair of edges (1, 2) and (2, 1) is considered to be multiple edges. Isolated vertex of the graph is a vertex such that there is no edge connecting this vertex to any other vertex.
Vasya wants to know the minimum and maximum possible number of isolated vertices in an undirected graph consisting of n vertices and m edges.
Input
The only line contains two integers n and m~(1 ≤ n ≤ 10^5, 0 ≤ m ≤ (n (n - 1))/(2)).
It is guaranteed that there exists a graph without any self-loops or multiple edges with such number of vertices and edges.
Output
In the only line print two numbers min and max — the minimum and maximum number of isolated vertices, respectively.
Examples
Input
4 2
Output
0 1
Input
3 1
Output
1 1
Note
In the first example it is possible to construct a graph with 0 isolated vertices: for example, it should contain edges (1, 2) and (3, 4). To get one isolated vertex, we may construct a graph with edges (1, 2) and (1, 3).
In the second example the graph will always contain exactly one isolated vertex. | def line():
return map(int, input().split())
from math import sqrt, ceil
n,m = line()
print(max(0, n-2*m), n if m==0 else n-ceil((sqrt(m*8+1)+1)/2))
| {
"input": [
"3 1\n",
"4 2\n"
],
"output": [
"1 1\n",
"0 1\n"
]
} |
1,243 | 12 | Lunar New Year is approaching, and Bob received a gift from his friend recently — a recursive sequence! He loves this sequence very much and wants to play with it.
Let f_1, f_2, …, f_i, … be an infinite sequence of positive integers. Bob knows that for i > k, f_i can be obtained by the following recursive equation:
$$$f_i = \left(f_{i - 1} ^ {b_1} ⋅ f_{i - 2} ^ {b_2} ⋅ ⋅⋅⋅ ⋅ f_{i - k} ^ {b_k}\right) mod p,$$$
which in short is
$$$f_i = \left(∏_{j = 1}^{k} f_{i - j}^{b_j}\right) mod p,$$$
where p = 998 244 353 (a widely-used prime), b_1, b_2, …, b_k are known integer constants, and x mod y denotes the remainder of x divided by y.
Bob lost the values of f_1, f_2, …, f_k, which is extremely troublesome – these are the basis of the sequence! Luckily, Bob remembers the first k - 1 elements of the sequence: f_1 = f_2 = … = f_{k - 1} = 1 and the n-th element: f_n = m. Please find any possible value of f_k. If no solution exists, just tell Bob that it is impossible to recover his favorite sequence, regardless of Bob's sadness.
Input
The first line contains a positive integer k (1 ≤ k ≤ 100), denoting the length of the sequence b_1, b_2, …, b_k.
The second line contains k positive integers b_1, b_2, …, b_k (1 ≤ b_i < p).
The third line contains two positive integers n and m (k < n ≤ 10^9, 1 ≤ m < p), which implies f_n = m.
Output
Output a possible value of f_k, where f_k is a positive integer satisfying 1 ≤ f_k < p. If there are multiple answers, print any of them. If no such f_k makes f_n = m, output -1 instead.
It is easy to show that if there are some possible values of f_k, there must be at least one satisfying 1 ≤ f_k < p.
Examples
Input
3
2 3 5
4 16
Output
4
Input
5
4 7 1 5 6
7 14187219
Output
6
Input
8
2 3 5 6 1 7 9 10
23333 1
Output
1
Input
1
2
88888 66666
Output
-1
Input
3
998244352 998244352 998244352
4 2
Output
-1
Input
10
283 463 213 777 346 201 463 283 102 999
2333333 6263423
Output
382480067
Note
In the first sample, we have f_4 = f_3^2 ⋅ f_2^3 ⋅ f_1^5. Therefore, applying f_3 = 4, we have f_4 = 16. Note that there can be multiple answers.
In the third sample, applying f_7 = 1 makes f_{23333} = 1.
In the fourth sample, no such f_1 makes f_{88888} = 66666. Therefore, we output -1 instead. | from math import ceil, sqrt
p = 998244353
def bsgs(g, h):
'''
Solve for x in h = g^x mod p given a prime p.
'''
N = ceil(sqrt(p - 1)) # phi(p) is p-1 if p is prime
# Store hashmap of g^{1...m} (mod p). Baby step.
tbl = {pow(g, i, p): i for i in range(N)}
# Precompute via Fermat's Little Theorem
c = pow(g, N * (p - 2), p)
# Search for an equivalence in the table. Giant step.
for j in range(N):
y = (h * pow(c, j, p)) % p
if y in tbl:
return j * N + tbl[y]
def gcd(a, b):
return b if a % b == 0 else gcd(b, a % b)
def xgcd(a, b):
"""return (g, x, y) such that a*x + b*y = g = gcd(x, y)"""
x0, x1, y0, y1 = 0, 1, 1, 0
while a != 0:
q, b, a = b // a, a, b % a
y0, y1 = y1, y0 - q * y1
x0, x1 = x1, x0 - q * x1
return b, x0, y0
def inv(a, m):
g, x, y = xgcd(a, m)
if g != 1:
return None
return (x + m) % m
# solve a = bx (mod m)
def div(a, b, m):
k = gcd(b, m)
if a % k != 0:
return None
ak = a // k
bk = b // k
mk = m // k
inv_bk = inv(bk, mk)
return (ak * inv_bk) % mk
def matmul(A, B):
m = len(A)
C = [[0 for _ in range(m)] for _ in range(m)]
for i in range(m):
for k in range(m):
for j in range(m):
C[i][j] += A[i][k]*B[k][j] % (p-1)
for i in range(m):
for j in range(m):
C[i][j] %= (p-1)
return C
def Id(n):
return [[int(i == j) for i in range(n)] for j in range(n)]
def matexp(A, n):
if n == 0:
return Id(len(A))
h = matexp(A, n//2)
R = matmul(h, h)
if n % 2 == 1:
R = matmul(A, R)
return R
def solve():
k = int(input())
A = [[0 for _ in range(k)] for _ in range(k)]
A[0] = [int(x) for x in input().split()]
for i in range(k-1):
A[i+1][i] = 1
n, v = [int(x) for x in input().split()]
e = matexp(A, n-k)[0][0]
g = 3
u = bsgs(g, v)
x = div(u, e, p-1)
if x is not None:
print(pow(g, x, p))
else:
print(-1)
if __name__ == '__main__':
solve()
| {
"input": [
"1\n2\n88888 66666\n",
"10\n283 463 213 777 346 201 463 283 102 999\n2333333 6263423\n",
"8\n2 3 5 6 1 7 9 10\n23333 1\n",
"3\n998244352 998244352 998244352\n4 2\n",
"5\n4 7 1 5 6\n7 14187219\n",
"3\n2 3 5\n4 16\n"
],
"output": [
"-1\n",
"382480067\n",
"1\n",
"-1\n",
"6\n",
"4\n"
]
} |
1,244 | 12 | You are given an undirected unweighted connected graph consisting of n vertices and m edges. It is guaranteed that there are no self-loops or multiple edges in the given graph.
Your task is to find any spanning tree of this graph such that the degree of the first vertex (vertex with label 1 on it) is equal to D (or say that there are no such spanning trees). Recall that the degree of a vertex is the number of edges incident to it.
Input
The first line contains three integers n, m and D (2 ≤ n ≤ 2 ⋅ 10^5, n - 1 ≤ m ≤ min(2 ⋅ 10^5, (n(n-1))/(2)), 1 ≤ D < n) — the number of vertices, the number of edges and required degree of the first vertex, respectively.
The following m lines denote edges: edge i is represented by a pair of integers v_i, u_i (1 ≤ v_i, u_i ≤ n, u_i ≠ v_i), which are the indices of vertices connected by the edge. There are no loops or multiple edges in the given graph, i. e. for each pair (v_i, u_i) there are no other pairs (v_i, u_i) or (u_i, v_i) in the list of edges, and for each pair (v_i, u_i) the condition v_i ≠ u_i is satisfied.
Output
If there is no spanning tree satisfying the condition from the problem statement, print "NO" in the first line.
Otherwise print "YES" in the first line and then print n-1 lines describing the edges of a spanning tree such that the degree of the first vertex (vertex with label 1 on it) is equal to D. Make sure that the edges of the printed spanning tree form some subset of the input edges (order doesn't matter and edge (v, u) is considered the same as the edge (u, v)).
If there are multiple possible answers, print any of them.
Examples
Input
4 5 1
1 2
1 3
1 4
2 3
3 4
Output
YES
2 1
2 3
3 4
Input
4 5 3
1 2
1 3
1 4
2 3
3 4
Output
YES
1 2
1 3
4 1
Input
4 4 3
1 2
1 4
2 3
3 4
Output
NO
Note
The picture corresponding to the first and second examples: <image>
The picture corresponding to the third example: <image> | import collections as cc
import math as mt
import sys
I=lambda:list(map(int,input().split()))
def find(u):
while u!=parent[u]:
u=parent[u]
return u
def union(u,v):
a=find(u)
b=find(v)
if a!=b:
parent[a]=parent[b]=min(a,b)
n,m,d=I()
uu=set()
uu.add(1)
parent=[i for i in range(n+1)]
g=cc.defaultdict(list)
on=[]
tf=cc.defaultdict(int)
other=[]
for i in range(m):
x,y=sorted(I())
g[x].append(y)
g[y].append(x)
if x!=1 and y!=1:
other.append([x,y])
union(x,y)
temp=g[1]
con=[find(i) for i in set(temp)]
if len(set(con))>d or len(set(temp))<d:
print("NO")
sys.exit()
else:
print("YES")
used=cc.defaultdict(int)
ans=[]
st=cc.deque()
use=[0]*(n+1)
use[1]=1
j=0
for i in range(len(temp)):
if not used[find(temp[i])]:
used[find(temp[i])]=1
ans.append([1,temp[i]])
st.append(temp[i])
use[temp[i]]=1
d-=1
for i in range(d):
while use[temp[j]]==1:
j+=1
ans.append([1,temp[j]])
st.append(temp[j])
use[temp[j]]=1
while st:
x=st.popleft()
use[x]=1
for y in g[x]:
if not use[y]:
ans.append([x,y])
st.append(y)
use[y]=1
for i in ans:
print(*i)
| {
"input": [
"4 5 1\n1 2\n1 3\n1 4\n2 3\n3 4\n",
"4 4 3\n1 2\n1 4\n2 3\n3 4\n",
"4 5 3\n1 2\n1 3\n1 4\n2 3\n3 4\n"
],
"output": [
"YES\n1 2\n2 3\n3 4\n",
"NO\n",
"YES\n1 2\n1 3\n1 4\n"
]
} |
1,245 | 10 | There is a robot staying at X=0 on the Ox axis. He has to walk to X=n. You are controlling this robot and controlling how he goes. The robot has a battery and an accumulator with a solar panel.
The i-th segment of the path (from X=i-1 to X=i) can be exposed to sunlight or not. The array s denotes which segments are exposed to sunlight: if segment i is exposed, then s_i = 1, otherwise s_i = 0.
The robot has one battery of capacity b and one accumulator of capacity a. For each segment, you should choose which type of energy storage robot will use to go to the next point (it can be either battery or accumulator). If the robot goes using the battery, the current charge of the battery is decreased by one (the robot can't use the battery if its charge is zero). And if the robot goes using the accumulator, the current charge of the accumulator is decreased by one (and the robot also can't use the accumulator if its charge is zero).
If the current segment is exposed to sunlight and the robot goes through it using the battery, the charge of the accumulator increases by one (of course, its charge can't become higher than it's maximum capacity).
If accumulator is used to pass some segment, its charge decreases by 1 no matter if the segment is exposed or not.
You understand that it is not always possible to walk to X=n. You want your robot to go as far as possible. Find the maximum number of segments of distance the robot can pass if you control him optimally.
Input
The first line of the input contains three integers n, b, a (1 ≤ n, b, a ≤ 2 ⋅ 10^5) — the robot's destination point, the battery capacity and the accumulator capacity, respectively.
The second line of the input contains n integers s_1, s_2, ..., s_n (0 ≤ s_i ≤ 1), where s_i is 1 if the i-th segment of distance is exposed to sunlight, and 0 otherwise.
Output
Print one integer — the maximum number of segments the robot can pass if you control him optimally.
Examples
Input
5 2 1
0 1 0 1 0
Output
5
Input
6 2 1
1 0 0 1 0 1
Output
3
Note
In the first example the robot can go through the first segment using the accumulator, and charge levels become b=2 and a=0. The second segment can be passed using the battery, and charge levels become b=1 and a=1. The third segment can be passed using the accumulator, and charge levels become b=1 and a=0. The fourth segment can be passed using the battery, and charge levels become b=0 and a=1. And the fifth segment can be passed using the accumulator.
In the second example the robot can go through the maximum number of segments using battery two times and accumulator one time in any order. | def line():
return map(int, input().split())
n,b,a0 = line()
a=a0
ss = line()
for i, s in enumerate(ss):
if s and a<a0 and b>0:
b-=1
a+=1
elif a>0:
a-=1
else:
b-=1
if a<=0 and b<=0:
print(i+1)
break
else:
print(n)
| {
"input": [
"5 2 1\n0 1 0 1 0\n",
"6 2 1\n1 0 0 1 0 1\n"
],
"output": [
"5\n",
"3\n"
]
} |
1,246 | 8 | You are given an array a consisting of n integers a_1, a_2, ... , a_n.
In one operation you can choose two elements of the array and replace them with the element equal to their sum (it does not matter where you insert the new element). For example, from the array [2, 1, 4] you can obtain the following arrays: [3, 4], [1, 6] and [2, 5].
Your task is to find the maximum possible number of elements divisible by 3 that are in the array after performing this operation an arbitrary (possibly, zero) number of times.
You have to answer t independent queries.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of queries.
The first line of each query contains one integer n (1 ≤ n ≤ 100).
The second line of each query contains n integers a_1, a_2, ... , a_n (1 ≤ a_i ≤ 10^9).
Output
For each query print one integer in a single line — the maximum possible number of elements divisible by 3 that are in the array after performing described operation an arbitrary (possibly, zero) number of times.
Example
Input
2
5
3 1 2 3 1
7
1 1 1 1 1 2 2
Output
3
3
Note
In the first query of the example you can apply the following sequence of operations to obtain 3 elements divisible by 3: [3, 1, 2, 3, 1] → [3, 3, 3, 1].
In the second query you can obtain 3 elements divisible by 3 with the following sequence of operations: [1, 1, 1, 1, 1, 2, 2] → [1, 1, 1, 1, 2, 3] → [1, 1, 1, 3, 3] → [2, 1, 3, 3] → [3, 3, 3]. | def f():
input()
a=[0]*3
for i in map(int,input().split()):
a[i%3]+=1
x=min(a[1:])
print(a[0]+x+(a[1]+a[2]-2*x)//3)
for i in range(int(input())):
f() | {
"input": [
"2\n5\n3 1 2 3 1\n7\n1 1 1 1 1 2 2\n"
],
"output": [
"3\n3\n"
]
} |
1,247 | 7 | Old timers of Summer Informatics School can remember previous camps in which each student was given a drink of his choice on the vechorka (late-evening meal). Or may be the story was more complicated?
There are n students living in a building, and for each of them the favorite drink a_i is known. So you know n integers a_1, a_2, ..., a_n, where a_i (1 ≤ a_i ≤ k) is the type of the favorite drink of the i-th student. The drink types are numbered from 1 to k.
There are infinite number of drink sets. Each set consists of exactly two portions of the same drink. In other words, there are k types of drink sets, the j-th type contains two portions of the drink j. The available number of sets of each of the k types is infinite.
You know that students will receive the minimum possible number of sets to give all students exactly one drink. Obviously, the number of sets will be exactly ⌈ n/2 ⌉, where ⌈ x ⌉ is x rounded up.
After students receive the sets, they will distribute their portions by their choice: each student will get exactly one portion. Note, that if n is odd then one portion will remain unused and the students' teacher will drink it.
What is the maximum number of students that can get their favorite drink if ⌈ n/2 ⌉ sets will be chosen optimally and students will distribute portions between themselves optimally?
Input
The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000) — the number of students in the building and the number of different drinks.
The next n lines contain student's favorite drinks. The i-th line contains a single integer from 1 to k — the type of the favorite drink of the i-th student.
Output
Print exactly one integer — the maximum number of students that can get a favorite drink.
Examples
Input
5 3
1
3
1
1
2
Output
4
Input
10 3
2
1
3
2
3
3
1
3
1
2
Output
9
Note
In the first example, students could choose three sets with drinks 1, 1 and 2 (so they will have two sets with two drinks of the type 1 each and one set with two drinks of the type 2, so portions will be 1, 1, 1, 1, 2, 2). This way all students except the second one will get their favorite drinks.
Another possible answer is sets with drinks 1, 2 and 3. In this case the portions will be 1, 1, 2, 2, 3, 3. Then all the students except one will gain their favorite drinks. The only student that will not gain the favorite drink will be a student with a_i = 1 (i.e. the first, the third or the fourth). | def gns():
return list(map(int,input().split()))
n,k=gns()
ks=[0]*k
for i in range(n):
x=int(input())-1
ks[x]+=1
ans=0
for i in range(k):
ans+=ks[i]//2*2
re=n-ans
print(ans+(re+1)//2) | {
"input": [
"5 3\n1\n3\n1\n1\n2\n",
"10 3\n2\n1\n3\n2\n3\n3\n1\n3\n1\n2\n"
],
"output": [
"4\n",
"9\n"
]
} |
1,248 | 9 | You are given a system of pipes. It consists of two rows, each row consists of n pipes. The top left pipe has the coordinates (1, 1) and the bottom right — (2, n).
There are six types of pipes: two types of straight pipes and four types of curved pipes. Here are the examples of all six types:
<image> Types of pipes
You can turn each of the given pipes 90 degrees clockwise or counterclockwise arbitrary (possibly, zero) number of times (so the types 1 and 2 can become each other and types 3, 4, 5, 6 can become each other).
You want to turn some pipes in a way that the water flow can start at (1, 0) (to the left of the top left pipe), move to the pipe at (1, 1), flow somehow by connected pipes to the pipe at (2, n) and flow right to (2, n + 1).
Pipes are connected if they are adjacent in the system and their ends are connected. Here are examples of connected pipes:
<image> Examples of connected pipes
Let's describe the problem using some example:
<image> The first example input
And its solution is below:
<image> The first example answer
As you can see, the water flow is the poorly drawn blue line. To obtain the answer, we need to turn the pipe at (1, 2) 90 degrees clockwise, the pipe at (2, 3) 90 degrees, the pipe at (1, 6) 90 degrees, the pipe at (1, 7) 180 degrees and the pipe at (2, 7) 180 degrees. Then the flow of water can reach (2, n + 1) from (1, 0).
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^4) — the number of queries. Then q queries follow.
Each query consists of exactly three lines. The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of pipes in each row. The next two lines contain a description of the first and the second rows correspondingly. Each row description consists of n digits from 1 to 6 without any whitespaces between them, each digit corresponds to the type of pipe in the corresponding cell. See the problem statement to understand which digits correspond to which types of pipes.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For the i-th query print the answer for it — "YES" (without quotes) if it is possible to turn some pipes in a way that the water flow can reach (2, n + 1) from (1, 0), and "NO" otherwise.
Example
Input
6
7
2323216
1615124
1
3
4
2
13
24
2
12
34
3
536
345
2
46
54
Output
YES
YES
YES
NO
YES
NO
Note
The first query from the example is described in the problem statement. | from sys import stdin
def main():
l = stdin.read().splitlines()
l, l1 = l[2::3], l[3::3]
for i, ab in enumerate(zip(l, l1)):
p = 4
for a, b in zip(*ab):
p = (0, 0, 0, 0, 8, 0, 4, 4, 4, 8, 0, 8)[(a < '3') * 2 + (b < '3') + p]
l[i] = ('NO', 'YES')[p == 8]
print('\n'.join(l))
if __name__ == '__main__':
main()
| {
"input": [
"6\n7\n2323216\n1615124\n1\n3\n4\n2\n13\n24\n2\n12\n34\n3\n536\n345\n2\n46\n54\n"
],
"output": [
"YES\nYES\nYES\nNO\nYES\nNO\n"
]
} |
1,249 | 8 | The Central Company has an office with a sophisticated security system. There are 10^6 employees, numbered from 1 to 10^6.
The security system logs entrances and departures. The entrance of the i-th employee is denoted by the integer i, while the departure of the i-th employee is denoted by the integer -i.
The company has some strict rules about access to its office:
* An employee can enter the office at most once per day.
* He obviously can't leave the office if he didn't enter it earlier that day.
* In the beginning and at the end of every day, the office is empty (employees can't stay at night). It may also be empty at any moment of the day.
Any array of events satisfying these conditions is called a valid day.
Some examples of valid or invalid days:
* [1, 7, -7, 3, -1, -3] is a valid day (1 enters, 7 enters, 7 leaves, 3 enters, 1 leaves, 3 leaves).
* [2, -2, 3, -3] is also a valid day.
* [2, 5, -5, 5, -5, -2] is not a valid day, because 5 entered the office twice during the same day.
* [-4, 4] is not a valid day, because 4 left the office without being in it.
* [4] is not a valid day, because 4 entered the office and didn't leave it before the end of the day.
There are n events a_1, a_2, …, a_n, in the order they occurred. This array corresponds to one or more consecutive days. The system administrator erased the dates of events by mistake, but he didn't change the order of the events.
You must partition (to cut) the array a of events into contiguous subarrays, which must represent non-empty valid days (or say that it's impossible). Each array element should belong to exactly one contiguous subarray of a partition. Each contiguous subarray of a partition should be a valid day.
For example, if n=8 and a=[1, -1, 1, 2, -1, -2, 3, -3] then he can partition it into two contiguous subarrays which are valid days: a = [1, -1~ \boldsymbol{|}~ 1, 2, -1, -2, 3, -3].
Help the administrator to partition the given array a in the required way or report that it is impossible to do. Find any required partition, you should not minimize or maximize the number of parts.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5).
The second line contains n integers a_1, a_2, …, a_n (-10^6 ≤ a_i ≤ 10^6 and a_i ≠ 0).
Output
If there is no valid partition, print -1. Otherwise, print any valid partition in the following format:
* On the first line print the number d of days (1 ≤ d ≤ n).
* On the second line, print d integers c_1, c_2, …, c_d (1 ≤ c_i ≤ n and c_1 + c_2 + … + c_d = n), where c_i is the number of events in the i-th day.
If there are many valid solutions, you can print any of them. You don't have to minimize nor maximize the number of days.
Examples
Input
6
1 7 -7 3 -1 -3
Output
1
6
Input
8
1 -1 1 2 -1 -2 3 -3
Output
2
2 6
Input
6
2 5 -5 5 -5 -2
Output
-1
Input
3
-8 1 1
Output
-1
Note
In the first example, the whole array is a valid day.
In the second example, one possible valid solution is to split the array into [1, -1] and [1, 2, -1, -2, 3, -3] (d = 2 and c = [2, 6]). The only other valid solution would be to split the array into [1, -1], [1, 2, -1, -2] and [3, -3] (d = 3 and c = [2, 4, 2]). Both solutions are accepted.
In the third and fourth examples, we can prove that there exists no valid solution. Please note that the array given in input is not guaranteed to represent a coherent set of events. | def solve(n,L):
s=set()
w=set()
r=[]
count=0
for i in L:
count+=1
if i < 0:
if -i not in s:
print(-1)
return
s.remove(-i)
if len(s)==0:
r.append(count)
w=set()
count=0
else:
if i in w:
print(-1)
return
s.add(i)
w.add(i)
if len(s)!=0:
print(-1)
return
print(len(r))
print(*r)
n=int(input())
L=list(map(int,input().split()))
solve(n,L)
| {
"input": [
"3\n-8 1 1\n",
"8\n1 -1 1 2 -1 -2 3 -3\n",
"6\n1 7 -7 3 -1 -3\n",
"6\n2 5 -5 5 -5 -2\n"
],
"output": [
"-1\n",
"3\n2 4 2 \n",
"1\n6 \n",
"-1\n"
]
} |
1,250 | 7 | Hooray! Polycarp turned n years old! The Technocup Team sincerely congratulates Polycarp!
Polycarp celebrated all of his n birthdays: from the 1-th to the n-th. At the moment, he is wondering: how many times he turned beautiful number of years?
According to Polycarp, a positive integer is beautiful if it consists of only one digit repeated one or more times. For example, the following numbers are beautiful: 1, 77, 777, 44 and 999999. The following numbers are not beautiful: 12, 11110, 6969 and 987654321.
Of course, Polycarpus uses the decimal numeral system (i.e. radix is 10).
Help Polycarpus to find the number of numbers from 1 to n (inclusive) that are beautiful.
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.
Each test case consists of one line, which contains a positive integer n (1 ≤ n ≤ 10^9) — how many years Polycarp has turned.
Output
Print t integers — the answers to the given test cases in the order they are written in the test. Each answer is an integer: the number of beautiful years between 1 and n, inclusive.
Example
Input
6
18
1
9
100500
33
1000000000
Output
10
1
9
45
12
81
Note
In the first test case of the example beautiful years are 1, 2, 3, 4, 5, 6, 7, 8, 9 and 11. | def func(n):
l=len(str(n))
sum=9*(l-1)
if n>=int("1"*l):
sum+=n//int("1"*l)
return sum
t=int(input())
for _ in range(t):
n=int(input())
print(func(n)) | {
"input": [
"6\n18\n1\n9\n100500\n33\n1000000000\n"
],
"output": [
"10\n1\n9\n45\n12\n81\n"
]
} |
1,251 | 8 | The map of Bertown can be represented as a set of n intersections, numbered from 1 to n and connected by m one-way roads. It is possible to move along the roads from any intersection to any other intersection. The length of some path from one intersection to another is the number of roads that one has to traverse along the path. The shortest path from one intersection v to another intersection u is the path that starts in v, ends in u and has the minimum length among all such paths.
Polycarp lives near the intersection s and works in a building near the intersection t. Every day he gets from s to t by car. Today he has chosen the following path to his workplace: p_1, p_2, ..., p_k, where p_1 = s, p_k = t, and all other elements of this sequence are the intermediate intersections, listed in the order Polycarp arrived at them. Polycarp never arrived at the same intersection twice, so all elements of this sequence are pairwise distinct. Note that you know Polycarp's path beforehand (it is fixed), and it is not necessarily one of the shortest paths from s to t.
Polycarp's car has a complex navigation system installed in it. Let's describe how it works. When Polycarp starts his journey at the intersection s, the system chooses some shortest path from s to t and shows it to Polycarp. Let's denote the next intersection in the chosen path as v. If Polycarp chooses to drive along the road from s to v, then the navigator shows him the same shortest path (obviously, starting from v as soon as he arrives at this intersection). However, if Polycarp chooses to drive to another intersection w instead, the navigator rebuilds the path: as soon as Polycarp arrives at w, the navigation system chooses some shortest path from w to t and shows it to Polycarp. The same process continues until Polycarp arrives at t: if Polycarp moves along the road recommended by the system, it maintains the shortest path it has already built; but if Polycarp chooses some other path, the system rebuilds the path by the same rules.
Here is an example. Suppose the map of Bertown looks as follows, and Polycarp drives along the path [1, 2, 3, 4] (s = 1, t = 4):
Check the picture by the link [http://tk.codeforces.com/a.png](//tk.codeforces.com/a.png)
1. When Polycarp starts at 1, the system chooses some shortest path from 1 to 4. There is only one such path, it is [1, 5, 4];
2. Polycarp chooses to drive to 2, which is not along the path chosen by the system. When Polycarp arrives at 2, the navigator rebuilds the path by choosing some shortest path from 2 to 4, for example, [2, 6, 4] (note that it could choose [2, 3, 4]);
3. Polycarp chooses to drive to 3, which is not along the path chosen by the system. When Polycarp arrives at 3, the navigator rebuilds the path by choosing the only shortest path from 3 to 4, which is [3, 4];
4. Polycarp arrives at 4 along the road chosen by the navigator, so the system does not have to rebuild anything.
Overall, we get 2 rebuilds in this scenario. Note that if the system chose [2, 3, 4] instead of [2, 6, 4] during the second step, there would be only 1 rebuild (since Polycarp goes along the path, so the system maintains the path [3, 4] during the third step).
The example shows us that the number of rebuilds can differ even if the map of Bertown and the path chosen by Polycarp stays the same. Given this information (the map and Polycarp's path), can you determine the minimum and the maximum number of rebuilds that could have happened during the journey?
Input
The first line contains two integers n and m (2 ≤ n ≤ m ≤ 2 ⋅ 10^5) — the number of intersections and one-way roads in Bertown, respectively.
Then m lines follow, each describing a road. Each line contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting a road from intersection u to intersection v. All roads in Bertown are pairwise distinct, which means that each ordered pair (u, v) appears at most once in these m lines (but if there is a road (u, v), the road (v, u) can also appear).
The following line contains one integer k (2 ≤ k ≤ n) — the number of intersections in Polycarp's path from home to his workplace.
The last line contains k integers p_1, p_2, ..., p_k (1 ≤ p_i ≤ n, all these integers are pairwise distinct) — the intersections along Polycarp's path in the order he arrived at them. p_1 is the intersection where Polycarp lives (s = p_1), and p_k is the intersection where Polycarp's workplace is situated (t = p_k). It is guaranteed that for every i ∈ [1, k - 1] the road from p_i to p_{i + 1} exists, so the path goes along the roads of Bertown.
Output
Print two integers: the minimum and the maximum number of rebuilds that could have happened during the journey.
Examples
Input
6 9
1 5
5 4
1 2
2 3
3 4
4 1
2 6
6 4
4 2
4
1 2 3 4
Output
1 2
Input
7 7
1 2
2 3
3 4
4 5
5 6
6 7
7 1
7
1 2 3 4 5 6 7
Output
0 0
Input
8 13
8 7
8 6
7 5
7 4
6 5
6 4
5 3
5 2
4 3
4 2
3 1
2 1
1 8
5
8 7 5 2 1
Output
0 3 | from collections import defaultdict
n, m = map(int, input().split())
adj = defaultdict(list)
rev = defaultdict(list)
dist = {}
for _ in range(m):
u, v = map(int, input().split())
adj[u].append(v)
rev[v].append(u)
k = int(input())
path = list(map(int, input().split()))
dt = {}
def bfs(t):
q = [t]
dt[t] = 0
while q:
c = q.pop(0)
for y in rev[c]:
if y not in dt:
dt[y] = dt[c] + 1
q.append(y)
min_rebuild = 0
max_rebuild = 0
bfs(path[k - 1])
for i in range(1, k - 1):
v = path[i - 1]
u = path[i]
if dt[u] + 1 > dt[v]:
min_rebuild += 1
max_rebuild += 1
elif dt[u] + 1 == dt[v]:
for w in adj[v]:
if u != w and dt[u] == dt[w]:
max_rebuild += 1
break
print(min_rebuild, max_rebuild) | {
"input": [
"7 7\n1 2\n2 3\n3 4\n4 5\n5 6\n6 7\n7 1\n7\n1 2 3 4 5 6 7\n",
"8 13\n8 7\n8 6\n7 5\n7 4\n6 5\n6 4\n5 3\n5 2\n4 3\n4 2\n3 1\n2 1\n1 8\n5\n8 7 5 2 1\n",
"6 9\n1 5\n5 4\n1 2\n2 3\n3 4\n4 1\n2 6\n6 4\n4 2\n4\n1 2 3 4\n"
],
"output": [
"0 0\n",
"0 3\n",
"1 2\n"
]
} |
1,252 | 11 | Consider the infinite sequence s of positive integers, created by repeating the following steps:
1. Find the lexicographically smallest triple of positive integers (a, b, c) such that
* a ⊕ b ⊕ c = 0, where ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
* a, b, c are not in s.
Here triple of integers (a_1, b_1, c_1) is considered to be lexicographically smaller than triple (a_2, b_2, c_2) if sequence [a_1, b_1, c_1] is lexicographically smaller than sequence [a_2, b_2, c_2].
2. Append a, b, c to s in this order.
3. Go back to the first step.
You have integer n. Find the n-th element of s.
You have to answer t independent test cases.
A sequence a is lexicographically smaller than a sequence b if in the first position where a and b differ, the sequence a has a smaller element than the corresponding element in b.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases.
Each of the next t lines contains a single integer n (1≤ n ≤ 10^{16}) — the position of the element you want to know.
Output
In each of the t lines, output the answer to the corresponding test case.
Example
Input
9
1
2
3
4
5
6
7
8
9
Output
1
2
3
4
8
12
5
10
15
Note
The first elements of s are 1, 2, 3, 4, 8, 12, 5, 10, 15, ... | from bisect import bisect
subst = [0, 2, 3, 1]
pows = [4**i for i in range(28)]
def nxt(x):
temp = []
while(x):
temp.append(x % 4)
x //= 4
res = 0
for v in temp[::-1]:
res = res * 4 + subst[v]
return res
def task(x):
y = x - (x-1) % 3
r = pows[bisect(pows, y) - 1]
z = y - (y-r) // 3 * 2
for _ in range(x-y):
z = nxt(z)
return z
for _ in range(int(input())):
print(task(int(input()))) | {
"input": [
"9\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"
],
"output": [
"1\n2\n3\n4\n8\n12\n5\n10\n15\n"
]
} |
1,253 | 7 | Today Johnny wants to increase his contribution. His plan assumes writing n blogs. One blog covers one topic, but one topic can be covered by many blogs. Moreover, some blogs have references to each other. Each pair of blogs that are connected by a reference has to cover different topics because otherwise, the readers can notice that they are split just for more contribution. Set of blogs and bidirectional references between some pairs of them is called blogs network.
There are n different topics, numbered from 1 to n sorted by Johnny's knowledge. The structure of the blogs network is already prepared. Now Johnny has to write the blogs in some order. He is lazy, so each time before writing a blog, he looks at it's already written neighbors (the blogs referenced to current one) and chooses the topic with the smallest number which is not covered by neighbors. It's easy to see that this strategy will always allow him to choose a topic because there are at most n - 1 neighbors.
For example, if already written neighbors of the current blog have topics number 1, 3, 1, 5, and 2, Johnny will choose the topic number 4 for the current blog, because topics number 1, 2 and 3 are already covered by neighbors and topic number 4 isn't covered.
As a good friend, you have done some research and predicted the best topic for each blog. Can you tell Johnny, in which order he has to write the blogs, so that his strategy produces the topic assignment chosen by you?
Input
The first line contains two integers n (1 ≤ n ≤ 5 ⋅ 10^5) and m (0 ≤ m ≤ 5 ⋅ 10^5) — the number of blogs and references, respectively.
Each of the following m lines contains two integers a and b (a ≠ b; 1 ≤ a, b ≤ n), which mean that there is a reference between blogs a and b. It's guaranteed that the graph doesn't contain multiple edges.
The last line contains n integers t_1, t_2, …, t_n, i-th of them denotes desired topic number of the i-th blog (1 ≤ t_i ≤ n).
Output
If the solution does not exist, then write -1. Otherwise, output n distinct integers p_1, p_2, …, p_n (1 ≤ p_i ≤ n), which describe the numbers of blogs in order which Johnny should write them. If there are multiple answers, print any.
Examples
Input
3 3
1 2
2 3
3 1
2 1 3
Output
2 1 3
Input
3 3
1 2
2 3
3 1
1 1 1
Output
-1
Input
5 3
1 2
2 3
4 5
2 1 2 2 1
Output
2 5 1 3 4
Note
In the first example, Johnny starts with writing blog number 2, there are no already written neighbors yet, so it receives the first topic. Later he writes blog number 1, it has reference to the already written second blog, so it receives the second topic. In the end, he writes blog number 3, it has references to blogs number 1 and 2 so it receives the third topic.
Second example: There does not exist any permutation fulfilling given conditions.
Third example: First Johnny writes blog 2, it receives the topic 1. Then he writes blog 5, it receives the topic 1 too because it doesn't have reference to single already written blog 2. Then he writes blog number 1, it has reference to blog number 2 with topic 1, so it receives the topic 2. Then he writes blog number 3 which has reference to blog 2, so it receives the topic 2. Then he ends with writing blog number 4 which has reference to blog 5 and receives the topic 2. | import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def f():
n, m = [int(s) for s in input().split()]
neibors = [[] for _ in range(n)]
for _ in range(m):
a, b = [int(s)-1 for s in input().split()]
neibors[a].append(b)
neibors[b].append(a)
t = [int(s) for s in input().split()]
# print(neibors)
def countSmaller(nbs,e):
s = {t[x] for x in nbs}
ans = 0
for x in s:
if x <= e:
ans += 1
return ans
smlCount = [countSmaller(neibors[i],t[i]) for i in range(n)]
# print(smlCount)
ind = list(range(n))
ind.sort(key=lambda x:t[x])
for i in ind:
if t[i]-1 != smlCount[i]:
print(-1)
return
print(' '.join(str(i+1) for i in ind))
f() | {
"input": [
"5 3\n1 2\n2 3\n4 5\n2 1 2 2 1\n",
"3 3\n1 2\n2 3\n3 1\n2 1 3\n",
"3 3\n1 2\n2 3\n3 1\n1 1 1\n"
],
"output": [
"2 5 1 3 4 ",
"2 1 3 ",
"-1\n"
]
} |
1,254 | 8 | Let a and b be two arrays of lengths n and m, respectively, with no elements in common. We can define a new array merge(a,b) of length n+m recursively as follows:
* If one of the arrays is empty, the result is the other array. That is, merge(∅,b)=b and merge(a,∅)=a. In particular, merge(∅,∅)=∅.
* If both arrays are non-empty, and a_1<b_1, then merge(a,b)=[a_1]+merge([a_2,…,a_n],b). That is, we delete the first element a_1 of a, merge the remaining arrays, then add a_1 to the beginning of the result.
* If both arrays are non-empty, and a_1>b_1, then merge(a,b)=[b_1]+merge(a,[b_2,…,b_m]). That is, we delete the first element b_1 of b, merge the remaining arrays, then add b_1 to the beginning of the result.
This algorithm has the nice property that if a and b are sorted, then merge(a,b) will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if a=[3,1] and b=[2,4], then merge(a,b)=[2,3,1,4].
A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).
There is a permutation p of length 2n. Determine if there exist two arrays a and b, each of length n and with no elements in common, so that p=merge(a,b).
Input
The first line contains a single integer t (1≤ t≤ 1000) — the number of test cases. Next 2t lines contain descriptions of test cases.
The first line of each test case contains a single integer n (1≤ n≤ 2000).
The second line of each test case contains 2n integers p_1,…,p_{2n} (1≤ p_i≤ 2n). It is guaranteed that p is a permutation.
It is guaranteed that the sum of n across all test cases does not exceed 2000.
Output
For each test case, output "YES" if there exist arrays a, b, each of length n and with no common elements, so that p=merge(a,b). Otherwise, output "NO".
Example
Input
6
2
2 3 1 4
2
3 1 2 4
4
3 2 6 1 5 7 8 4
3
1 2 3 4 5 6
4
6 1 3 7 4 5 8 2
6
4 3 2 5 1 11 9 12 8 6 10 7
Output
YES
NO
YES
YES
NO
NO
Note
In the first test case, [2,3,1,4]=merge([3,1],[2,4]).
In the second test case, we can show that [3,1,2,4] is not the merge of two arrays of length 2.
In the third test case, [3,2,6,1,5,7,8,4]=merge([3,2,8,4],[6,1,5,7]).
In the fourth test case, [1,2,3,4,5,6]=merge([1,3,6],[2,4,5]), for example. | #wtf lol
def unmerge(arr):
cnt=1
mx=arr[0]
ls=[]
for i in range(1,len(arr)):
if arr[i]>mx:
ls.append(cnt)
mx=arr[i]
cnt=1
else:
cnt+=1
if cnt:
ls.append(cnt)
dp=1
for i in ls:
dp|=dp<<i #10100101
if dp&1<<len(arr)//2: #check the halfway bit
return "YES"
return "NO"
for i in range(int(input())):
a=input()
lst=list(map(int,input().strip().split()))
print(unmerge(lst)) | {
"input": [
"6\n2\n2 3 1 4\n2\n3 1 2 4\n4\n3 2 6 1 5 7 8 4\n3\n1 2 3 4 5 6\n4\n6 1 3 7 4 5 8 2\n6\n4 3 2 5 1 11 9 12 8 6 10 7\n"
],
"output": [
"YES\nNO\nYES\nYES\nNO\nNO\n"
]
} |
1,255 | 9 | You are given an array a_1, a_2, ..., a_n where all a_i are integers and greater than 0.
In one operation, you can choose two different indices i and j (1 ≤ i, j ≤ n). If gcd(a_i, a_j) is equal to the minimum element of the whole array a, you can swap a_i and a_j. gcd(x, y) denotes the [greatest common divisor (GCD)](https://en.wikipedia.org/wiki/Greatest_common_divisor) of integers x and y.
Now you'd like to make a non-decreasing using the operation any number of times (possibly zero). Determine if you can do this.
An array a is non-decreasing if and only if a_1 ≤ a_2 ≤ … ≤ a_n.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains one integer n (1 ≤ n ≤ 10^5) — the length of array a.
The second line of each test case contains n positive integers a_1, a_2, … a_n (1 ≤ a_i ≤ 10^9) — the array itself.
It is guaranteed that the sum of n over all test cases doesn't exceed 10^5.
Output
For each test case, output "YES" if it is possible to make the array a non-decreasing using the described operation, or "NO" if it is impossible to do so.
Example
Input
4
1
8
6
4 3 6 6 2 9
4
4 5 6 7
5
7 5 2 2 4
Output
YES
YES
YES
NO
Note
In the first and third sample, the array is already non-decreasing.
In the second sample, we can swap a_1 and a_3 first, and swap a_1 and a_5 second to make the array non-decreasing.
In the forth sample, we cannot the array non-decreasing using the operation. | def solve(a,n):
p=sorted(a);s=min(a)
for i in range(n):
if a[i]!=p[i] and a[i]%s!=0:return 'NO'
return 'YES'
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
print(solve(a,n)) | {
"input": [
"4\n1\n8\n6\n4 3 6 6 2 9\n4\n4 5 6 7\n5\n7 5 2 2 4\n"
],
"output": [
"YES\nYES\nYES\nNO\n"
]
} |
1,256 | 7 | You have a knapsack with the capacity of W. There are also n items, the i-th one has weight w_i.
You want to put some of these items into the knapsack in such a way that their total weight C is at least half of its size, but (obviously) does not exceed it. Formally, C should satisfy: ⌈ W/2⌉ ≤ C ≤ W.
Output the list of items you will put into the knapsack or determine that fulfilling the conditions is impossible.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights of items in the knapsack.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4). Description of the test cases follows.
The first line of each test case contains integers n and W (1 ≤ n ≤ 200 000, 1≤ W ≤ 10^{18}).
The second line of each test case contains n integers w_1, w_2, ..., w_n (1 ≤ w_i ≤ 10^9) — weights of the items.
The sum of n over all test cases does not exceed 200 000.
Output
For each test case, if there is no solution, print a single integer -1.
If there exists a solution consisting of m items, print m in the first line of the output and m integers j_1, j_2, ..., j_m (1 ≤ j_i ≤ n, all j_i are distinct) in the second line of the output — indices of the items you would like to pack into the knapsack.
If there are several possible lists of items satisfying the conditions, you can output any. Note that you don't have to maximize the sum of weights items in the knapsack.
Example
Input
3
1 3
3
6 2
19 8 19 69 9 4
7 12
1 1 1 17 1 1 1
Output
1
1
-1
6
1 2 3 5 6 7
Note
In the first test case, you can take the item of weight 3 and fill the knapsack just right.
In the second test case, all the items are larger than the knapsack's capacity. Therefore, the answer is -1.
In the third test case, you fill the knapsack exactly in half. | import math
def solve():
n,W = map(int, input().split())
w = list(map(int, input().split()))
weight=0
index = []
for i in range(n):
if math.ceil(W/2)<=w[i]<=W:
print(1)
print(i+1)
return
if weight+w[i]<=W:
weight+=w[i]
index.append(i+1)
if math.ceil(W/2)<=weight<=W:
print(len(index))
print(*index)
else:
print("-1")
for _ in range(int(input())):
solve() | {
"input": [
"3\n1 3\n3\n6 2\n19 8 19 69 9 4\n7 12\n1 1 1 17 1 1 1\n"
],
"output": [
"1\n1 \n-1\n6\n1 2 3 5 6 7 \n"
]
} |
1,257 | 7 | Petya organized a strange birthday party. He invited n friends and assigned an integer k_i to the i-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are m unique presents available, the j-th present costs c_j dollars (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m). It's not allowed to buy a single present more than once.
For the i-th friend Petya can either buy them a present j ≤ k_i, which costs c_j dollars, or just give them c_{k_i} dollars directly.
Help Petya determine the minimum total cost of hosting his party.
Input
The first input line contains a single integer t (1 ≤ t ≤ 10^3) — the number of test cases.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of friends, and the number of unique presents available.
The following line contains n integers k_1, k_2, …, k_n (1 ≤ k_i ≤ m), assigned by Petya to his friends.
The next line contains m integers c_1, c_2, …, c_m (1 ≤ c_1 ≤ c_2 ≤ … ≤ c_m ≤ 10^9) — the prices of the presents.
It is guaranteed that sum of values n over all test cases does not exceed 3 ⋅ 10^5, and the sum of values m over all test cases does not exceed 3 ⋅ 10^5.
Output
For each test case output a single integer — the minimum cost of the party.
Examples
Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1
Note
In the first example, there are two test cases. In the first one, Petya has 5 friends and 4 available presents. Petya can spend only 30 dollars if he gives
* 5 dollars to the first friend.
* A present that costs 12 dollars to the second friend.
* A present that costs 5 dollars to the third friend.
* A present that costs 3 dollars to the fourth friend.
* 5 dollars to the fifth friend.
In the second one, Petya has 5 and 5 available presents. Petya can spend only 190 dollars if he gives
* A present that costs 10 dollars to the first friend.
* A present that costs 40 dollars to the second friend.
* 90 dollars to the third friend.
* 40 dollars to the fourth friend.
* 10 dollars to the fifth friend. | from sys import stdin
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
for _ in range(it()):
n,m=mp()
k=sorted(mp(),reverse=True)
c=mp()
# print(k)
ans=0
p=0
for i in k:
if p<i:
ans+=c[p]
p+=1
else:
ans+=c[i-1]
print(ans)
| {
"input": [
"2\n5 4\n2 3 4 3 2\n3 5 12 20\n5 5\n5 4 3 2 1\n10 40 90 160 250\n",
"1\n1 1\n1\n1\n"
],
"output": [
"\n30\n190\n",
"\n1\n"
]
} |
1,258 | 8 | You are given a multiset S initially consisting of n distinct non-negative integers. A multiset is a set, that can contain some elements multiple times.
You will perform the following operation k times:
* Add the element ⌈(a+b)/(2)⌉ (rounded up) into S, where a = \operatorname{mex}(S) and b = max(S). If this number is already in the set, it is added again.
Here \operatorname{max} of a multiset denotes the maximum integer in the multiset, and \operatorname{mex} of a multiset denotes the smallest non-negative integer that is not present in the multiset. For example:
* \operatorname{mex}(\{1,4,0,2\})=3;
* \operatorname{mex}(\{2,5,1\})=0.
Your task is to calculate the number of distinct elements in S after k operations will be done.
Input
The input consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains two integers n, k (1≤ n≤ 10^5, 0≤ k≤ 10^9) — the initial size of the multiset S and how many operations you need to perform.
The second line of each test case contains n distinct integers a_1,a_2,...,a_n (0≤ a_i≤ 10^9) — the numbers in the initial multiset.
It is guaranteed that the sum of n over all test cases does not exceed 10^5.
Output
For each test case, print the number of distinct elements in S after k operations will be done.
Example
Input
5
4 1
0 1 3 4
3 1
0 1 4
3 0
0 1 4
3 2
0 1 2
3 2
1 2 3
Output
4
4
3
5
3
Note
In the first test case, S=\{0,1,3,4\}, a=\operatorname{mex}(S)=2, b=max(S)=4, ⌈(a+b)/(2)⌉=3. So 3 is added into S, and S becomes \{0,1,3,3,4\}. The answer is 4.
In the second test case, S=\{0,1,4\}, a=\operatorname{mex}(S)=2, b=max(S)=4, ⌈(a+b)/(2)⌉=3. So 3 is added into S, and S becomes \{0,1,3,4\}. The answer is 4. | def main():
for _ in range(int(input())):
n, k = map(int, input().split())
l = sorted(map(int, input().split()))
for i, a in enumerate(l):
if a != i:
if k:
k = (((i + l[-1] + 1) // 2) not in l)
break
print(n + k)
if __name__ == '__main__':
main()
| {
"input": [
"5\n4 1\n0 1 3 4\n3 1\n0 1 4\n3 0\n0 1 4\n3 2\n0 1 2\n3 2\n1 2 3\n"
],
"output": [
"\n4\n4\n3\n5\n3\n"
]
} |
1,259 | 11 | There are n points on an infinite plane. The i-th point has coordinates (x_i, y_i) such that x_i > 0 and y_i > 0. The coordinates are not necessarily integer.
In one move you perform the following operations:
* choose two points a and b (a ≠ b);
* move point a from (x_a, y_a) to either (x_a + 1, y_a) or (x_a, y_a + 1);
* move point b from (x_b, y_b) to either (x_b + 1, y_b) or (x_b, y_b + 1);
* remove points a and b.
However, the move can only be performed if there exists a line that passes through the new coordinates of a, new coordinates of b and (0, 0).
Otherwise, the move can't be performed and the points stay at their original coordinates (x_a, y_a) and (x_b, y_b), respectively.
The numeration of points does not change after some points are removed. Once the points are removed, they can't be chosen in any later moves. Note that you have to move both points during the move, you can't leave them at their original coordinates.
What is the maximum number of moves you can perform? What are these moves?
If there are multiple answers, you can print any of them.
Input
The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The i-th of the next n lines contains four integers a_i, b_i, c_i, d_i (1 ≤ a_i, b_i, c_i, d_i ≤ 10^9). The coordinates of the i-th point are x_i = (a_i)/(b_i) and y_i = (c_i)/(d_i).
Output
In the first line print a single integer c — the maximum number of moves you can perform.
Each of the next c lines should contain a description of a move: two integers a and b (1 ≤ a, b ≤ n, a ≠ b) — the points that are removed during the current move. There should be a way to move points a and b according to the statement so that there's a line that passes through the new coordinates of a, the new coordinates of b and (0, 0). No removed point can be chosen in a later move.
If there are multiple answers, you can print any of them. You can print the moves and the points in the move in the arbitrary order.
Examples
Input
7
4 1 5 1
1 1 1 1
3 3 3 3
1 1 4 1
6 1 1 1
5 1 4 1
6 1 1 1
Output
3
1 6
2 4
5 7
Input
4
2 1 1 1
1 1 2 1
2 1 1 2
1 2 1 2
Output
1
1 2
Input
4
182 168 60 96
78 72 45 72
69 21 144 63
148 12 105 6
Output
1
2 4
Note
Here are the points and the moves for the ones that get chosen for the moves from the first example:
<image> | import io
import os
from collections import defaultdict
from math import gcd
from types import GeneratorType
# From https://github.com/cheran-senthil/PyRival/blob/master/pyrival/misc/bootstrap.py
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def solve(N, points):
compress = defaultdict(lambda: len(compress))
edges = []
for i, (a, b, c, d) in enumerate(points):
edge = []
for dx, dy in [(0, 1), (1, 0)]:
x, y = (a * d + d * b * dx, c * b + d * b * dy)
g = gcd(x, y)
x //= g
y //= g
edge.append(compress[(x, y)])
edges.append(edge)
# Each line is a node in the graph
# Each point is an edge in the graph
graph = [[] for i in range(len(compress))]
for label, (u, v) in enumerate(edges):
graph[u].append((v, label))
graph[v].append((u, label))
# Want to cover graph with as many paths of length 2 as possible
# Create a dfs tree
depth = [-1] * len(graph)
parent = [-1] * len(graph)
usedPoints = [0] * N
ans = []
@bootstrap
def dfs(node, p, d):
depth[node] = d
parent[node] = p
for child, label in graph[node]:
if depth[child] == -1:
yield dfs(child, node, d + 1)
descendants = []
ancestors = []
for nbr, label in graph[node]:
if not usedPoints[label]:
assert depth[nbr] != -1
if depth[nbr] > d:
descendants.append(label)
else:
assert depth[nbr] < d
ancestors.append(label)
# Pair up all edges incident to this node
# If odd, leave out one ancestor edge for future consideration
pairs = descendants + ancestors
for i in range(1, len(pairs), 2):
x = pairs[i - 1]
y = pairs[i]
usedPoints[x] = 1
usedPoints[y] = 1
ans.append(str(x + 1) + " " + str(y + 1))
yield
for root in range(len(graph)):
if depth[root] == -1:
dfs(root, -1, 0)
return str(len(ans)) + "\n" + "\n".join(ans)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = 1
for tc in range(1, TC + 1):
(N,) = [int(x) for x in input().split()]
points = [[int(x) for x in input().split()] for i in range(N)]
ans = solve(N, points)
print(ans)
| {
"input": [
"7\n4 1 5 1\n1 1 1 1\n3 3 3 3\n1 1 4 1\n6 1 1 1\n5 1 4 1\n6 1 1 1\n",
"4\n2 1 1 1\n1 1 2 1\n2 1 1 2\n1 2 1 2\n",
"4\n182 168 60 96\n78 72 45 72\n69 21 144 63\n148 12 105 6\n"
],
"output": [
"\n3\n1 6\n2 4\n5 7\n",
"\n1\n1 2\n",
"\n1\n2 4\n"
]
} |
1,260 | 7 | A group of n merry programmers celebrate Robert Floyd's birthday. Polucarpus has got an honourable task of pouring Ber-Cola to everybody. Pouring the same amount of Ber-Cola to everybody is really important. In other words, the drink's volume in each of the n mugs must be the same.
Polycarpus has already began the process and he partially emptied the Ber-Cola bottle. Now the first mug has a1 milliliters of the drink, the second one has a2 milliliters and so on. The bottle has b milliliters left and Polycarpus plans to pour them into the mugs so that the main equation was fulfilled.
Write a program that would determine what volume of the drink Polycarpus needs to add into each mug to ensure that the following two conditions were fulfilled simultaneously:
* there were b milliliters poured in total. That is, the bottle need to be emptied;
* after the process is over, the volumes of the drink in the mugs should be equal.
Input
The first line contains a pair of integers n, b (2 ≤ n ≤ 100, 1 ≤ b ≤ 100), where n is the total number of friends in the group and b is the current volume of drink in the bottle. The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 100), where ai is the current volume of drink in the i-th mug.
Output
Print a single number "-1" (without the quotes), if there is no solution. Otherwise, print n float numbers c1, c2, ..., cn, where ci is the volume of the drink to add in the i-th mug. Print the numbers with no less than 6 digits after the decimal point, print each ci on a single line. Polycarpus proved that if a solution exists then it is unique.
Russian locale is installed by default on the testing computer. Make sure that your solution use the point to separate the integer part of a real number from the decimal, not a comma.
Examples
Input
5 50
1 2 3 4 5
Output
12.000000
11.000000
10.000000
9.000000
8.000000
Input
2 2
1 100
Output
-1 | def f(l1,al):
n,b = l1
c = (sum(al) + b)/n
if max(al)>c:
return [-1]
return [c-a for a in al]
l1 = list(map(int,input().split()))
l2 = list(map(int,input().split()))
[print(r) for r in f(l1,l2)]
| {
"input": [
"5 50\n1 2 3 4 5\n",
"2 2\n1 100\n"
],
"output": [
"12.000000\n11.000000\n10.000000\n9.000000\n8.000000\n",
"-1\n"
]
} |
1,261 | 8 | There is a square painted on a piece of paper, the square's side equals n meters. John Doe draws crosses on the square's perimeter. John paints the first cross in the lower left corner of the square. Then John moves along the square's perimeter in the clockwise direction (first upwards, then to the right, then downwards, then to the left and so on). Every time he walks (n + 1) meters, he draws a cross (see picture for clarifications).
John Doe stops only when the lower left corner of the square has two crosses. How many crosses will John draw?
<image> The figure shows the order in which John draws crosses for a square with side 4. The lower left square has two crosses. Overall John paints 17 crosses.
Input
The first line contains integer t (1 ≤ t ≤ 104) — the number of test cases.
The second line contains t space-separated integers ni (1 ≤ ni ≤ 109) — the sides of the square for each test sample.
Output
For each test sample print on a single line the answer to it, that is, the number of crosses John will draw as he will move along the square of the corresponding size. Print the answers to the samples in the order in which the samples are given in the input.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
3
4 8 100
Output
17
33
401 | import math
def lcm(x,y):
return x * y // math.gcd(x,y)
n = int(input())
arr = list(map(int, input().split()))
for i in arr:
print((lcm(4*i, i+1) // (i+1)) + 1)
| {
"input": [
"3\n4 8 100\n"
],
"output": [
"17\n33\n401\n"
]
} |
1,262 | 8 | Lolek and Bolek are about to travel abroad by plane. The local airport has a special "Choose Your Plane" offer. The offer's conditions are as follows:
* it is up to a passenger to choose a plane to fly on;
* if the chosen plane has x (x > 0) empty seats at the given moment, then the ticket for such a plane costs x zlotys (units of Polish currency).
The only ticket office of the airport already has a queue of n passengers in front of it. Lolek and Bolek have not stood in the queue yet, but they are already wondering what is the maximum and the minimum number of zlotys the airport administration can earn if all n passengers buy tickets according to the conditions of this offer?
The passengers buy tickets in turn, the first person in the queue goes first, then goes the second one, and so on up to n-th person.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the number of passengers in the queue and the number of planes in the airport, correspondingly. The next line contains m integers a1, a2, ..., am (1 ≤ ai ≤ 1000) — ai stands for the number of empty seats in the i-th plane before the ticket office starts selling tickets.
The numbers in the lines are separated by a space. It is guaranteed that there are at least n empty seats in total.
Output
Print two integers — the maximum and the minimum number of zlotys that the airport administration can earn, correspondingly.
Examples
Input
4 3
2 1 1
Output
5 5
Input
4 3
2 2 2
Output
7 6
Note
In the first test sample the number of passengers is equal to the number of empty seats, so regardless of the way the planes are chosen, the administration will earn the same sum.
In the second sample the sum is maximized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 2-nd plane, the 3-rd person — to the 3-rd plane, the 4-th person — to the 1-st plane. The sum is minimized if the 1-st person in the queue buys a ticket to the 1-st plane, the 2-nd person — to the 1-st plane, the 3-rd person — to the 2-nd plane, the 4-th person — to the 2-nd plane. | n, m = map(int,input().split())
l = list(map(int,input().split()))
def g(f):
A = l[:]; s = 0
for _ in range(n):
i = A.index(f(A)); s += A[i]
if A[i] > 1: A[i] -= 1;
else:
A.pop(i)
return s
print (g(max), g(min)) | {
"input": [
"4 3\n2 2 2\n",
"4 3\n2 1 1\n"
],
"output": [
"7 6\n",
"5 5\n"
]
} |
1,263 | 8 | Paladin Manao caught the trail of the ancient Book of Evil in a swampy area. This area contains n settlements numbered from 1 to n. Moving through the swamp is very difficult, so people tramped exactly n - 1 paths. Each of these paths connects some pair of settlements and is bidirectional. Moreover, it is possible to reach any settlement from any other one by traversing one or several paths.
The distance between two settlements is the minimum number of paths that have to be crossed to get from one settlement to the other one. Manao knows that the Book of Evil has got a damage range d. This means that if the Book of Evil is located in some settlement, its damage (for example, emergence of ghosts and werewolves) affects other settlements at distance d or less from the settlement where the Book resides.
Manao has heard of m settlements affected by the Book of Evil. Their numbers are p1, p2, ..., pm. Note that the Book may be affecting other settlements as well, but this has not been detected yet. Manao wants to determine which settlements may contain the Book. Help him with this difficult task.
Input
The first line contains three space-separated integers n, m and d (1 ≤ m ≤ n ≤ 100000; 0 ≤ d ≤ n - 1). The second line contains m distinct space-separated integers p1, p2, ..., pm (1 ≤ pi ≤ n). Then n - 1 lines follow, each line describes a path made in the area. A path is described by a pair of space-separated integers ai and bi representing the ends of this path.
Output
Print a single number — the number of settlements that may contain the Book of Evil. It is possible that Manao received some controversial information and there is no settlement that may contain the Book. In such case, print 0.
Examples
Input
6 2 3
1 2
1 5
2 3
3 4
4 5
5 6
Output
3
Note
Sample 1. The damage range of the Book of Evil equals 3 and its effects have been noticed in settlements 1 and 2. Thus, it can be in settlements 3, 4 or 5.
<image> | from collections import defaultdict
import sys
input=sys.stdin.readline
class graph:
def __init__(self,n,mark):
self.d=defaultdict(list)
self.n=n
self.mark=mark
def add(self,s,d):
self.d[s].append(d)
self.d[d].append(s)
def bfs(self,s,dis):
marked=s
visited=[False]*self.n
visited[s]=True
q=[s]
while q:
s=q.pop(0)
if(s in mark):
marked=s
for i in self.d[s]:
if(visited[i]==False):
q.append(i)
visited[i]=True
dis[i]+=dis[s]+1
return marked
n,m,k=map(int,input().split())
mrk=[int(x) for x in input().split()]
mark={}
for i in mrk:
mark[i-1]=1
g=graph(n,mark)
for i in range(n-1):
a,b=map(int,input().split())
g.add(a-1,b-1)
dis=[0]*n
u=g.bfs(0,dis)
dis=[0]*n
d=g.bfs(u,dis)
#print(dis)
temp=[0]*n
x=g.bfs(d,temp)
#print(temp)
count=0
for i in range(n):
if(temp[i]<=k and dis[i]<=k):
count+=1
print(count)
| {
"input": [
"6 2 3\n1 2\n1 5\n2 3\n3 4\n4 5\n5 6\n"
],
"output": [
"3\n"
]
} |
1,264 | 8 | Iahub wants to enhance his multitasking abilities. In order to do this, he wants to sort n arrays simultaneously, each array consisting of m integers.
Iahub can choose a pair of distinct indices i and j (1 ≤ i, j ≤ m, i ≠ j). Then in each array the values at positions i and j are swapped only if the value at position i is strictly greater than the value at position j.
Iahub wants to find an array of pairs of distinct indices that, chosen in order, sort all of the n arrays in ascending or descending order (the particular order is given in input). The size of the array can be at most <image> (at most <image> pairs). Help Iahub, find any suitable array.
Input
The first line contains three integers n (1 ≤ n ≤ 1000), m (1 ≤ m ≤ 100) and k. Integer k is 0 if the arrays must be sorted in ascending order, and 1 if the arrays must be sorted in descending order. Each line i of the next n lines contains m integers separated by a space, representing the i-th array. For each element x of the array i, 1 ≤ x ≤ 106 holds.
Output
On the first line of the output print an integer p, the size of the array (p can be at most <image>). Each of the next p lines must contain two distinct integers i and j (1 ≤ i, j ≤ m, i ≠ j), representing the chosen indices.
If there are multiple correct answers, you can print any.
Examples
Input
2 5 0
1 3 2 5 4
1 4 3 2 5
Output
3
2 4
2 3
4 5
Input
3 2 1
1 2
2 3
3 4
Output
1
2 1
Note
Consider the first sample. After the first operation, the arrays become [1, 3, 2, 5, 4] and [1, 2, 3, 4, 5]. After the second operation, the arrays become [1, 2, 3, 5, 4] and [1, 2, 3, 4, 5]. After the third operation they become [1, 2, 3, 4, 5] and [1, 2, 3, 4, 5]. | def s(n,m,k):
print(m*(m-1)//2)
for i in range(1,m):
for j in range(i+1,m+1):
if k:
print(j,i)
else:
print(i,j)
s(*map(int,input().split())) | {
"input": [
"2 5 0\n1 3 2 5 4\n1 4 3 2 5\n",
"3 2 1\n1 2\n2 3\n3 4\n"
],
"output": [
"10\n1 2\n1 3\n1 4\n1 5\n2 3\n2 4\n2 5\n3 4\n3 5\n4 5\n",
"1\n2 1\n"
]
} |
1,265 | 7 | Little Chris is bored during his physics lessons (too easy), so he has built a toy box to keep himself occupied. The box is special, since it has the ability to change gravity.
There are n columns of toy cubes in the box arranged in a line. The i-th column contains ai cubes. At first, the gravity in the box is pulling the cubes downwards. When Chris switches the gravity, it begins to pull all the cubes to the right side of the box. The figure shows the initial and final configurations of the cubes in the box: the cubes that have changed their position are highlighted with orange.
<image>
Given the initial configuration of the toy cubes in the box, find the amounts of cubes in each of the n columns after the gravity switch!
Input
The first line of input contains an integer n (1 ≤ n ≤ 100), the number of the columns in the box. The next line contains n space-separated integer numbers. The i-th number ai (1 ≤ ai ≤ 100) denotes the number of cubes in the i-th column.
Output
Output n integer numbers separated by spaces, where the i-th number is the amount of cubes in the i-th column after the gravity switch.
Examples
Input
4
3 2 1 2
Output
1 2 2 3
Input
3
2 3 8
Output
2 3 8
Note
The first example case is shown on the figure. The top cube of the first column falls to the top of the last column; the top cube of the second column falls to the top of the third column; the middle cube of the first column falls to the top of the second column.
In the second example case the gravity switch does not change the heights of the columns. | def f():
x = int(input());a = list(map(int,input().split()));a.sort();print(*a)
f() | {
"input": [
"3\n2 3 8\n",
"4\n3 2 1 2\n"
],
"output": [
"2 3 8 ",
"1 2 2 3 "
]
} |
1,266 | 8 | Consider a football tournament where n teams participate. Each team has two football kits: for home games, and for away games. The kit for home games of the i-th team has color xi and the kit for away games of this team has color yi (xi ≠ yi).
In the tournament, each team plays exactly one home game and exactly one away game with each other team (n(n - 1) games in total). The team, that plays the home game, traditionally plays in its home kit. The team that plays an away game plays in its away kit. However, if two teams has the kits of the same color, they cannot be distinguished. In this case the away team plays in its home kit.
Calculate how many games in the described tournament each team plays in its home kit and how many games it plays in its away kit.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the number of teams. Next n lines contain the description of the teams. The i-th line contains two space-separated numbers xi, yi (1 ≤ xi, yi ≤ 105; xi ≠ yi) — the color numbers for the home and away kits of the i-th team.
Output
For each team, print on a single line two space-separated integers — the number of games this team is going to play in home and away kits, correspondingly. Print the answers for the teams in the order they appeared in the input.
Examples
Input
2
1 2
2 1
Output
2 0
2 0
Input
3
1 2
2 1
1 3
Output
3 1
4 0
2 2 | def mi():
return map(int, input().split())
n = int(input())
h, a = [0]*n, [0]*n
hc, ac = [0]*(10**5+3), [0]*(10**5+3)
for i in range(n):
h[i], a[i] = mi()
hc[h[i]]+=1
ac[a[i]]+=1
for i in range(n):
ha=hc[a[i]]+n-1
aa=2*n-2-ha
print (ha, aa)
| {
"input": [
"2\n1 2\n2 1\n",
"3\n1 2\n2 1\n1 3\n"
],
"output": [
"2 0\n2 0\n",
"3 1\n4 0\n2 2\n"
]
} |
1,267 | 8 | Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b.
Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>.
Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution.
Input
The single line of the input contains two space separated integers n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100).
Output
On the first line print a single integer — the minimal possible m.
On each of the next n lines print four space separated integers representing the i-th set.
Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them.
Examples
Input
1 1
Output
5
1 2 3 5
Input
2 2
Output
22
2 4 6 22
14 18 10 16
Note
For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <image>. | import sys
def main():
# fin = open("input.txt", "r")
fin = sys.stdin
fout = sys.stdout
n, k = map(int, fin.readline().split())
m = 5 + 6 * (n - 1)
m *= k
print(m)
print(k, 2 * k, 3 * k, 5 * k)
idx = 1
for i in range(1, n):
idx += 6
print(idx * k, (idx + 1) * k, (idx + 2) * k, (idx + 4) * k)
fin.close()
fout.close()
main() | {
"input": [
"2 2\n",
"1 1\n"
],
"output": [
"22\n2 4 6 10\n14 16 18 22\n",
"5\n1 2 3 5\n"
]
} |
1,268 | 9 | A new e-mail service "Berlandesk" is going to be opened in Berland in the near future. The site administration wants to launch their project as soon as possible, that's why they ask you to help. You're suggested to implement the prototype of site registration system. The system should work on the following principle.
Each time a new user wants to register, he sends to the system a request with his name. If such a name does not exist in the system database, it is inserted into the database, and the user gets the response OK, confirming the successful registration. If the name already exists in the system database, the system makes up a new user name, sends it to the user as a prompt and also inserts the prompt into the database. The new name is formed by the following rule. Numbers, starting with 1, are appended one after another to name (name1, name2, ...), among these numbers the least i is found so that namei does not yet exist in the database.
Input
The first line contains number n (1 ≤ n ≤ 105). The following n lines contain the requests to the system. Each request is a non-empty line, and consists of not more than 32 characters, which are all lowercase Latin letters.
Output
Print n lines, which are system responses to the requests: OK in case of successful registration, or a prompt with a new name, if the requested name is already taken.
Examples
Input
4
abacaba
acaba
abacaba
acab
Output
OK
OK
abacaba1
OK
Input
6
first
first
second
second
third
third
Output
OK
first1
OK
second1
OK
third1 | def add(s, s1):
s[s1]=s.setdefault(s1,-1)+1
if s[s1] == 0:
print("OK")
else:
print(s1+str(s[s1]))
s={}
n = int(input())
for i in range(n):
x=input()
add(s, x)
#print("dict", s)
| {
"input": [
"6\nfirst\nfirst\nsecond\nsecond\nthird\nthird\n",
"4\nabacaba\nacaba\nabacaba\nacab\n"
],
"output": [
"OK\nfirst1\nOK\nsecond1\nOK\nthird1\n",
"OK\nOK\nabacaba1\nOK\n"
]
} |
1,269 | 8 | Pasha got a very beautiful string s for his birthday, the string consists of lowercase Latin letters. The letters in the string are numbered from 1 to |s| from left to right, where |s| is the length of the given string.
Pasha didn't like his present very much so he decided to change it. After his birthday Pasha spent m days performing the following transformations on his string — each day he chose integer ai and reversed a piece of string (a segment) from position ai to position |s| - ai + 1. It is guaranteed that 2·ai ≤ |s|.
You face the following task: determine what Pasha's string will look like after m days.
Input
The first line of the input contains Pasha's string s of length from 2 to 2·105 characters, consisting of lowercase Latin letters.
The second line contains a single integer m (1 ≤ m ≤ 105) — the number of days when Pasha changed his string.
The third line contains m space-separated elements ai (1 ≤ ai; 2·ai ≤ |s|) — the position from which Pasha started transforming the string on the i-th day.
Output
In the first line of the output print what Pasha's string s will look like after m days.
Examples
Input
abcdef
1
2
Output
aedcbf
Input
vwxyz
2
2 2
Output
vwxyz
Input
abcdef
3
1 2 3
Output
fbdcea | def s():
s = list(input())
l = len(s)-1
input()
a = list(map(int,input().split(' ')))
a.sort()
a.append(l//2+2)
f = False
t = 0
for i in a:
if f:
for k in range(t,i-1):
s[k], s[l-k] = s[l-k], s[k]
f = not f
t = i-1
print(*s,sep='')
s() | {
"input": [
"abcdef\n3\n1 2 3\n",
"abcdef\n1\n2\n",
"vwxyz\n2\n2 2\n"
],
"output": [
"fbdcea\n",
"aedcbf\n",
"vwxyz\n"
]
} |
1,270 | 9 | You are given a non-negative integer n, its decimal representation consists of at most 100 digits and doesn't contain leading zeroes.
Your task is to determine if it is possible in this case to remove some of the digits (possibly not remove any digit at all) so that the result contains at least one digit, forms a non-negative integer, doesn't have leading zeroes and is divisible by 8. After the removing, it is forbidden to rearrange the digits.
If a solution exists, you should print it.
Input
The single line of the input contains a non-negative integer n. The representation of number n doesn't contain any leading zeroes and its length doesn't exceed 100 digits.
Output
Print "NO" (without quotes), if there is no such way to remove some digits from number n.
Otherwise, print "YES" in the first line and the resulting number after removing digits from number n in the second line. The printed number must be divisible by 8.
If there are multiple possible answers, you may print any of them.
Examples
Input
3454
Output
YES
344
Input
10
Output
YES
0
Input
111111
Output
NO | a = input()
def ans(i,a):
b = str(i)
j =0
for i in a:
if i==b[j]:
j+=1
if j==len(b):
return 1
return 0
q =0
for i in range(0,1000,8):
if ans(i,a):
q =1
break
if q:print("YES");print(i)
else:print("NO") | {
"input": [
"111111\n",
"3454\n",
"10\n"
],
"output": [
"NO\n",
"YES\n344\n",
"YES\n0\n"
]
} |
1,271 | 10 | A tree of size n is an undirected connected graph consisting of n vertices without cycles.
Consider some tree with n vertices. We call a tree invariant relative to permutation p = p1p2... pn, if for any two vertices of the tree u and v the condition holds: "vertices u and v are connected by an edge if and only if vertices pu and pv are connected by an edge".
You are given permutation p of size n. Find some tree size n, invariant relative to the given permutation.
Input
The first line contains number n (1 ≤ n ≤ 105) — the size of the permutation (also equal to the size of the sought tree).
The second line contains permutation pi (1 ≤ pi ≤ n).
Output
If the sought tree does not exist, print "NO" (without the quotes).
Otherwise, print "YES", and then print n - 1 lines, each of which contains two integers — the numbers of vertices connected by an edge of the tree you found. The vertices are numbered from 1, the order of the edges and the order of the vertices within the edges does not matter.
If there are multiple solutions, output any of them.
Examples
Input
4
4 3 2 1
Output
YES
4 1
4 2
1 3
Input
3
3 1 2
Output
NO
Note
In the first sample test a permutation transforms edge (4, 1) into edge (1, 4), edge (4, 2) into edge (1, 3) and edge (1, 3) into edge (4, 2). These edges all appear in the resulting tree.
It can be shown that in the second sample test no tree satisfies the given condition. | def main():
n = int(input())
a = list(map(lambda x: int(x) - 1, input().split()))
p = -1
q = -1
for i in range(n):
if a[a[i]] == i:
p, q = i, a[i]
if a[i] == i:
print('YES')
[print(i + 1, j + 1) for j in range(n) if i != j]
exit()
if p < 0 or q < 0:
print('NO'); exit()
ans = [(p, q)]
used = [False] * n
used[p] = True
used[q] = True
for i in range(n):
if used[i]: continue
ans.append((p, i))
used[i] = True
flag = False
x = a[i]
while x != i:
ans.append((p if flag else q, x))
used[x] = True
x = a[x]
flag = not flag
if not flag:
print('NO'); exit()
print('YES')
[print(x + 1, y + 1) for x, y in ans]
main()
| {
"input": [
"3\n3 1 2\n",
"4\n4 3 2 1\n"
],
"output": [
"NO\n",
"YES\n1 4\n1 2\n4 3\n"
]
} |
1,272 | 8 | Marina loves Sasha. But she keeps wondering whether Sasha loves her. Of course, the best way to know it is fortune telling. There are many ways of telling fortune, but Marina has picked the easiest one. She takes in her hand one or several camomiles and tears off the petals one by one. After each petal she pronounces alternatively "Loves" and "Doesn't love", at that Marina always starts with "Loves". There are n camomiles growing in the field, possessing the numbers of petals equal to a1, a2, ... an. Marina wants to pick a bouquet with the maximal possible total number of petals so that the result would still be "Loves". Help her do that; find the maximal number of petals possible in the bouquet.
Input
The first line contains an integer n (1 ≤ n ≤ 100), which is the number of flowers growing in the field. The second line contains n integers ai (1 ≤ ai ≤ 100) which represent the number of petals on a given i-th camomile.
Output
Print a single number which is the maximal number of petals in the bouquet, the fortune telling on which would result in "Loves". If there are no such bouquet, print 0 instead. The bouquet may consist of a single flower.
Examples
Input
1
1
Output
1
Input
1
2
Output
0
Input
3
5 6 7
Output
13 | def mp():return map(int,input().split())
def it():return int(input())
n=it()
l=list(mp())
ans=float('inf')
odd,even=0,0
for i in range(n):
if l[i]&1:
ans=min(ans,l[i])
odd+=1
else:
even+=1
if odd&1:
print(sum(l))
elif odd&1==0 and odd>0:
print(sum(l)-ans)
else:
print(0)
| {
"input": [
"3\n5 6 7\n",
"1\n2\n",
"1\n1\n"
],
"output": [
"13\n",
"0\n",
"1\n"
]
} |
1,273 | 11 | Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 ≤ ai ≤ 3, 1 ≤ ti, xi ≤ 109) — type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0 | # ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
q=defaultdict(list)
que=[]
ind=defaultdict(list)
ans=defaultdict(int)
for i in range(n):
a,c,b=map(int,input().split())
ind[b].append(c)
q[b].append((a,c))
que.append((a,b,c))
for i in ind:
ind[i].sort()
inde=defaultdict(int)
for j in range(len(ind[i])):
inde[ind[i][j]]=j
e=[0]*len(ind[i])
s=SegmentTree(e)
for j in q[i]:
a,c=j
if a==1:
e[inde[c]]+=1
s.__setitem__(inde[c],e[inde[c]])
elif a==2:
e[inde[c]] -= 1
s.__setitem__(inde[c], e[inde[c]])
else:
ans[c]=s.query(0,inde[c])
for i in range(n):
a,b,c=que[i]
if a==3:
print(ans[c])
| {
"input": [
"3\n1 1 1\n2 2 1\n3 3 1\n",
"6\n1 1 5\n3 5 5\n1 2 5\n3 6 5\n2 3 5\n3 7 5\n"
],
"output": [
"0\n",
"1\n2\n1\n"
]
} |
1,274 | 9 | Recently, on a programming lesson little Petya showed how quickly he can create files and folders on the computer. But he got soon fed up with this activity, and he decided to do a much more useful thing. He decided to calculate what folder contains most subfolders (including nested folders, nested folders of nested folders, and so on) and what folder contains most files (including the files in the subfolders).
More formally, the subfolders of the folder are all its directly nested folders and the subfolders of these nested folders. The given folder is not considered the subfolder of itself. A file is regarded as lying in a folder, if and only if it either lies directly in this folder, or lies in some subfolder of the folder.
For a better understanding of how to count subfolders and files for calculating the answer, see notes and answers to the samples.
You are given a few files that Petya has managed to create. The path to each file looks as follows:
diskName:\folder1\folder2\...\ foldern\fileName
* diskName is single capital letter from the set {C,D,E,F,G}.
* folder1, ..., foldern are folder names. Each folder name is nonempty sequence of lowercase Latin letters and digits from 0 to 9. (n ≥ 1)
* fileName is a file name in the form of name.extension, where the name and the extension are nonempty sequences of lowercase Latin letters and digits from 0 to 9.
It is also known that there is no file whose path looks like diskName:\fileName. That is, each file is stored in some folder, but there are no files directly in the root. Also let us assume that the disk root is not a folder.
Help Petya to find the largest number of subfolders, which can be in some folder, and the largest number of files that can be in some folder, counting all its subfolders.
Input
Each line of input data contains the description of one file path. The length of each line does not exceed 100, and overall there are no more than 100 lines. It is guaranteed, that all the paths are correct and meet the above rules. It is also guaranteed, that there are no two completely equal lines. That is, each file is described exactly once.
There is at least one line in the input data.
Output
Print two space-separated numbers. The first one is the maximal number of possible subfolders in a folder (including nested folders, nested folders of nested folders, and so on). The second one is the maximal number of files in a folder (including nested files in subfolders). Note that the disks are not regarded as folders.
Examples
Input
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>file1.txt
Output
0 1
Input
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>folder2<span class="tex-span">\</span>folder3<span class="tex-span">\</span>file1.txt
C:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>folder2<span class="tex-span">\</span>folder4<span class="tex-span">\</span>file1.txt
D:<span class="tex-span">\</span>folder1<span class="tex-span">\</span>file1.txt
Output
3 2
Input
C:<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file.txt
C:<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file<span class="tex-span">\</span>file2<span class="tex-span">\</span>file.txt
Output
4 2
Note
In the first sample we have one folder on the "C" disk. It has no subfolders, which is why the first number in the answer is 0. But this folder contains one file, so the second number of the answer is 1.
In the second sample we have several different folders. Consider the "folder1" folder on the "C" disk. This folder directly contains one folder, "folder2". The "folder2" folder contains two more folders — "folder3" and "folder4". Thus, the "folder1" folder on the "C" drive has exactly 3 subfolders. Also this folder contains two files, even though they do not lie directly in the folder, but they are located in subfolders of "folder1".
In the third example we see that the names of some folders and some subfolders are identical. Consider the "file" folder, which lies directly on the "C" disk. That folder contains another "file" folder, which in turn contains another "file" folder, which contains two more folders, "file" and "file2". Thus, the "file" folder, which lies directly on the "C" disk, contains 4 subfolders. | import sys
from array import array # noqa: F401
from collections import defaultdict
def input():
return sys.stdin.buffer.readline().decode('utf-8')
cnt1 = defaultdict(set)
cnt2 = defaultdict(int)
for line in sys.stdin:
path = line.rstrip().split('\\')
key = tuple(path[:2])
for i in range(3, len(path)):
cnt1[key].add(tuple(path[2:i]))
cnt2[key] += 1
ans1 = max((len(s) for s in cnt1.values()), default=0)
ans2 = max(cnt2.values(), default=0)
print(ans1, ans2)
| {
"input": [
"C:<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file.txt\nC:<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file<span class=\"tex-span\">\\</span>file2<span class=\"tex-span\">\\</span>file.txt",
"C:<span class=\"tex-span\">\\</span>folder1<span class=\"tex-span\">\\</span>folder2<span class=\"tex-span\">\\</span>folder3<span class=\"tex-span\">\\</span>file1.txt\nC:<span class=\"tex-span\">\\</span>folder1<span class=\"tex-span\">\\</span>folder2<span class=\"tex-span\">\\</span>folder4<span class=\"tex-span\">\\</span>file1.txt\nD:<span class=\"tex-span\">\\</span>folder1<span class=\"tex-span\">\\</span>file1.txt\n",
"C:<span class=\"tex-span\">\\</span>folder1<span class=\"tex-span\">\\</span>file1.txt"
],
"output": [
"5 2\n",
"4 2\n",
"0 1\n"
]
} |
1,275 | 8 | Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n ≥ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni ≥ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 2·109) — the total year income of mr. Funt.
Output
Print one integer — minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3 | n = int(input())
def isPrime(x):
s = [2, 3, 5, 7, 11]
return x in s or all(pow(i, x, x) == i for i in s)
print(1 if isPrime(n) else (not isPrime(n - 2) and n % 2) + 2) | {
"input": [
"27\n",
"4\n"
],
"output": [
"3\n",
"2\n"
]
} |
1,276 | 8 | n hobbits are planning to spend the night at Frodo's house. Frodo has n beds standing in a row and m pillows (n ≤ m). Each hobbit needs a bed and at least one pillow to sleep, however, everyone wants as many pillows as possible. Of course, it's not always possible to share pillows equally, but any hobbit gets hurt if he has at least two pillows less than some of his neighbors have.
Frodo will sleep on the k-th bed in the row. What is the maximum number of pillows he can have so that every hobbit has at least one pillow, every pillow is given to some hobbit and no one is hurt?
Input
The only line contain three integers n, m and k (1 ≤ n ≤ m ≤ 109, 1 ≤ k ≤ n) — the number of hobbits, the number of pillows and the number of Frodo's bed.
Output
Print single integer — the maximum number of pillows Frodo can have so that no one is hurt.
Examples
Input
4 6 2
Output
2
Input
3 10 3
Output
4
Input
3 6 1
Output
3
Note
In the first example Frodo can have at most two pillows. In this case, he can give two pillows to the hobbit on the first bed, and one pillow to each of the hobbits on the third and the fourth beds.
In the second example Frodo can take at most four pillows, giving three pillows to each of the others.
In the third example Frodo can take three pillows, giving two pillows to the hobbit in the middle and one pillow to the hobbit on the third bed. | n, m, k = list(map(int,input().split()))
def g(a,b,d):
return (a+a+(b-1)*d)*b//2
def f(x):
return g(x,min(x,k),-1) + g(x-1,min(x-1,n-k),-1)
bl, br, ba = 1, m-n, 0
while bl <= br:
mid = (bl + br) >> 1
if f(mid) <= m-n:
ba, bl = mid, mid + 1
else:
br = mid - 1
print(1+ba)
| {
"input": [
"3 10 3\n",
"3 6 1\n",
"4 6 2\n"
],
"output": [
"4\n",
"3\n",
"2\n"
]
} |
1,277 | 8 | Little Vasya likes very much to play with sets consisting of positive integers. To make the game more interesting, Vasya chose n non-empty sets in such a way, that no two of them have common elements.
One day he wanted to show his friends just how interesting playing with numbers is. For that he wrote out all possible unions of two different sets on n·(n - 1) / 2 pieces of paper. Then he shuffled the pieces of paper. He had written out the numbers in the unions in an arbitrary order.
For example, if n = 4, and the actual sets have the following form {1, 3}, {5}, {2, 4}, {7}, then the number of set pairs equals to six. The six pieces of paper can contain the following numbers:
* 2, 7, 4.
* 1, 7, 3;
* 5, 4, 2;
* 1, 3, 5;
* 3, 1, 2, 4;
* 5, 7.
Then Vasya showed the pieces of paper to his friends, but kept the n sets secret from them. His friends managed to calculate which sets Vasya had thought of in the first place. And how about you, can you restore the sets by the given pieces of paper?
Input
The first input file line contains a number n (2 ≤ n ≤ 200), n is the number of sets at Vasya's disposal. Then follow sets of numbers from the pieces of paper written on n·(n - 1) / 2 lines. Each set starts with the number ki (2 ≤ ki ≤ 200), which is the number of numbers written of the i-th piece of paper, and then follow ki numbers aij (1 ≤ aij ≤ 200). All the numbers on the lines are separated by exactly one space. It is guaranteed that the input data is constructed according to the above given rules from n non-intersecting sets.
Output
Print on n lines Vasya's sets' description. The first number on the line shows how many numbers the current set has. Then the set should be recorded by listing its elements. Separate the numbers by spaces. Each number and each set should be printed exactly once. Print the sets and the numbers in the sets in any order. If there are several answers to that problem, print any of them.
It is guaranteed that there is a solution.
Examples
Input
4
3 2 7 4
3 1 7 3
3 5 4 2
3 1 3 5
4 3 1 2 4
2 5 7
Output
1 7
2 2 4
2 1 3
1 5
Input
4
5 6 7 8 9 100
4 7 8 9 1
4 7 8 9 2
3 1 6 100
3 2 6 100
2 1 2
Output
3 7 8 9
2 6 100
1 1
1 2
Input
3
2 1 2
2 1 3
2 2 3
Output
1 1
1 2
1 3 | read = lambda: tuple(map(int, input().split()))
n = read()[0]
c = n * (n - 1) // 2
if c == 1:
v = read()[1:]
print(1, v[0])
print(len(v) - 1, *v[1:])
else:
d = {}
d1 = {}
sets = {}
ss = []
def addset(a):
sets[min(a)] = a
for i in range(c):
cur = frozenset(read()[1:])
v = min(cur)
if v in d:
a = d[v] & cur
addset(a)
addset(d[v] ^ a)
addset(cur ^ a)
else:
d[v] = cur
for k in sets:
v = sets[k]
print(len(v), *v)
| {
"input": [
"4\n5 6 7 8 9 100\n4 7 8 9 1\n4 7 8 9 2\n3 1 6 100\n3 2 6 100\n2 1 2\n",
"4\n3 2 7 4\n3 1 7 3\n3 5 4 2\n3 1 3 5\n4 3 1 2 4\n2 5 7\n",
"3\n2 1 2\n2 1 3\n2 2 3\n"
],
"output": [
"1 1 \n1 2 \n2 6 100 \n3 7 8 9 \n",
"2 1 3 \n2 2 4 \n1 5 \n1 7 \n",
"1 1 \n1 2 \n1 3 \n"
]
} |
1,278 | 11 | Vasya has an array of integers of length n.
Vasya performs the following operations on the array: on each step he finds the longest segment of consecutive equal integers (the leftmost, if there are several such segments) and removes it. For example, if Vasya's array is [13, 13, 7, 7, 7, 2, 2, 2], then after one operation it becomes [13, 13, 2, 2, 2].
Compute the number of operations Vasya should make until the array becomes empty, i.e. Vasya removes all elements from it.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains a sequence a1, a2, ..., an (1 ≤ ai ≤ 109) — Vasya's array.
Output
Print the number of operations Vasya should make to remove all elements from the array.
Examples
Input
4
2 5 5 2
Output
2
Input
5
6 3 4 1 5
Output
5
Input
8
4 4 4 2 2 100 100 100
Output
3
Input
6
10 10 50 10 50 50
Output
4
Note
In the first example, at first Vasya removes two fives at the second and third positions. The array becomes [2, 2]. In the second operation Vasya removes two twos at the first and second positions. After that the array becomes empty.
In the second example Vasya has to perform five operations to make the array empty. In each of them he removes the first element from the array.
In the third example Vasya needs three operations. In the first operation he removes all integers 4, in the second — all integers 100, in the third — all integers 2.
In the fourth example in the first operation Vasya removes the first two integers 10. After that the array becomes [50, 10, 50, 50]. Then in the second operation Vasya removes the two rightmost integers 50, so that the array becomes [50, 10]. In the third operation he removes the remaining 50, and the array becomes [10] after that. In the last, fourth operation he removes the only remaining 10. The array is empty after that. | from sys import stdin
from heapq import heappop, heappush, heapify
def main():
n = int(stdin.readline())
a = stdin.readline().split()
q = []
p = 0
c = 0
l = [0] * (n + 1)
r = [0] * (n + 1)
k = [0] * (n + 1)
pa = [0] * (n + 1)
for i, x in enumerate(a):
if x == a[p]:
c += 1
else:
l[p] = p - 1
k[p] = k[i-1] = c
pa[p] = i - 1
pa[i-1] = p
r[i-1] = i
q.append((-c, p))
p = i
c = 1
q.append((-c, p))
l[p] = p - 1
k[p] = k[n-1] = c
pa[p] = n - 1
pa[n-1] = p
r[n-1] = n
heapify(q)
ans = 0
while len(q):
c, p = heappop(q)
c = -c
if k[p] > c:
continue
ans += 1
ls = l[p]
rs = r[pa[p]]
if ls >= 0 and rs < n and a[ls] == a[rs]:
nc = k[ls] + k[rs]
nl, nr = pa[ls], pa[rs]
k[nl] = k[nr] = k[ls] = k[rs] = nc
pa[nr] = nl
pa[nl] = nr
heappush(q, (-nc, nl))
else:
if ls >= 0:
r[ls] = rs
if rs < n:
l[rs] = ls
print (ans)
main() | {
"input": [
"8\n4 4 4 2 2 100 100 100\n",
"4\n2 5 5 2\n",
"5\n6 3 4 1 5\n",
"6\n10 10 50 10 50 50\n"
],
"output": [
"3",
"2",
"5",
"4"
]
} |
1,279 | 7 | It is winter now, and Max decided it's about time he watered the garden.
The garden can be represented as n consecutive garden beds, numbered from 1 to n. k beds contain water taps (i-th tap is located in the bed xi), which, if turned on, start delivering water to neighbouring beds. If the tap on the bed xi is turned on, then after one second has passed, the bed xi will be watered; after two seconds have passed, the beds from the segment [xi - 1, xi + 1] will be watered (if they exist); after j seconds have passed (j is an integer number), the beds from the segment [xi - (j - 1), xi + (j - 1)] will be watered (if they exist). Nothing changes during the seconds, so, for example, we can't say that the segment [xi - 2.5, xi + 2.5] will be watered after 2.5 seconds have passed; only the segment [xi - 2, xi + 2] will be watered at that moment.
<image> The garden from test 1. White colour denotes a garden bed without a tap, red colour — a garden bed with a tap. <image> The garden from test 1 after 2 seconds have passed after turning on the tap. White colour denotes an unwatered garden bed, blue colour — a watered bed.
Max wants to turn on all the water taps at the same moment, and now he wonders, what is the minimum number of seconds that have to pass after he turns on some taps until the whole garden is watered. Help him to find the answer!
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 200).
Then t test cases follow. The first line of each test case contains two integers n and k (1 ≤ n ≤ 200, 1 ≤ k ≤ n) — the number of garden beds and water taps, respectively.
Next line contains k integers xi (1 ≤ xi ≤ n) — the location of i-th water tap. It is guaranteed that for each <image> condition xi - 1 < xi holds.
It is guaranteed that the sum of n over all test cases doesn't exceed 200.
Note that in hacks you have to set t = 1.
Output
For each test case print one integer — the minimum number of seconds that have to pass after Max turns on some of the water taps, until the whole garden is watered.
Example
Input
3
5 1
3
3 3
1 2 3
4 1
1
Output
3
1
4
Note
The first example consists of 3 tests:
1. There are 5 garden beds, and a water tap in the bed 3. If we turn it on, then after 1 second passes, only bed 3 will be watered; after 2 seconds pass, beds [1, 3] will be watered, and after 3 seconds pass, everything will be watered.
2. There are 3 garden beds, and there is a water tap in each one. If we turn all of them on, then everything will be watered after 1 second passes.
3. There are 4 garden beds, and only one tap in the bed 1. It will take 4 seconds to water, for example, bed 4. |
def solve(n,X):
a = X[0]-1
b = n-X[-1]
c = max((X[i+1]-X[i] for i in range(len(X)-1)),default=0)//2
return max(a,b,c)+1
T = int(input())
for _ in range(T):
n,k = map(int,input().split())
X = tuple(map(int,input().split()))
print(solve(n,X)) | {
"input": [
"3\n5 1\n3\n3 3\n1 2 3\n4 1\n1\n"
],
"output": [
"3\n1\n4\n"
]
} |
1,280 | 10 | You are given a sequence of n positive integers d1, d2, ..., dn (d1 < d2 < ... < dn). Your task is to construct an undirected graph such that:
* there are exactly dn + 1 vertices;
* there are no self-loops;
* there are no multiple edges;
* there are no more than 106 edges;
* its degree set is equal to d.
Vertices should be numbered 1 through (dn + 1).
Degree sequence is an array a with length equal to the number of vertices in a graph such that ai is the number of vertices adjacent to i-th vertex.
Degree set is a sorted in increasing order sequence of all distinct values from the degree sequence.
It is guaranteed that there exists such a graph that all the conditions hold, and it contains no more than 106 edges.
Print the resulting graph.
Input
The first line contains one integer n (1 ≤ n ≤ 300) — the size of the degree set.
The second line contains n integers d1, d2, ..., dn (1 ≤ di ≤ 1000, d1 < d2 < ... < dn) — the degree set.
Output
In the first line print one integer m (1 ≤ m ≤ 106) — the number of edges in the resulting graph. It is guaranteed that there exists such a graph that all the conditions hold and it contains no more than 106 edges.
Each of the next m lines should contain two integers vi and ui (1 ≤ vi, ui ≤ dn + 1) — the description of the i-th edge.
Examples
Input
3
2 3 4
Output
8
3 1
4 2
4 5
2 5
5 1
3 2
2 1
5 3
Input
3
1 2 3
Output
4
1 2
1 3
1 4
2 3 | # python3
def readline(): return list(map(int, input().split()))
def solve(d):
while d:
dn = d.pop()
if not d:
for i in range(1, dn + 1):
for j in range(i, dn + 1):
yield i, j + 1
return
else:
d1 = d.pop(0)
for i in range(1, dn + 1):
for j in range(max(dn - d1 + 1, i), dn + 1):
yield i, j + 1
d = [di - d1 for di in d]
def main():
n, = readline()
d = readline()
assert len(d) == n
edges = list(solve(d))
print(len(edges))
print("\n".join(map("{0[0]} {0[1]}".format, edges)))
main()
| {
"input": [
"3\n1 2 3\n",
"3\n2 3 4\n"
],
"output": [
"4\n1 2\n1 3\n1 4\n2 3\n",
"8\n1 2\n1 3\n1 4\n1 5\n2 3\n2 4\n2 5\n3 4\n"
]
} |
1,281 | 8 | Allen wants to enter a fan zone that occupies a round square and has n entrances.
There already is a queue of a_i people in front of the i-th entrance. Each entrance allows one person from its queue to enter the fan zone in one minute.
Allen uses the following strategy to enter the fan zone:
* Initially he stands in the end of the queue in front of the first entrance.
* Each minute, if he is not allowed into the fan zone during the minute (meaning he is not the first in the queue), he leaves the current queue and stands in the end of the queue of the next entrance (or the first entrance if he leaves the last entrance).
Determine the entrance through which Allen will finally enter the fan zone.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of entrances.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^9) — the number of people in queues. These numbers do not include Allen.
Output
Print a single integer — the number of entrance that Allen will use.
Examples
Input
4
2 3 2 0
Output
3
Input
2
10 10
Output
1
Input
6
5 2 6 5 7 4
Output
6
Note
In the first example the number of people (not including Allen) changes as follows: [2, 3, 2, 0] → [1, 2, 1, 0] → [0, 1, 0, 0]. The number in bold is the queue Alles stands in. We see that he will enter the fan zone through the third entrance.
In the second example the number of people (not including Allen) changes as follows: [10, 10] → [9, 9] → [8, 8] → [7, 7] → [6, 6] → \\\ [5, 5] → [4, 4] → [3, 3] → [2, 2] → [1, 1] → [0, 0].
In the third example the number of people (not including Allen) changes as follows: [5, 2, 6, 5, 7, 4] → [4, 1, 5, 4, 6, 3] → [3, 0, 4, 3, 5, 2] → \\\ [2, 0, 3, 2, 4, 1] → [1, 0, 2, 1, 3, 0] → [0, 0, 1, 0, 2, 0]. | def f(i, ai, n):
c = (ai // n) * n + i
if c < ai:
c += n
return c
n = int(input())
a = list(map(int, input().split()))
b = [f(i, a[i], n) for i in range(n)]
print(b.index(min(b)) + 1)
| {
"input": [
"4\n2 3 2 0\n",
"6\n5 2 6 5 7 4\n",
"2\n10 10\n"
],
"output": [
"3\n",
"6\n",
"1\n"
]
} |
1,282 | 11 | One of Arkady's friends works at a huge radio telescope. A few decades ago the telescope has sent a signal s towards a faraway galaxy. Recently they've received a response t which they believe to be a response from aliens! The scientists now want to check if the signal t is similar to s.
The original signal s was a sequence of zeros and ones (everyone knows that binary code is the universe-wide language). The returned signal t, however, does not look as easy as s, but the scientists don't give up! They represented t as a sequence of English letters and say that t is similar to s if you can replace all zeros in s with some string r_0 and all ones in s with some other string r_1 and obtain t. The strings r_0 and r_1 must be different and non-empty.
Please help Arkady's friend and find the number of possible replacements for zeros and ones (the number of pairs of strings r_0 and r_1) that transform s to t.
Input
The first line contains a string s (2 ≤ |s| ≤ 10^5) consisting of zeros and ones — the original signal.
The second line contains a string t (1 ≤ |t| ≤ 10^6) consisting of lowercase English letters only — the received signal.
It is guaranteed, that the string s contains at least one '0' and at least one '1'.
Output
Print a single integer — the number of pairs of strings r_0 and r_1 that transform s to t.
In case there are no such pairs, print 0.
Examples
Input
01
aaaaaa
Output
4
Input
001
kokokokotlin
Output
2
Note
In the first example, the possible pairs (r_0, r_1) are as follows:
* "a", "aaaaa"
* "aa", "aaaa"
* "aaaa", "aa"
* "aaaaa", "a"
The pair "aaa", "aaa" is not allowed, since r_0 and r_1 must be different.
In the second example, the following pairs are possible:
* "ko", "kokotlin"
* "koko", "tlin" | def gethash(l,r):
return (ha[r]-((ha[l]*p[r-l])%mod)+mod)%mod
def check(lenx,leny):
ha_0=-1
ha_1=-1
j=0
for i in range(m):
if s[i]=="0":
tmp=gethash(j,j+lenx)
if ha_0==-1:
ha_0=tmp
elif ha_0!=tmp:
return 0
j+=lenx
else:
tmp=gethash(j,j+leny)
if ha_1==-1:
ha_1=tmp
elif ha_1!=tmp:
return 0
j+=leny
return ha_0!=ha_1
s=list(input())
t=list(input())
m=len(s)
n=len(t)
p=[1]
bas=2333
mod=(1<<50)-2
for i in range(1,n+1):
p.append((p[i-1]*bas)%mod)
ha=[0]
for i in range(1,n+1):
ha.append((ha[i-1]*bas+ord(t[i-1]))%mod)
cnt_0=0
cnt_1=0
for x in s:
if x=="0":
cnt_0+=1
else:
cnt_1+=1
ans=0
for i in range(1,n//cnt_0+1):#length of r_0
j=n-cnt_0*i
if j%cnt_1==0 and j!=0:
j//=cnt_1
ans+=check(i,j)
print(ans) | {
"input": [
"001\nkokokokotlin\n",
"01\naaaaaa\n"
],
"output": [
"2\n",
"4\n"
]
} |
1,283 | 7 | The German University in Cairo (GUC) dorm houses are numbered from 1 to n. Underground water pipes connect these houses together. Each pipe has certain direction (water can flow only in this direction and not vice versa), and diameter (which characterizes the maximal amount of water it can handle).
For each house, there is at most one pipe going into it and at most one pipe going out of it. With the new semester starting, GUC student and dorm resident, Lulu, wants to install tanks and taps at the dorms. For every house with an outgoing water pipe and without an incoming water pipe, Lulu should install a water tank at that house. For every house with an incoming water pipe and without an outgoing water pipe, Lulu should install a water tap at that house. Each tank house will convey water to all houses that have a sequence of pipes from the tank to it. Accordingly, each tap house will receive water originating from some tank house.
In order to avoid pipes from bursting one week later (like what happened last semester), Lulu also has to consider the diameter of the pipes. The amount of water each tank conveys should not exceed the diameter of the pipes connecting a tank to its corresponding tap. Lulu wants to find the maximal amount of water that can be safely conveyed from each tank to its corresponding tap.
Input
The first line contains two space-separated integers n and p (1 ≤ n ≤ 1000, 0 ≤ p ≤ n) — the number of houses and the number of pipes correspondingly.
Then p lines follow — the description of p pipes. The i-th line contains three integers ai bi di, indicating a pipe of diameter di going from house ai to house bi (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ di ≤ 106).
It is guaranteed that for each house there is at most one pipe going into it and at most one pipe going out of it.
Output
Print integer t in the first line — the number of tank-tap pairs of houses.
For the next t lines, print 3 integers per line, separated by spaces: tanki, tapi, and diameteri, where tanki ≠ tapi (1 ≤ i ≤ t). Here tanki and tapi are indexes of tank and tap houses respectively, and diameteri is the maximum amount of water that can be conveyed. All the t lines should be ordered (increasingly) by tanki.
Examples
Input
3 2
1 2 10
2 3 20
Output
1
1 3 10
Input
3 3
1 2 20
2 3 10
3 1 5
Output
0
Input
4 2
1 2 60
3 4 50
Output
2
1 2 60
3 4 50 | import math
import sys
sys.setrecursionlimit(1100)
n, p = map(int, input().split())
neighList = [() for _ in range(n)]
in_degrees = [0] * n
for _ in range(p):
a, b, d = map(int, input().split())
a -= 1; b-= 1
neighList[a] = (b, d)
in_degrees[b] += 1
def dfs(u, d):
if len(neighList[u]) == 0:
return (u, d)
else:
return dfs(neighList[u][0], min(d, neighList[u][1]))
res = []
for u in range(n):
if in_degrees[u] == 0 and len(neighList[u]) != 0:
b, d = dfs(u, math.inf)
res.append((u+1, b+1, d))
res.sort()
print(len(res))
for r in res:
print(*r)
| {
"input": [
"4 2\n1 2 60\n3 4 50\n",
"3 3\n1 2 20\n2 3 10\n3 1 5\n",
"3 2\n1 2 10\n2 3 20\n"
],
"output": [
"2\n1 2 60\n3 4 50\n",
"0\n",
"1\n1 3 10\n"
]
} |
1,284 | 8 | Inaka has a disc, the circumference of which is n units. The circumference is equally divided by n points numbered clockwise from 1 to n, such that points i and i + 1 (1 ≤ i < n) are adjacent, and so are points n and 1.
There are m straight segments on the disc, the endpoints of which are all among the aforementioned n points.
Inaka wants to know if her image is rotationally symmetrical, i.e. if there is an integer k (1 ≤ k < n), such that if all segments are rotated clockwise around the center of the circle by k units, the new image will be the same as the original one.
Input
The first line contains two space-separated integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 200 000) — the number of points and the number of segments, respectively.
The i-th of the following m lines contains two space-separated integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) that describe a segment connecting points a_i and b_i.
It is guaranteed that no segments coincide.
Output
Output one line — "Yes" if the image is rotationally symmetrical, and "No" otherwise (both excluding quotation marks).
You can output each letter in any case (upper or lower).
Examples
Input
12 6
1 3
3 7
5 7
7 11
9 11
11 3
Output
Yes
Input
9 6
4 5
5 6
7 8
8 9
1 2
2 3
Output
Yes
Input
10 3
1 2
3 2
7 2
Output
No
Input
10 2
1 6
2 7
Output
Yes
Note
The first two examples are illustrated below. Both images become the same as their respective original ones after a clockwise rotation of 120 degrees around the center.
<image> | n, m = map(int, input().split())
a = set()
for i in range(m):
c, d = map(int, input().split())
c %= n
d %= n
a.add((min(c, d), max(c, d)))
def comprobar(x):
global a, n
b = set()
for c, d in a:
c += x
d += x
c %= n
d %= n
if (min(c, d), max(c, d)) not in a:
return False
#print("COMPARACION", x)
#print(a)
#print(b)
return True
for i in range(1, n):
if n%i == 0:
if comprobar(i):
print("Yes")
exit()
print("No") | {
"input": [
"10 2\n1 6\n2 7\n",
"10 3\n1 2\n3 2\n7 2\n",
"9 6\n4 5\n5 6\n7 8\n8 9\n1 2\n2 3\n",
"12 6\n1 3\n3 7\n5 7\n7 11\n9 11\n11 3\n"
],
"output": [
"Yes\n",
"No\n",
"Yes\n",
"Yes\n"
]
} |
1,285 | 9 | Toad Pimple has an array of integers a_1, a_2, …, a_n.
We say that y is reachable from x if x<y and there exists an integer array p such that x = p_1 < p_2 < … < p_k=y, and a_{p_i} \& a_{p_{i+1}} > 0 for all integers i such that 1 ≤ i < k.
Here \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND).
You are given q pairs of indices, check reachability for each of them.
Input
The first line contains two integers n and q (2 ≤ n ≤ 300 000, 1 ≤ q ≤ 300 000) — the number of integers in the array and the number of queries you need to answer.
The second line contains n space-separated integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 300 000) — the given array.
The next q lines contain two integers each. The i-th of them contains two space-separated integers x_i and y_i (1 ≤ x_i < y_i ≤ n). You need to check if y_i is reachable from x_i.
Output
Output q lines. In the i-th of them print "Shi" if y_i is reachable from x_i, otherwise, print "Fou".
Example
Input
5 3
1 3 0 2 1
1 3
2 4
1 4
Output
Fou
Shi
Shi
Note
In the first example, a_3 = 0. You can't reach it, because AND with it is always zero. a_2 \& a_4 > 0, so 4 is reachable from 2, and to go from 1 to 4 you can use p = [1, 2, 4]. |
from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop
import math
from collections import *
from functools import reduce,cmp_to_key,lru_cache
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
# import sys
# input = sys.stdin.readline
M = mod = 10**9 + 7
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
def li():return [int(i) for i in input().rstrip().split()]
def st():return str(input().rstrip())[2:-1]
def val():return int(input().rstrip())
def li2():return [str(i)[2:-1] for i in input().rstrip().split()]
def li3():return [int(i) for i in st()]
he = []
n, q = li()
queue = [-1] * 20
ans = [[-1] * 20 for i in range(n + 1)]
l = li()
for i, curr in enumerate(l):
for j in range(20):
if curr >> j & 1:
for k in range(20):
ans[i][k] = max(ans[i][k], ans[queue[j]][k])
ans[i][j] = i
for j in range(20):queue[j] = max(queue[j], ans[i][j])
# for i in ans:print(*i)
for i in range(q):
a, b = li()
a -= 1
b -= 1
currans = 0
for j in range(20):
if (l[a] >> j) & 1 and ans[b][j] >= a:
currans = 1
break
print('Shi' if currans else 'Fou') | {
"input": [
"5 3\n1 3 0 2 1\n1 3\n2 4\n1 4\n"
],
"output": [
"Fou\nShi\nShi\n"
]
} |
1,286 | 8 | You are given two strings of equal length s and t consisting of lowercase Latin letters. You may perform any number (possibly, zero) operations on these strings.
During each operation you choose two adjacent characters in any string and assign the value of the first character to the value of the second or vice versa.
For example, if s is "acbc" you can get the following strings in one operation:
* "aabc" (if you perform s_2 = s_1);
* "ccbc" (if you perform s_1 = s_2);
* "accc" (if you perform s_3 = s_2 or s_3 = s_4);
* "abbc" (if you perform s_2 = s_3);
* "acbb" (if you perform s_4 = s_3);
Note that you can also apply this operation to the string t.
Please determine whether it is possible to transform s into t, applying the operation above any number of times.
Note that you have to answer q independent queries.
Input
The first line contains one integer q (1 ≤ q ≤ 100) — the number of queries. Each query is represented by two consecutive lines.
The first line of each query contains the string s (1 ≤ |s| ≤ 100) consisting of lowercase Latin letters.
The second line of each query contains the string t (1 ≤ |t| ≤ 100, |t| = |s|) consisting of lowercase Latin letters.
Output
For each query, print "YES" if it is possible to make s equal to t, and "NO" otherwise.
You may print every letter in any case you want (so, for example, the strings "yEs", "yes", "Yes", and "YES" will all be recognized as positive answer).
Example
Input
3
xabb
aabx
technocup
technocup
a
z
Output
YES
YES
NO
Note
In the first query, you can perform two operations s_1 = s_2 (after it s turns into "aabb") and t_4 = t_3 (after it t turns into "aabb").
In the second query, the strings are equal initially, so the answer is "YES".
In the third query, you can not make strings s and t equal. Therefore, the answer is "NO". | def f():
s1 = input()
s2 = input()
if set(s1) & set(s2):
return "YES"
return "NO"
for i in range(int(input())):
print(f())
| {
"input": [
"3\nxabb\naabx\ntechnocup\ntechnocup\na\nz\n"
],
"output": [
"YES\nYES\nNO\n"
]
} |
1,287 | 11 | There are n seats in the train's car and there is exactly one passenger occupying every seat. The seats are numbered from 1 to n from left to right. The trip is long, so each passenger will become hungry at some moment of time and will go to take boiled water for his noodles. The person at seat i (1 ≤ i ≤ n) will decide to go for boiled water at minute t_i.
Tank with a boiled water is located to the left of the 1-st seat. In case too many passengers will go for boiled water simultaneously, they will form a queue, since there can be only one passenger using the tank at each particular moment of time. Each passenger uses the tank for exactly p minutes. We assume that the time it takes passengers to go from their seat to the tank is negligibly small.
Nobody likes to stand in a queue. So when the passenger occupying the i-th seat wants to go for a boiled water, he will first take a look on all seats from 1 to i - 1. In case at least one of those seats is empty, he assumes that those people are standing in a queue right now, so he would be better seating for the time being. However, at the very first moment he observes that all seats with numbers smaller than i are busy, he will go to the tank.
There is an unspoken rule, that in case at some moment several people can go to the tank, than only the leftmost of them (that is, seating on the seat with smallest number) will go to the tank, while all others will wait for the next moment.
Your goal is to find for each passenger, when he will receive the boiled water for his noodles.
Input
The first line contains integers n and p (1 ≤ n ≤ 100 000, 1 ≤ p ≤ 10^9) — the number of people and the amount of time one person uses the tank.
The second line contains n integers t_1, t_2, ..., t_n (0 ≤ t_i ≤ 10^9) — the moments when the corresponding passenger will go for the boiled water.
Output
Print n integers, where i-th of them is the time moment the passenger on i-th seat will receive his boiled water.
Example
Input
5 314
0 310 942 628 0
Output
314 628 1256 942 1570
Note
Consider the example.
At the 0-th minute there were two passengers willing to go for a water, passenger 1 and 5, so the first passenger has gone first, and returned at the 314-th minute. At this moment the passenger 2 was already willing to go for the water, so the passenger 2 has gone next, and so on. In the end, 5-th passenger was last to receive the boiled water. | import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
from heapq import heappop, heappush, heapify
from collections import deque
class SWAG_Stack():
def __init__(self, F):
self.stack1 = deque()
self.stack2 = deque()
self.F = F
self.len = 0
def push(self, x):
if self.stack2:
self.stack2.append((x, self.F(self.stack2[-1][1], x)))
else:
self.stack2.append((x, x))
self.len += 1
def pop(self):
if not self.stack1:
while self.stack2:
x, _ = self.stack2.pop()
if self.stack1:
self.stack1.appendleft((x, self.F(x, self.stack1[0][1])))
else:
self.stack1.appendleft((x, x))
x, _ = self.stack1.popleft()
self.len -= 1
return x
def sum_all(self):
if self.stack1 and self.stack2:
return self.F(self.stack1[0][1], self.stack2[-1][1])
elif self.stack1:
return self.stack1[0][1]
elif self.stack2:
return self.stack2[-1][1]
else:
return float("inf")
n,p = map(int, input().split())
t = list((j, i) for i,j in enumerate(map(int, input().split())))
heapify(t)
stack = SWAG_Stack(min)
heap = []
cur = 0
ans = [-1]*n
hoge = 0
# 今追加できるやつで最も小さいものを追加
# ここでなにもなかったら？
# 時間を変更する
# 次の時間までに追加できるものを追加
# 清算
while hoge != n:
if heap and stack.sum_all() > heap[0]:
j = heappop(heap)
stack.push(j)
if stack.len==0 and t:
cur = max(cur, t[0][0])
while t and t[0][0] <= cur+p:
ti, i = heappop(t)
if ti == cur+p:
# 後回し
heappush(heap, i)
else:
# いま追加できるか確認
if stack.sum_all() > i:
stack.push(i)
else:
# 後回し
heappush(heap, i)
if stack.len:
j = stack.pop()
cur += p
ans[j] = cur
hoge += 1
print(*ans) | {
"input": [
"5 314\n0 310 942 628 0\n"
],
"output": [
"314 628 1256 942 1570 "
]
} |
1,288 | 10 | Daisy is a senior software engineer at RainyDay, LLC. She has just implemented three new features in their product: the first feature makes their product work, the second one makes their product fast, and the third one makes their product correct. The company encourages at least some testing of new features, so Daisy appointed her intern Demid to write some tests for the new features.
Interestingly enough, these three features pass all the tests on Demid's development server, which has index 1, but might fail the tests on some other servers.
After Demid has completed this task, Daisy appointed you to deploy these three features to all n servers of your company. For every feature f and every server s, Daisy told you whether she wants the feature f to be deployed on the server s. If she wants it to be deployed, it must be done even if the feature f fails the tests on the server s. If she does not want it to be deployed, you may not deploy it there.
Your company has two important instruments for the deployment of new features to servers: Continuous Deployment (CD) and Continuous Testing (CT). CD can be established between several pairs of servers, forming a directed graph. CT can be set up on some set of servers.
If CD is configured from the server s_1 to the server s_2 then every time s_1 receives a new feature f the system starts the following deployment process of f to s_2:
* If the feature f is already deployed on the server s_2, then nothing is done.
* Otherwise, if CT is not set up on the server s_1, then the server s_1 just deploys the feature f to the server s_2 without any testing.
* Otherwise, the server s_1 runs tests for the feature f. If the tests fail on the server s_1, nothing is done. If the tests pass, then the server s_1 deploys the feature f to the server s_2.
You are to configure the CD/CT system, and after that Demid will deploy all three features on his development server. Your CD/CT system must deploy each feature exactly to the set of servers that Daisy wants.
Your company does not have a lot of computing resources, so you can establish CD from one server to another at most 264 times.
Input
The first line contains integer n (2 ≤ n ≤ 256) — the number of servers in your company.
Next n lines contain three integers each. The j-th integer in the i-th line is 1 if Daisy wants the j-th feature to be deployed to the i-th server, or 0 otherwise.
Next n lines contain three integers each. The j-th integer in the i-th line is 1 if tests pass for the j-th feature on the i-th server, or 0 otherwise.
Demid's development server has index 1. It is guaranteed that Daisy wants all three features to be deployed to the server number 1, and all three features pass their tests on the server number 1.
Output
If it is impossible to configure CD/CT system with CD being set up between at most 264 pairs of servers, then output the single line "Impossible".
Otherwise, the first line of the output must contain the line "Possible".
Next line must contain n space-separated integers — the configuration of CT. The i-th integer should be 1 if you set up CT on the i-th server, or 0 otherwise.
Next line must contain the integer m (0 ≤ m ≤ 264) — the number of CD pairs you want to set up.
Each of the next m lines must describe CD configuration, each line with two integers s_i and t_i (1 ≤ s_i, t_i ≤ n; s_i ≠ t_i), establishing automated deployment of new features from the server s_i to the server t_i.
Examples
Input
3
1 1 1
1 0 1
1 1 1
1 1 1
0 0 0
1 0 1
Output
Possible
1 1 1
2
3 2
1 3
Input
2
1 1 1
0 0 1
1 1 1
1 1 0
Output
Impossible
Note
CD/CT system for the first sample test is shown below.
<image> | import sys
from functools import reduce
def impossible():
print("Impossible")
def main_proc():
res = []
cnt2resolve = 0
n = int(input()) # number of servers
# structure definition
target = [[[], []] for _ in range(8)] # target_id(equal to number of features) => [parent src_ids,target src_ids]
test = [0 for _ in range(8)] # test_id => src_ids
test[7] = 1
src = [[] for _ in range(0, n + 1)] # src_id => [target_id, test_id]
ct = ["1" for _ in range(0, n + 1)]
# structure population
input() # skip server no.1
for i in range(2, n + 1):
ind = reduce(lambda a, b: (a << 1) + int(b), [int(_) for _ in input().split()])
src[i].append(ind)
target[ind][1].append(i)
target[0][1] = []
for x in target:
if len(x[1]): cnt2resolve += 1
input() # skip server no.1
for i in range(2, n + 1):
ind = reduce(lambda a, b: (a << 1) + int(b), [int(_) for _ in input().split()])
ind &= src[i][0]
src[i].append(ind)
# print("src: ", src, file=sys.stderr)
# print("target: ", target, file=sys.stderr)
# search for solution
for i in (7, 6, 5, 3, 4, 2, 1):
if not target[i][0] and target[i][1]:
for j in target[i][1]:
if test[src[j][0]]:
if not target[i][0]:
target[i][0].append(test[src[j][0]])
cnt2resolve -= 1
test[src[j][1]] = j
# print("src : ", src, file=sys.stderr)
# print("target: ", target, file=sys.stderr)
# print("test: ", test, file=sys.stderr)
if cnt2resolve:
for i in (6, 5, 3):
if not target[i][0] and target[i][1]:
tmp = 2
for j in (4, 2, 1):
if j & i:
if test[j]:
if src[test[j]][0] in (4, 2, 1):
target[i][0].append(target[src[test[j]][0]][0][0])
else:
target[i][0].append(test[j])
tmp -= 1
if not tmp:
cnt2resolve -= 1
# print("src : ", src, file=sys.stderr)
# print("target: ", target, file=sys.stderr)
# print("test: ", test, file=sys.stderr)
if not cnt2resolve:
for i in range(7, 0, -1):
for k in target[i][0]:
if len(target[i][0]) == 2:
tt = target[i][1][:1]
else:
tt = target[i][1]
for j in tt:
res.append(" ".join((str(k), str(j))))
if len(target[i][0]) == 2 and len(target[i][1]) > 1:
hp = target[i][1][0]
ct[hp] = "0"
for j in target[i][1][1:]:
res.append(" ".join((str(hp), str(j))))
print("Possible")
print(" ".join(ct[1:]))
print(len(res))
print("\n".join(res))
else:
print("Impossible")
return
if __name__ == '__main__':
main_proc()
| {
"input": [
"3\n1 1 1\n1 0 1\n1 1 1\n1 1 1\n0 0 0\n1 0 1\n",
"2\n1 1 1\n0 0 1\n1 1 1\n1 1 0\n"
],
"output": [
"Possible\n1 1 1 \n2\n1 3\n3 2\n",
"Impossible\n"
]
} |
1,289 | 11 | Polycarp is a frequent user of the very popular messenger. He's chatting with his friends all the time. He has n friends, numbered from 1 to n.
Recall that a permutation of size n is an array of size n such that each integer from 1 to n occurs exactly once in this array.
So his recent chat list can be represented with a permutation p of size n. p_1 is the most recent friend Polycarp talked to, p_2 is the second most recent and so on.
Initially, Polycarp's recent chat list p looks like 1, 2, ..., n (in other words, it is an identity permutation).
After that he receives m messages, the j-th message comes from the friend a_j. And that causes friend a_j to move to the first position in a permutation, shifting everyone between the first position and the current position of a_j by 1. Note that if the friend a_j is in the first position already then nothing happens.
For example, let the recent chat list be p = [4, 1, 5, 3, 2]:
* if he gets messaged by friend 3, then p becomes [3, 4, 1, 5, 2];
* if he gets messaged by friend 4, then p doesn't change [4, 1, 5, 3, 2];
* if he gets messaged by friend 2, then p becomes [2, 4, 1, 5, 3].
For each friend consider all position he has been at in the beginning and after receiving each message. Polycarp wants to know what were the minimum and the maximum positions.
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 3 ⋅ 10^5) — the number of Polycarp's friends and the number of received messages, respectively.
The second line contains m integers a_1, a_2, ..., a_m (1 ≤ a_i ≤ n) — the descriptions of the received messages.
Output
Print n pairs of integers. For each friend output the minimum and the maximum positions he has been in the beginning and after receiving each message.
Examples
Input
5 4
3 5 1 4
Output
1 3
2 5
1 4
1 5
1 5
Input
4 3
1 2 4
Output
1 3
1 2
3 4
1 4
Note
In the first example, Polycarp's recent chat list looks like this:
* [1, 2, 3, 4, 5]
* [3, 1, 2, 4, 5]
* [5, 3, 1, 2, 4]
* [1, 5, 3, 2, 4]
* [4, 1, 5, 3, 2]
So, for example, the positions of the friend 2 are 2, 3, 4, 4, 5, respectively. Out of these 2 is the minimum one and 5 is the maximum one. Thus, the answer for the friend 2 is a pair (2, 5).
In the second example, Polycarp's recent chat list looks like this:
* [1, 2, 3, 4]
* [1, 2, 3, 4]
* [2, 1, 3, 4]
* [4, 2, 1, 3] | n,m=map(int,input().split())
a=[int(i)-1 for i in input().split()]
ans1=[i+1 for i in range(n)]
ans2=[-1 for i in range(n)]
for i in set(a):
ans1[i]=1
N=1
while N<n+m:N<<=1
st=[0 for i in range(N<<1)]
pos=[i+m for i in range(n)]
for i in range(n):
st[i+N+m]=1
for i in range(N-1,0,-1):
st[i]=st[i<<1]+st[i<<1|1]
def up(i,v):
i+=N
st[i]=v
i>>=1
while i>0:
st[i]=st[i<<1]+st[i<<1|1]
i>>=1
def qr(l,r=N):
l+=N
r+=N
ans=0
while l<r:
if l&1:
ans+=st[l]
l+=1
if r&1:
r-=1
ans+=ans[r]
l>>=1
r>>=1
return(ans)
for j in range(m):
x=a[j]
i=pos[x]
ans2[x]=max(ans2[x],n-qr(i+1))
up(i,0)
pos[x]=m-1-j
up(pos[x],1)
for i in range(n):
x=pos[i]
ans2[i]=max(ans2[i],n-qr(x+1))
for i in range(n):
print(ans1[i],ans2[i]) | {
"input": [
"5 4\n3 5 1 4\n",
"4 3\n1 2 4\n"
],
"output": [
"1 3\n2 5\n1 4\n1 5\n1 5\n",
"1 3\n1 2\n3 4\n1 4\n"
]
} |
1,290 | 9 | You are given two positive integers n and k. Print the k-th positive integer that is not divisible by n.
For example, if n=3, and k=7, then all numbers that are not divisible by 3 are: 1, 2, 4, 5, 7, 8, 10, 11, 13 .... The 7-th number among them is 10.
Input
The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases in the input. Next, t test cases are given, one per line.
Each test case is two positive integers n (2 ≤ n ≤ 10^9) and k (1 ≤ k ≤ 10^9).
Output
For each test case print the k-th positive integer that is not divisible by n.
Example
Input
6
3 7
4 12
2 1000000000
7 97
1000000000 1000000000
2 1
Output
10
15
1999999999
113
1000000001
1 | def call():
n,k = map(int,input().split())
print(k+((k-1)//(n-1)))
for i in range(int(input())):
call() | {
"input": [
"6\n3 7\n4 12\n2 1000000000\n7 97\n1000000000 1000000000\n2 1\n"
],
"output": [
"10\n15\n1999999999\n113\n1000000001\n1\n"
]
} |
1,291 | 7 | You have been blessed as a child of Omkar. To express your gratitude, please solve this problem for Omkar!
An array a of length n is called complete if all elements are positive and don't exceed 1000, and for all indices x,y,z (1 ≤ x,y,z ≤ n), a_{x}+a_{y} ≠ a_{z} (not necessarily distinct).
You are given one integer n. Please find any complete array of length n. It is guaranteed that under given constraints such array exists.
Input
Each test contains multiple test cases. The first line contains t (1 ≤ t ≤ 1000) — the number of test cases. Description of the test cases follows.
The only line of each test case contains one integer n (1 ≤ n ≤ 1000).
It is guaranteed that the sum of n over all test cases does not exceed 1000.
Output
For each test case, print a complete array on a single line. All elements have to be integers between 1 and 1000 and for all indices x,y,z (1 ≤ x,y,z ≤ n) (not necessarily distinct), a_{x}+a_{y} ≠ a_{z} must hold.
If multiple solutions exist, you may print any.
Example
Input
2
5
4
Output
1 5 3 77 12
384 384 44 44
Note
It can be shown that the outputs above are valid for each test case. For example, 44+44 ≠ 384.
Below are some examples of arrays that are NOT complete for the 1st test case:
[1,2,3,4,5]
Notice that a_{1}+a_{2} = a_{3}.
[1,3000,1,300,1]
Notice that a_{2} = 3000 > 1000. | def main():
for _ in range(int(input())):
n=int(input())
print(*([1]*n))
main() | {
"input": [
"2\n5\n4\n"
],
"output": [
"1 1 1 1 1\n1 1 1 1\n"
]
} |
1,292 | 9 | A new agent called Killjoy invented a virus COVID-2069 that infects accounts on Codeforces. Each account has a rating, described by an integer (it can possibly be negative or very large).
Killjoy's account is already infected and has a rating equal to x. Its rating is constant. There are n accounts except hers, numbered from 1 to n. The i-th account's initial rating is a_i. Any infected account (initially the only infected account is Killjoy's) instantly infects any uninfected account if their ratings are equal. This can happen at the beginning (before any rating changes) and after each contest. If an account is infected, it can not be healed.
Contests are regularly held on Codeforces. In each contest, any of these n accounts (including infected ones) can participate. Killjoy can't participate. After each contest ratings are changed this way: each participant's rating is changed by an integer, but the sum of all changes must be equal to zero. New ratings can be any integer.
Find out the minimal number of contests needed to infect all accounts. You can choose which accounts will participate in each contest and how the ratings will change.
It can be proven that all accounts can be infected in some finite number of contests.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. The next 2t lines contain the descriptions of all test cases.
The first line of each test case contains two integers n and x (2 ≤ n ≤ 10^3, -4000 ≤ x ≤ 4000) — the number of accounts on Codeforces and the rating of Killjoy's account.
The second line of each test case contains n integers a_1, a_2, ..., a_n (-4000 ≤ a_i ≤ 4000) — the ratings of other accounts.
Output
For each test case output the minimal number of contests needed to infect all accounts.
Example
Input
3
2 69
68 70
6 4
4 4 4 4 4 4
9 38
-21 83 50 -59 -77 15 -71 -78 20
Output
1
0
2
Note
In the first test case it's possible to make all ratings equal to 69. First account's rating will increase by 1, and second account's rating will decrease by 1, so the sum of all changes will be equal to zero.
In the second test case all accounts will be instantly infected, because all ratings (including Killjoy's account's rating) are equal to 4. | def func(a,x):
ans = 0
for i in a:
ans += x-i
return ans==0
for _ in range(int(input())):
n,x = map(int,input().split())
a = list(map(int,input().split()))
if min(a)==max(a)==x:
print(0)
else:
if func(a,x) or x in a:
print(1)
else:
print(2)
| {
"input": [
"3\n2 69\n68 70\n6 4\n4 4 4 4 4 4\n9 38\n-21 83 50 -59 -77 15 -71 -78 20\n"
],
"output": [
"1\n0\n2\n"
]
} |
1,293 | 9 | Chef Monocarp has just put n dishes into an oven. He knows that the i-th dish has its optimal cooking time equal to t_i minutes.
At any positive integer minute T Monocarp can put no more than one dish out of the oven. If the i-th dish is put out at some minute T, then its unpleasant value is |T - t_i| — the absolute difference between T and t_i. Once the dish is out of the oven, it can't go back in.
Monocarp should put all the dishes out of the oven. What is the minimum total unpleasant value Monocarp can obtain?
Input
The first line contains a single integer q (1 ≤ q ≤ 200) — the number of testcases.
Then q testcases follow.
The first line of the testcase contains a single integer n (1 ≤ n ≤ 200) — the number of dishes in the oven.
The second line of the testcase contains n integers t_1, t_2, ..., t_n (1 ≤ t_i ≤ n) — the optimal cooking time for each dish.
The sum of n over all q testcases doesn't exceed 200.
Output
Print a single integer for each testcase — the minimum total unpleasant value Monocarp can obtain when he puts out all the dishes out of the oven. Remember that Monocarp can only put the dishes out at positive integer minutes and no more than one dish at any minute.
Example
Input
6
6
4 2 4 4 5 2
7
7 7 7 7 7 7 7
1
1
5
5 1 2 4 3
4
1 4 4 4
21
21 8 1 4 1 5 21 1 8 21 11 21 11 3 12 8 19 15 9 11 13
Output
4
12
0
0
2
21
Note
In the first example Monocarp can put out the dishes at minutes 3, 1, 5, 4, 6, 2. That way the total unpleasant value will be |4 - 3| + |2 - 1| + |4 - 5| + |4 - 4| + |6 - 5| + |2 - 2| = 4.
In the second example Monocarp can put out the dishes at minutes 4, 5, 6, 7, 8, 9, 10.
In the third example Monocarp can put out the dish at minute 1.
In the fourth example Monocarp can put out the dishes at minutes 5, 1, 2, 4, 3.
In the fifth example Monocarp can put out the dishes at minutes 1, 3, 4, 5. | from functools import lru_cache
INF = 10**9
for _ in range(int(input())):
nn = int(input())
a = [0] + list(map(int, input().split()))
a.sort()
@lru_cache(maxsize=None)
def f(n, k):
if n < 0 or k < 0: return INF
if n == 0 and k == 0: return 0
return min(f(n, k - 1), f(n - 1, k - 1) + abs(a[n] - k))
print(f(nn, 410))
| {
"input": [
"6\n6\n4 2 4 4 5 2\n7\n7 7 7 7 7 7 7\n1\n1\n5\n5 1 2 4 3\n4\n1 4 4 4\n21\n21 8 1 4 1 5 21 1 8 21 11 21 11 3 12 8 19 15 9 11 13\n"
],
"output": [
"4\n12\n0\n0\n2\n21\n"
]
} |
1,294 | 7 | Polycarp has a favorite sequence a[1 ... n] consisting of n integers. He wrote it out on the whiteboard as follows:
* he wrote the number a_1 to the left side (at the beginning of the whiteboard);
* he wrote the number a_2 to the right side (at the end of the whiteboard);
* then as far to the left as possible (but to the right from a_1), he wrote the number a_3;
* then as far to the right as possible (but to the left from a_2), he wrote the number a_4;
* Polycarp continued to act as well, until he wrote out the entire sequence on the whiteboard.
<image> The beginning of the result looks like this (of course, if n ≥ 4).
For example, if n=7 and a=[3, 1, 4, 1, 5, 9, 2], then Polycarp will write a sequence on the whiteboard [3, 4, 5, 2, 9, 1, 1].
You saw the sequence written on the whiteboard and now you want to restore Polycarp's favorite sequence.
Input
The first line contains a single positive integer t (1 ≤ t ≤ 300) — the number of test cases in the test. Then t test cases follow.
The first line of each test case contains an integer n (1 ≤ n ≤ 300) — the length of the sequence written on the whiteboard.
The next line contains n integers b_1, b_2,…, b_n (1 ≤ b_i ≤ 10^9) — the sequence written on the whiteboard.
Output
Output t answers to the test cases. Each answer — is a sequence a that Polycarp wrote out on the whiteboard.
Example
Input
6
7
3 4 5 2 9 1 1
4
9 2 7 1
11
8 4 3 1 2 7 8 7 9 4 2
1
42
2
11 7
8
1 1 1 1 1 1 1 1
Output
3 1 4 1 5 9 2
9 1 2 7
8 2 4 4 3 9 1 7 2 8 7
42
11 7
1 1 1 1 1 1 1 1
Note
In the first test case, the sequence a matches the sequence from the statement. The whiteboard states after each step look like this:
[3] ⇒ [3, 1] ⇒ [3, 4, 1] ⇒ [3, 4, 1, 1] ⇒ [3, 4, 5, 1, 1] ⇒ [3, 4, 5, 9, 1, 1] ⇒ [3, 4, 5, 2, 9, 1, 1]. | def solve():
n=int(input())
a=list(map(int, input().split()))
for i in range (n):
print(a[i//2] if i%2==0 else a[n-i//2-1], end=' ')
print()
t=int(input())
while t:
solve()
t-=1 | {
"input": [
"6\n7\n3 4 5 2 9 1 1\n4\n9 2 7 1\n11\n8 4 3 1 2 7 8 7 9 4 2\n1\n42\n2\n11 7\n8\n1 1 1 1 1 1 1 1\n"
],
"output": [
"\n3 1 4 1 5 9 2 \n9 1 2 7 \n8 2 4 4 3 9 1 7 2 8 7 \n42 \n11 7 \n1 1 1 1 1 1 1 1 \n"
]
} |
1,295 | 8 | Suppose you are living with two cats: A and B. There are n napping spots where both cats usually sleep.
Your cats like to sleep and also like all these spots, so they change napping spot each hour cyclically:
* Cat A changes its napping place in order: n, n - 1, n - 2, ..., 3, 2, 1, n, n - 1, ... In other words, at the first hour it's on the spot n and then goes in decreasing order cyclically;
* Cat B changes its napping place in order: 1, 2, 3, ..., n - 1, n, 1, 2, ... In other words, at the first hour it's on the spot 1 and then goes in increasing order cyclically.
The cat B is much younger, so they have a strict hierarchy: A and B don't lie together. In other words, if both cats'd like to go in spot x then the A takes this place and B moves to the next place in its order (if x < n then to x + 1, but if x = n then to 1). Cat B follows his order, so it won't return to the skipped spot x after A frees it, but will move to the spot x + 2 and so on.
Calculate, where cat B will be at hour k?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first and only line of each test case contains two integers n and k (2 ≤ n ≤ 10^9; 1 ≤ k ≤ 10^9) — the number of spots and hour k.
Output
For each test case, print one integer — the index of the spot where cat B will sleep at hour k.
Example
Input
7
2 1
2 2
3 1
3 2
3 3
5 5
69 1337
Output
1
2
1
3
2
2
65
Note
In the first and second test cases n = 2, so:
* at the 1-st hour, A is on spot 2 and B is on 1;
* at the 2-nd hour, A moves to spot 1 and B — to 2.
If n = 3 then:
* at the 1-st hour, A is on spot 3 and B is on 1;
* at the 2-nd hour, A moves to spot 2; B'd like to move from 1 to 2, but this spot is occupied, so it moves to 3;
* at the 3-rd hour, A moves to spot 1; B also would like to move from 3 to 1, but this spot is occupied, so it moves to 2.
In the sixth test case:
* A's spots at each hour are [5, 4, 3, 2, 1];
* B's spots at each hour are [1, 2, 4, 5, 2]. | def func(n, k):
f = n//2
k -= 1
print((k + (n % 2) * (k//f)) % n+1)
for _ in range(int(input())):
n, k = (map(int, input().split()))
func(n, k)
| {
"input": [
"7\n2 1\n2 2\n3 1\n3 2\n3 3\n5 5\n69 1337\n"
],
"output": [
"\n1\n2\n1\n3\n2\n2\n65\n"
]
} |
1,296 | 10 | You are given two integers a and b. In one turn, you can do one of the following operations:
* Take an integer c (c > 1 and a should be divisible by c) and replace a with a/c;
* Take an integer c (c > 1 and b should be divisible by c) and replace b with b/c.
Your goal is to make a equal to b using exactly k turns.
For example, the numbers a=36 and b=48 can be made equal in 4 moves:
* c=6, divide b by c ⇒ a=36, b=8;
* c=2, divide a by c ⇒ a=18, b=8;
* c=9, divide a by c ⇒ a=2, b=8;
* c=4, divide b by c ⇒ a=2, b=2.
For the given numbers a and b, determine whether it is possible to make them equal using exactly k turns.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
Each test case is contains three integers a, b and k (1 ≤ a, b, k ≤ 10^9).
Output
For each test case output:
* "Yes", if it is possible to make the numbers a and b equal in exactly k turns;
* "No" otherwise.
The strings "Yes" and "No" can be output in any case.
Example
Input
8
36 48 2
36 48 3
36 48 4
2 8 1
2 8 2
1000000000 1000000000 1000000000
1 2 1
2 2 1
Output
YES
YES
YES
YES
YES
NO
YES
NO | def d(n):
a=0;d=3
while~n&1:n>>=1;a+=1
while d*d<=n:
while n%d<1:n//=d;a+=1
d+=2
return a+(n>1)
for s in[*open(0)][1:]:a,b,k=map(int,s.split());print("YNEOS"[[k>d(a)+d(b),0<max(a,b)%min(a,b)or a==b][k<2]::2]) | {
"input": [
"8\n36 48 2\n36 48 3\n36 48 4\n2 8 1\n2 8 2\n1000000000 1000000000 1000000000\n1 2 1\n2 2 1\n"
],
"output": [
"\nYES\nYES\nYES\nYES\nYES\nNO\nYES\nNO\n"
]
} |
1,297 | 7 | John Doe started thinking about graphs. After some thought he decided that he wants to paint an undirected graph, containing exactly k cycles of length 3.
A cycle of length 3 is an unordered group of three distinct graph vertices a, b and c, such that each pair of them is connected by a graph edge.
John has been painting for long, but he has not been a success. Help him find such graph. Note that the number of vertices there shouldn't exceed 100, or else John will have problems painting it.
Input
A single line contains an integer k (1 ≤ k ≤ 105) — the number of cycles of length 3 in the required graph.
Output
In the first line print integer n (3 ≤ n ≤ 100) — the number of vertices in the found graph. In each of next n lines print n characters "0" and "1": the i-th character of the j-th line should equal "0", if vertices i and j do not have an edge between them, otherwise it should equal "1". Note that as the required graph is undirected, the i-th character of the j-th line must equal the j-th character of the i-th line. The graph shouldn't contain self-loops, so the i-th character of the i-th line must equal "0" for all i.
Examples
Input
1
Output
3
011
101
110
Input
10
Output
5
01111
10111
11011
11101
11110 | # Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def main():
k=int(input())
l=3
r=100
while l<=r :
n=l+((r-l)>>1)
if (n*(n-1)*(n-2))//6 <= k:
l=n+1
else:
r=n-1
n=l-1
ans=[[0 for _ in range(100)] for _ in range(100)]
for i in range(n):
for j in range(i+1,n):
ans[i][j]=ans[j][i]=1
k-=(n*(n-1)*(n-2))//6
while k>0:
z=2
while ((z+1)*z)>>1 <=k:
z+=1
k-=((z*(z-1))>>1)
n+=1
for i in range(z):
ans[i][n]=ans[n][i]=1
print(100)
for item in ans:
print(*item,sep="")
#----------------------------------------------------------------------------------------
# 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() | {
"input": [
"1\n",
"10\n"
],
"output": [
"3\n011\n101\n110\n",
"5\n01111\n10111\n11011\n11101\n11110\n"
]
} |
1,298 | 11 | Victor and Peter are playing hide-and-seek. Peter has hidden, and Victor is to find him. In the room where they are playing, there is only one non-transparent wall and one double-sided mirror. Victor and Peter are points with coordinates (xv, yv) and (xp, yp) respectively. The wall is a segment joining points with coordinates (xw, 1, yw, 1) and (xw, 2, yw, 2), the mirror — a segment joining points (xm, 1, ym, 1) and (xm, 2, ym, 2).
If an obstacle has a common point with a line of vision, it's considered, that the boys can't see each other with this line of vision. If the mirror has a common point with the line of vision, it's considered, that the boys can see each other in the mirror, i.e. reflection takes place. The reflection process is governed by laws of physics — the angle of incidence is equal to the angle of reflection. The incident ray is in the same half-plane as the reflected ray, relative to the mirror. I.e. to see each other Victor and Peter should be to the same side of the line, containing the mirror (see example 1). If the line of vision is parallel to the mirror, reflection doesn't take place, and the mirror isn't regarded as an obstacle (see example 4).
Victor got interested if he can see Peter, while standing at the same spot. Help him solve this problem.
Input
The first line contains two numbers xv and yv — coordinates of Victor.
The second line contains two numbers xp and yp — coordinates of Peter.
The third line contains 4 numbers xw, 1, yw, 1, xw, 2, yw, 2 — coordinates of the wall.
The forth line contains 4 numbers xm, 1, ym, 1, xm, 2, ym, 2 — coordinates of the mirror.
All the coordinates are integer numbers, and don't exceed 104 in absolute value. It's guaranteed, that the segments don't have common points, Victor and Peter are not on any of the segments, coordinates of Victor and Peter aren't the same, the segments don't degenerate into points.
Output
Output YES, if Victor can see Peter without leaving the initial spot. Otherwise output NO.
Examples
Input
-1 3
1 3
0 2 0 4
0 0 0 1
Output
NO
Input
0 0
1 1
0 1 1 0
-100 -100 -101 -101
Output
NO
Input
0 0
1 1
0 1 1 0
-1 1 1 3
Output
YES
Input
0 0
10 0
100 100 101 101
1 0 3 0
Output
YES | xv,yv=list(map(int,input().split()))
xp,yp=list(map(int,input().split()))
xw1,yw1,xw2,yw2=list(map(int,input().split()))
xm1,ym1,xm2,ym2=list(map(int,input().split()))
def a(x1,y1,x2,y2,x3,y3,x4,y4):
if x1==x2:
if x3==x4:
return False
else:
k2=(y3-y4)/(x3-x4)
b2=y3-k2*x3
return min(y3,y4)<=k2*x1+b2<=max(y3,y4) and min(y1,y2)<=k2*x1+b2<=max(y1,y2) and min(x3,x4)<=x1<=max(x3,x4) and min(x1,x2)<=x1<=max(x1,x2)
else:
if x3==x4:
k1=(y1-y2)/(x1-x2)
b1=y1-k1*x1
return min(y3,y4)<=k1*x3+b1<=max(y3,y4) and min(y1,y2)<=k1*x3+b1<=max(y1,y2) and min(x3,x4)<=x3<=max(x3,x4) and min(x1,x2)<=x3<=max(x1,x2)
else:
k1=(y1-y2)/(x1-x2)
b1=y1-k1*x1
k2=(y3-y4)/(x3-x4)
b2=y3-k2*x3
if k1==k2:
return b1==b2 and min(x1,x2)<=min(x3,x4)<=max(x1,x2) and min(y1,y2)<=min(y3,y4)<=max(y1,y2)
x=(b2-b1)/(k1-k2)
y=k1*x+b1
return min(y3,y4)<=y<=max(y3,y4) and min(y1,y2)<=y<=max(y1,y2) and min(x3,x4)<=x<=max(x3,x4) and min(x1,x2)<=x<=max(x1,x2)
def b(xm1,xm2,ym1,ym2,x,y):
if ym1==ym2:
xi=x
yi=2*ym1-y
elif xm1==xm2:
yi=y
xi=2*xm1-x
else:
k1=-(xm1-xm2)/(ym1-ym2)
b1=y-k1*x
k2=(ym1-ym2)/(xm1-xm2)
b2=ym1-k2*xm1
x1=(b2-b1)/(k1-k2)
xi=2*x1-x
yi=k1*xi+b1
return [xi,yi]
xw3,yw3=b(xm1,xm2,ym1,ym2,xw1,yw1)
xw4,yw4=b(xm1,xm2,ym1,ym2,xw2,yw2)
if a(xv,yv,xp,yp,xw1,yw1,xw2,yw2) or a(xv,yv,xp,yp,xm1,ym1,xm2,ym2):
xip,yip=b(xm1,xm2,ym1,ym2,xp,yp)
if [xip,yip]!=[xv,yv] and a(xv,yv,xip,yip,xm1,ym1,xm2,ym2) and not(a(xv,yv,xip,yip,xw1,yw1,xw2,yw2)) and not(a(xv,yv,xip,yip,xw3,yw3,xw4,yw4)):
print('YES')
else:
print('NO')
else:
print('YES') | {
"input": [
"0 0\n10 0\n100 100 101 101\n1 0 3 0\n",
"-1 3\n1 3\n0 2 0 4\n0 0 0 1\n",
"0 0\n1 1\n0 1 1 0\n-100 -100 -101 -101\n",
"0 0\n1 1\n0 1 1 0\n-1 1 1 3\n"
],
"output": [
"YES",
"NO",
"NO",
"YES"
]
} |
1,299 | 7 | User ainta loves to play with cards. He has a cards containing letter "o" and b cards containing letter "x". He arranges the cards in a row, and calculates the score of the deck by the formula below.
1. At first, the score is 0.
2. For each block of contiguous "o"s with length x the score increases by x2.
3. For each block of contiguous "x"s with length y the score decreases by y2.
For example, if a = 6, b = 3 and ainta have arranged the cards in the order, that is described by string "ooxoooxxo", the score of the deck equals 22 - 12 + 32 - 22 + 12 = 9. That is because the deck has 5 blocks in total: "oo", "x", "ooo", "xx", "o".
User ainta likes big numbers, so he wants to maximize the score with the given cards. Help ainta make the score as big as possible. Note, that he has to arrange all his cards.
Input
The first line contains two space-separated integers a and b (0 ≤ a, b ≤ 105; a + b ≥ 1) — the number of "o" cards and the number of "x" cards.
Output
In the first line print a single integer v — the maximum score that ainta can obtain.
In the second line print a + b characters describing the deck. If the k-th card of the deck contains "o", the k-th character must be "o". If the k-th card of the deck contains "x", the k-th character must be "x". The number of "o" characters must be equal to a, and the number of "x " characters must be equal to b. If there are many ways to maximize v, print any.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
2 3
Output
-1
xoxox
Input
4 0
Output
16
oooo
Input
0 4
Output
-16
xxxx | a,b=map(int,input().split())
def sqr(x):
return x*x
def work( num, flag=0 ):
ans=sqr(a-num+1)+num-1
could = min(b, num+1)
cc=b//could
res=b%could
ans-=res * sqr(cc+1) + (could-res)*sqr(cc)
if flag:
print(ans)
list=''
res2=could-res
if could==num+1:
list+='x'*cc
res2-=1
ta=a
list+='o'*(a-num+1)
ta-=a-num+1
while ta>0:
u=cc+int(res>0)
if res>0:
res-=1
else:
res2-=1
list+='x'*u
list+='o'
ta-=1
if res>0 or res2>0:
list+='x'*(cc+int(res>0))
print(str(list))
return ans
if a==0:
print(-sqr(b))
print('x'*b)
elif b==0:
print(sqr(a))
print('o'*a)
else:
now=1
for i in range(1,a+1):
if i-1<=b and work(i)>work(now):
now=i
work(now,1)
| {
"input": [
"2 3\n",
"4 0\n",
"0 4\n"
],
"output": [
"-1\nxxoox",
"16\noooo\n",
"-16\nxxxx\n"
]
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.