name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
1446_D1. Frequency Problem (Easy Version) | This is the easy version of the problem. The difference between the versions is in the constraints on the array elements. You can make hacks only if all versions of the problem are solved.
You are given an array [a_1, a_2, ..., a_n].
Your goal is to find the length of the longest subarray of this array such that the most frequent value in it is not unique. In other words, you are looking for a subarray such that if the most frequent value occurs f times in this subarray, then at least 2 different values should occur exactly f times.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ min(n, 100)) — elements of the array.
Output
You should output exactly one integer — the length of the longest subarray of the array whose most frequent value is not unique. If there is no such subarray, output 0.
Examples
Input
7
1 1 2 2 3 3 3
Output
6
Input
10
1 1 1 5 4 1 3 1 2 2
Output
7
Input
1
1
Output
0
Note
In the first sample, the subarray [1, 1, 2, 2, 3, 3] is good, but [1, 1, 2, 2, 3, 3, 3] isn't: in the latter there are 3 occurrences of number 3, and no other element appears 3 times. | ```python
import sys
from collections import defaultdict, Counter
import sys
import os
from io import BytesIO, IOBase
#Fast IO Region
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")
N = int(input())
arr = list(map(int, input().split()))
freq = Counter(arr)
ans = 0
fix = freq.most_common(1)[0][0]
for other in freq:
if other == fix:
continue
pref, last_pos = [0] * (N+2), {0:0}
for i in range(N):
now = 1 if arr[i] == other else 0
pref[i+1] = pref[i] + (-1 if arr[i] == fix else now)
last_pos.setdefault(pref[i+1], i+1)
ans = max(ans, i+1 - last_pos[pref[i+1]])
print(ans)
``` |
1470_D. Strange Housing | Students of Winter Informatics School are going to live in a set of houses connected by underground passages. Teachers are also going to live in some of these houses, but they can not be accommodated randomly. For safety reasons, the following must hold:
* All passages between two houses will be closed, if there are no teachers in both of them. All other passages will stay open.
* It should be possible to travel between any two houses using the underground passages that are open.
* Teachers should not live in houses, directly connected by a passage.
Please help the organizers to choose the houses where teachers will live to satisfy the safety requirements or determine that it is impossible.
Input
The first input line contains a single integer t — the number of test cases (1 ≤ t ≤ 10^5).
Each test case starts with two integers n and m (2 ≤ n ≤ 3 ⋅ 10^5, 0 ≤ m ≤ 3 ⋅ 10^5) — the number of houses and the number of passages.
Then m lines follow, each of them contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v), describing a passage between the houses u and v. It is guaranteed that there are no two passages connecting the same pair of houses.
The 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, if there is no way to choose the desired set of houses, output "NO". Otherwise, output "YES", then the total number of houses chosen, and then the indices of the chosen houses in arbitrary order.
Examples
Input
2
3 2
3 2
2 1
4 2
1 4
2 3
Output
YES
2
1 3
NO
Input
1
17 27
1 8
2 9
3 10
4 11
5 12
6 13
7 14
8 9
8 14
8 15
9 10
9 15
10 11
10 15
10 17
11 12
11 17
12 13
12 16
12 17
13 14
13 16
14 16
14 15
15 16
15 17
16 17
Output
YES
8
1 3 4 5 6 9 14 17
Note
The picture below shows the second example test.
<image> | ```python
import io
import os
from collections import deque
def solve(N, M, edges):
graph = [[] for i in range(N)]
for u, v in edges:
graph[u].append(v)
graph[v].append(u)
source = 0
q = deque([source])
isTeacher = {}
while q:
node = q.popleft()
if node in isTeacher:
continue
for nbr in graph[node]:
if nbr in isTeacher and isTeacher[nbr] == 1:
isTeacher[node] = 0
break
else:
isTeacher[node] = 1
for nbr in graph[node]:
if nbr not in isTeacher:
q.append(nbr)
if len(isTeacher) != N:
return "NO"
ans = [str(k + 1) for k, v in isTeacher.items() if v]
return "YES\n" + str(len(ans)) + "\n" + " ".join(ans)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
(N, M) = [int(x) for x in input().split()]
edges = [[int(x) - 1 for x in input().split()] for i in range(M)] # 0 indexed
ans = solve(N, M, edges)
print(ans)
``` |
1497_C2. k-LCM (hard version) | It is the hard version of the problem. The only difference is that in this version 3 ≤ k ≤ n.
You are given a positive integer n. Find k positive integers a_1, a_2, …, a_k, such that:
* a_1 + a_2 + … + a_k = n
* LCM(a_1, a_2, …, a_k) ≤ n/2
Here LCM is the [least common multiple](https://en.wikipedia.org/wiki/Least_common_multiple) of numbers a_1, a_2, …, a_k.
We can show that for given constraints the answer always exists.
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The only line of each test case contains two integers n, k (3 ≤ n ≤ 10^9, 3 ≤ k ≤ n).
It is guaranteed that the sum of k over all test cases does not exceed 10^5.
Output
For each test case print k positive integers a_1, a_2, …, a_k, for which all conditions are satisfied.
Example
Input
2
6 4
9 5
Output
1 2 2 1
1 3 3 1 1 | ```python
for nt in range(int(input())):
n, k = map(int,input().split())
ans = [1]*(k-3)
n -= (k-3)
if n%2:
ans.extend([1, n//2, n//2])
else:
if n//2%2:
ans.extend([2, n//2-1, n//2-1])
else:
ans.extend([n//2, n//4, n//4])
print (*ans)
``` |
151_B. Phone Numbers | Winters are just damn freezing cold in Nvodsk! That's why a group of n friends prefers to take a taxi, order a pizza and call girls. The phone numbers in the city consist of three pairs of digits (for example, 12-34-56). Each friend has a phonebook of size si (that's the number of phone numbers). We know that taxi numbers consist of six identical digits (for example, 22-22-22), the numbers of pizza deliveries should necessarily be decreasing sequences of six different digits (for example, 98-73-21), all other numbers are the girls' numbers.
You are given your friends' phone books. Calculate which friend is best to go to when you are interested in each of those things (who has maximal number of phone numbers of each type).
If the phone book of one person contains some number two times, you should count it twice. That is, each number should be taken into consideration the number of times it occurs in the phone book.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of friends.
Then follow n data blocks that describe each friend's phone books. Each block is presented in the following form: first goes the line that contains integer si and string namei (0 ≤ si ≤ 100) — the number of phone numbers in the phone book of the i-th friend and the name of the i-th friend. The name is a non-empty sequence of uppercase and lowercase Latin letters, containing no more than 20 characters. Next si lines contain numbers as "XX-XX-XX", where X is arbitrary digits from 0 to 9.
Output
In the first line print the phrase "If you want to call a taxi, you should call: ". Then print names of all friends whose phone books contain maximal number of taxi phone numbers.
In the second line print the phrase "If you want to order a pizza, you should call: ". Then print names of all friends who have maximal number of pizza phone numbers.
In the third line print the phrase "If you want to go to a cafe with a wonderful girl, you should call: ". Then print names of all friends who have maximal number of girls' phone numbers.
Print the names in the order in which they are given in the input data. Separate two consecutive names with a comma and a space. Each line should end with exactly one point. For clarifications concerning the output form, see sample tests. It is necessary that you follow the output form strictly. Extra spaces are not allowed.
Examples
Input
4
2 Fedorov
22-22-22
98-76-54
3 Melnikov
75-19-09
23-45-67
99-99-98
7 Rogulenko
22-22-22
11-11-11
33-33-33
44-44-44
55-55-55
66-66-66
95-43-21
3 Kaluzhin
11-11-11
99-99-99
98-65-32
Output
If you want to call a taxi, you should call: Rogulenko.
If you want to order a pizza, you should call: Fedorov, Rogulenko, Kaluzhin.
If you want to go to a cafe with a wonderful girl, you should call: Melnikov.
Input
3
5 Gleb
66-66-66
55-55-55
01-01-01
65-43-21
12-34-56
3 Serega
55-55-55
87-65-43
65-55-21
5 Melnik
12-42-12
87-73-01
36-04-12
88-12-22
82-11-43
Output
If you want to call a taxi, you should call: Gleb.
If you want to order a pizza, you should call: Gleb, Serega.
If you want to go to a cafe with a wonderful girl, you should call: Melnik.
Input
3
3 Kulczynski
22-22-22
65-43-21
98-12-00
4 Pachocki
11-11-11
11-11-11
11-11-11
98-76-54
0 Smietanka
Output
If you want to call a taxi, you should call: Pachocki.
If you want to order a pizza, you should call: Kulczynski, Pachocki.
If you want to go to a cafe with a wonderful girl, you should call: Kulczynski.
Note
In the first sample you are given four friends. Fedorov's phone book contains one taxi number and one pizza delivery number, Melnikov's phone book only has 3 numbers of girls, Rogulenko's one has 6 taxi numbers and one pizza delivery number, Kaluzhin's one contains 2 taxi numbers and one pizza delivery number.
Thus, if you need to order a taxi, you should obviously call Rogulenko, if you need to order a pizza you should call anybody of the following: Rogulenko, Fedorov, Kaluzhin (each of them has one number). Melnikov has maximal number of phone numbers of girls. | ```python
def num_type(h):
if h.count(h[0]) == 6:
return 0
for i in range(1,6):
if h[i] >= h[i-1]:
return 2
return 1
def pri(g,ind,p):
[maxx,st]=[0,[]]
for i in range(len(p)):
if p[i][ind] == maxx:
st.append(p[i][-1])
elif p[i][ind] > maxx:
maxx=p[i][ind]
st=[p[i][-1]]
print(g,", ".join(st)+".")
def main():
mode="filee"
if mode=="file":f=open("test.txt","r")
get = lambda :[int(x) for x in (f.readline() if mode=="file" else input()).split()]
gets = lambda :[str(x) for x in (f.readline() if mode=="file" else input()).split()]
[n] = get()
p=[]
for i in range(n):
[x,g]=gets()
p.append([0,0,0,g])
for j in range(int(x)):
[h]=gets()
h = h.split("-")
h="".join(h)
h=list(h)
p[i][num_type(h)]+=1
#print(p)
pri("If you want to call a taxi, you should call:",0,p)
pri("If you want to order a pizza, you should call:",1,p)
pri("If you want to go to a cafe with a wonderful girl, you should call:",2,p)
if mode=="file":f.close()
if __name__=="__main__":
main()
``` |
1547_B. Alphabetical Strings | A string s of length n (1 ≤ n ≤ 26) is called alphabetical if it can be obtained using the following algorithm:
* first, write an empty string to s (i.e. perform the assignment s := "");
* then perform the next step n times;
* at the i-th step take i-th lowercase letter of the Latin alphabet and write it either to the left of the string s or to the right of the string s (i.e. perform the assignment s := c+s or s := s+c, where c is the i-th letter of the Latin alphabet).
In other words, iterate over the n first letters of the Latin alphabet starting from 'a' and etc. Each time we prepend a letter to the left of the string s or append a letter to the right of the string s. Strings that can be obtained in that way are alphabetical.
For example, the following strings are alphabetical: "a", "ba", "ab", "bac" and "ihfcbadeg". The following strings are not alphabetical: "z", "aa", "ca", "acb", "xyz" and "ddcba".
From the given string, determine if it is alphabetical.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case is written on a separate line that contains one string s. String s consists of lowercase letters of the Latin alphabet and has a length between 1 and 26, inclusive.
Output
Output t lines, each of them must contain the answer to the corresponding test case. Output YES if the given string s is alphabetical and NO otherwise.
You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as a positive answer).
Example
Input
11
a
ba
ab
bac
ihfcbadeg
z
aa
ca
acb
xyz
ddcba
Output
YES
YES
YES
YES
YES
NO
NO
NO
NO
NO
NO
Note
The example contains test cases from the main part of the condition. | ```python
t = int(input())
for amp in range(t):
s = input()
n = len(s)
y = -1
for i in range(n):
if s[i] == "a" :
y = i
break
sol = "YES"
if y == -1 :
sol = "NO"
else:
val = ord(s[y])
l = z = y
q = 1
while q < n :
if l - 1 >= 0 and ord(s[l-1]) == val + 1 :
q += 1
l -= 1
val += 1
elif z + 1 < n and ord(s[z + 1]) == val + 1:
q += 1
z += 1
val += 1
else:
break
if q < n:
sol = "NO"
print(sol)
``` |
194_E. Hamming Distance | Hamming distance between strings a and b of equal length (denoted by h(a, b)) is equal to the number of distinct integers i (1 ≤ i ≤ |a|), such that ai ≠ bi, where ai is the i-th symbol of string a, bi is the i-th symbol of string b. For example, the Hamming distance between strings "aba" and "bba" equals 1, they have different first symbols. For strings "bbba" and "aaab" the Hamming distance equals 4.
John Doe had a paper on which four strings of equal length s1, s2, s3 and s4 were written. Each string si consisted only of lowercase letters "a" and "b". John found the Hamming distances between all pairs of strings he had. Then he lost the paper with the strings but he didn't lose the Hamming distances between all pairs.
Help John restore the strings; find some four strings s'1, s'2, s'3, s'4 of equal length that consist only of lowercase letters "a" and "b", such that the pairwise Hamming distances between them are the same as between John's strings. More formally, set s'i must satisfy the condition <image>.
To make the strings easier to put down on a piece of paper, you should choose among all suitable sets of strings the one that has strings of minimum length.
Input
The first line contains space-separated integers h(s1, s2), h(s1, s3), h(s1, s4). The second line contains space-separated integers h(s2, s3) and h(s2, s4). The third line contains the single integer h(s3, s4).
All given integers h(si, sj) are non-negative and do not exceed 105. It is guaranteed that at least one number h(si, sj) is positive.
Output
Print -1 if there's no suitable set of strings.
Otherwise print on the first line number len — the length of each string. On the i-th of the next four lines print string s'i. If there are multiple sets with the minimum length of the strings, print any of them.
Examples
Input
4 4 4
4 4
4
Output
6
aaaabb
aabbaa
bbaaaa
bbbbbb | ```python
h = [[0 in range(10)] for j in range(10)]
for i in range(1, 4):
h[i] = [0 for j in range(i + 1)] + list(map(int, input().split()))
#for i in range(1, 4):
# print(" ".join(map(str, h[i][1:5])))
if (h[1][2] + h[1][3] < h[2][3] or (h[1][2] + h[1][3] - h[2][3]) % 2 == 1):
print("-1")
exit(0)
BB = (h[1][2] + h[1][3] - h[2][3]) // 2
BA = h[1][2] - BB
AB = h[1][3] - BB
NowB = h[1][4]
NowLen = BB + AB + BA
Now24 = BA + NowB + BB
Now34 = AB + NowB + BB
BAB = 0
ABB = 0
BBB = 0
Dif = (BA - AB) - (h[2][4] - h[3][4])
if (abs(Dif) % 2 == 1):
print("-1")
exit(0)
if Dif < 0:
ABB += abs(Dif) // 2
Now34 -= ABB * 2
#Now24 += ABB
if (AB < ABB or NowB < ABB):
print("-1")
exit(0)
NowB -= ABB
else:
BAB += Dif // 2
Now24 -= BAB * 2
#Now34 += BAB
if (BA < BAB or NowB < BAB):
print("-1")
exit(0)
NowB -= BAB
if (Now24 < h[2][4] or (Now24 - h[2][4]) % 2 == 1):
print("-1")
exit(0)
#print(Now34 - h[3][4])
for i in range(BB + 1):
if (i > NowB):
break
Now = i * 2
if (Now > Now24 - h[2][4]):
break
if min([(NowB - i) // 2, BA - BAB, AB - ABB]) * 2 >= Now24 - h[2][4] - Now:
#print(i, Now24, h[2][4], NowB)
BBB += i
BAB += (Now24 - h[2][4] - Now) // 2
ABB += (Now24 - h[2][4] - Now) // 2
NowB -= i + (Now24 - h[2][4] - Now)
print(NowLen + NowB)
print("".join(["a" for j in range(NowLen)] + ["a" for j in range(NowB)]))
print("".join(["a" for j in range(AB)] + ["b" for j in range(BB + BA)] + ["a" for j in range(NowB)]))
print("".join(["b" for j in range(AB + BB)] + ["a" for j in range(BA)] + ["a" for j in range(NowB)]))
print("".join(["b" for j in range(ABB)] + ["a" for j in range(AB - ABB)] + ["b" for j in range(BBB)] + ["a" for j in range(BB - BBB)] + ["b" for j in range(BAB)] + ["a" for j in range(BA - BAB)] + ["b" for j in range(NowB)]))
exit(0)
print("-1")
``` |
242_B. Big Segment | A coordinate line has n segments, the i-th segment starts at the position li and ends at the position ri. We will denote such a segment as [li, ri].
You have suggested that one of the defined segments covers all others. In other words, there is such segment in the given set, which contains all other ones. Now you want to test your assumption. Find in the given set the segment which covers all other segments, and print its number. If such a segment doesn't exist, print -1.
Formally we will assume that segment [a, b] covers segment [c, d], if they meet this condition a ≤ c ≤ d ≤ b.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of segments. Next n lines contain the descriptions of the segments. The i-th line contains two space-separated integers li, ri (1 ≤ li ≤ ri ≤ 109) — the borders of the i-th segment.
It is guaranteed that no two segments coincide.
Output
Print a single integer — the number of the segment that covers all other segments in the set. If there's no solution, print -1.
The segments are numbered starting from 1 in the order in which they appear in the input.
Examples
Input
3
1 1
2 2
3 3
Output
-1
Input
6
1 5
2 3
1 10
7 10
7 7
10 10
Output
3 | ```python
n = int(input())
segments = []
minl = 10**9
maxr = 1
for i in range(n):
a, b = map(int, input().split())
segments.append((a, b))
if a<minl:
minl = a
if b>maxr:
maxr = b
if (minl, maxr) in segments:
print(segments.index((minl, maxr))+1)
else:
print(-1)
``` |
290_C. WTF? |
HAI
I HAS A TUX
GIMMEH TUX
I HAS A FOO ITS 0
I HAS A BAR ITS 0
I HAS A BAZ ITS 0
I HAS A QUZ ITS 1
TUX IS NOW A NUMBR
IM IN YR LOOP NERFIN YR TUX TIL BOTH SAEM TUX AN 0
I HAS A PUR
GIMMEH PUR
PUR IS NOW A NUMBR
FOO R SUM OF FOO AN PUR
BAR R SUM OF BAR AN 1
BOTH SAEM BIGGR OF PRODUKT OF FOO AN QUZ AN PRODUKT OF BAR BAZ AN PRODUKT OF FOO AN QUZ
O RLY?
YA RLY
BAZ R FOO
QUZ R BAR
OIC
IM OUTTA YR LOOP
BAZ IS NOW A NUMBAR
VISIBLE SMOOSH QUOSHUNT OF BAZ QUZ
KTHXBYE
Input
The input contains between 1 and 10 lines, i-th line contains an integer number xi (0 ≤ xi ≤ 9).
Output
Output a single real number. The answer is considered to be correct if its absolute or relative error does not exceed 10 - 4.
Examples
Input
3
0
1
1
Output
0.666667 | ```python
"""
IM IN YR LOOP NERFIN YR TUX TIL BOTH SAEM TUX AN 0
I HAS A PUR
GIMMEH PUR
PUR IS NOW A NUMBR
FOO R SUM OF FOO AN PUR
BAR R SUM OF BAR AN 1
BOTH SAEM BIGGR OF PRODUKT OF FOO AN QUZ AN PRODUKT OF BAR BAZ AN PRODUKT OF FOO AN QUZ
O RLY?
YA RLY
BAZ R FOO
QUZ R BAR
OIC
IM OUTTA YR LOOP
BAZ IS NOW A NUMBAR
VISIBLE SMOOSH QUOSHUNT OF BAZ QUZ
KTHXBYE
"""
tux, foo, bar, baz, quz = int(input()), 0, 0, 0, 1
while tux != 0:
pur = int(input())
foo += pur
bar += 1
if max(foo * quz, bar * baz) == foo * quz:
baz = foo
quz = bar
tux -= 1
print(float(baz / quz))
``` |
316_B1. EKG | In the rush of modern life, people often forget how beautiful the world is. The time to enjoy those around them is so little that some even stand in queues to several rooms at the same time in the clinic, running from one queue to another.
(Cultural note: standing in huge and disorganized queues for hours is a native tradition in Russia, dating back to the Soviet period. Queues can resemble crowds rather than lines. Not to get lost in such a queue, a person should follow a strict survival technique: you approach the queue and ask who the last person is, somebody answers and you join the crowd. Now you're the last person in the queue till somebody else shows up. You keep an eye on the one who was last before you as he is your only chance to get to your destination) I'm sure many people have had the problem when a stranger asks who the last person in the queue is and even dares to hint that he will be the last in the queue and then bolts away to some unknown destination. These are the representatives of the modern world, in which the ratio of lack of time is so great that they do not even watch foreign top-rated TV series. Such people often create problems in queues, because the newcomer does not see the last person in the queue and takes a place after the "virtual" link in this chain, wondering where this legendary figure has left.
The Smart Beaver has been ill and he's made an appointment with a therapist. The doctor told the Beaver the sad news in a nutshell: it is necessary to do an electrocardiogram. The next day the Smart Beaver got up early, put on the famous TV series on download (three hours till the download's complete), clenched his teeth and bravely went to join a queue to the electrocardiogram room, which is notorious for the biggest queues at the clinic.
Having stood for about three hours in the queue, the Smart Beaver realized that many beavers had not seen who was supposed to stand in the queue before them and there was a huge mess. He came up to each beaver in the ECG room queue and asked who should be in front of him in the queue. If the beaver did not know his correct position in the queue, then it might be his turn to go get an ECG, or maybe he should wait for a long, long time...
As you've guessed, the Smart Beaver was in a hurry home, so he gave you all the necessary information for you to help him to determine what his number in the queue can be.
Input
The first line contains two integers n (1 ≤ n ≤ 103) and x (1 ≤ x ≤ n) — the number of beavers that stand in the queue and the Smart Beaver's number, correspondingly. All willing to get to the doctor are numbered from 1 to n.
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ n) — the number of the beaver followed by the i-th beaver. If ai = 0, then the i-th beaver doesn't know who is should be in front of him. It is guaranteed that values ai are correct. That is there is no cycles in the dependencies. And any beaver is followed by at most one beaver in the queue.
The input limits for scoring 30 points are (subproblem B1):
* It is guaranteed that the number of zero elements ai doesn't exceed 20.
The input limits for scoring 100 points are (subproblems B1+B2):
* The number of zero elements ai is arbitrary.
Output
Print all possible positions of the Smart Beaver in the line in the increasing order.
Examples
Input
6 1
2 0 4 0 6 0
Output
2
4
6
Input
6 2
2 3 0 5 6 0
Output
2
5
Input
4 1
0 0 0 0
Output
1
2
3
4
Input
6 2
0 0 1 0 4 5
Output
1
3
4
6
Note
<image> Picture for the fourth test. | ```python
def f(x, p):
q = []
while x:
q.append(x)
x = p[x]
return q
from collections import defaultdict
n, k = map(int, input().split())
t = list(map(int, input().split()))
p = [0] * (n + 1)
for i, j in enumerate(t, 1):
p[j] = i
p = [f(i, p) for i, j in enumerate(t, 1) if j == 0]
s = defaultdict(int)
for i in p:
if k in i: t = {i.index(k) + 1}
else: s[len(i)] += 1
s = [list(range(i, k * i + 1, i)) for i, k in s.items()]
for q in s:
t |= {x + y for x in q for y in t}
print('\n'.join(map(str, sorted(list(t)))))
``` |
361_B. Levko and Permutation | Levko loves permutations very much. A permutation of length n is a sequence of distinct positive integers, each is at most n.
Let’s assume that value gcd(a, b) shows the greatest common divisor of numbers a and b. Levko assumes that element pi of permutation p1, p2, ... , pn is good if gcd(i, pi) > 1. Levko considers a permutation beautiful, if it has exactly k good elements. Unfortunately, he doesn’t know any beautiful permutation. Your task is to help him to find at least one of them.
Input
The single line contains two integers n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ n).
Output
In a single line print either any beautiful permutation or -1, if such permutation doesn’t exist.
If there are multiple suitable permutations, you are allowed to print any of them.
Examples
Input
4 2
Output
2 4 3 1
Input
1 1
Output
-1
Note
In the first sample elements 4 and 3 are good because gcd(2, 4) = 2 > 1 and gcd(3, 3) = 3 > 1. Elements 2 and 1 are not good because gcd(1, 2) = 1 and gcd(4, 1) = 1. As there are exactly 2 good elements, the permutation is beautiful.
The second sample has no beautiful permutations. | ```python
from sys import stdin,stdout
n,k=map(int ,stdin.readline().strip().split())
if n==k:
print(-1)
else:
result=[0]*n
for i in range(n-k,n):
result[i]=i+1
for i in range(1,n-k):
result[i]=i
result[0]=n-k
print(*result,sep=' ')
``` |
405_D. Toy Sum | Little Chris is very keen on his toy blocks. His teacher, however, wants Chris to solve more problems, so he decided to play a trick on Chris.
There are exactly s blocks in Chris's set, each block has a unique number from 1 to s. Chris's teacher picks a subset of blocks X and keeps it to himself. He will give them back only if Chris can pick such a non-empty subset Y from the remaining blocks, that the equality holds:
<image> "Are you kidding me?", asks Chris.
For example, consider a case where s = 8 and Chris's teacher took the blocks with numbers 1, 4 and 5. One way for Chris to choose a set is to pick the blocks with numbers 3 and 6, see figure. Then the required sums would be equal: (1 - 1) + (4 - 1) + (5 - 1) = (8 - 3) + (8 - 6) = 7.
<image>
However, now Chris has exactly s = 106 blocks. Given the set X of blocks his teacher chooses, help Chris to find the required set Y!
Input
The first line of input contains a single integer n (1 ≤ n ≤ 5·105), the number of blocks in the set X. The next line contains n distinct space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 106), the numbers of the blocks in X.
Note: since the size of the input and output could be very large, don't use slow output techniques in your language. For example, do not use input and output streams (cin, cout) in C++.
Output
In the first line of output print a single integer m (1 ≤ m ≤ 106 - n), the number of blocks in the set Y. In the next line output m distinct space-separated integers y1, y2, ..., ym (1 ≤ yi ≤ 106), such that the required equality holds. The sets X and Y should not intersect, i.e. xi ≠ yj for all i, j (1 ≤ i ≤ n; 1 ≤ j ≤ m). It is guaranteed that at least one solution always exists. If there are multiple solutions, output any of them.
Examples
Input
3
1 4 5
Output
2
999993 1000000
Input
1
1
Output
1
1000000 | ```python
import sys
from math import gcd,sqrt,ceil
from collections import defaultdict,Counter,deque
import math
# input=sys.stdin.readline
# def print(x):
# sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP1/output.txt",'w')
# sys.stdin=open("CP1/input.txt",'r')
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# import sys
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def get_sum(bit,i):
s = 0
i+=1
while i>0:
s+=bit[i]
i-=i&(-i)
return s
def update(bit,n,i,v):
i+=1
while i<=n:
bit[i]+=v
i+=i&(-i)
def modInverse(b,m):
g = math.gcd(b, m)
if (g != 1):
return -1
else:
return pow(b, m - 2, m)
# print(lo,ha)
n = int(input())
l = list(map(int,input().split()))
s = 10**6
ans = set()
l = set(l)
w = 0
for i in range(1,s+1):
opp = s+1-i
if i in l and opp not in l:
ans.add(opp)
elif i in l and opp in l:
w+=1
w//=2
for i in range(1,s+1):
opp = s+1-i
if w == 0:
break
if opp not in ans and i not in ans and i not in l and opp not in l:
ans.add(opp)
ans.add(i)
w-=1
print(len(ans))
print(*ans)
``` |
432_E. Square Tiling | You have an n × m rectangle table, its cells are not initially painted. Your task is to paint all cells of the table. The resulting picture should be a tiling of the table with squares. More formally:
* each cell must be painted some color (the colors are marked by uppercase Latin letters);
* we will assume that two cells of the table are connected if they are of the same color and share a side; each connected region of the table must form a square.
Given n and m, find lexicographically minimum coloring of the table that meets the described properties.
Input
The first line contains two integers, n and m (1 ≤ n, m ≤ 100).
Output
Print lexicographically minimum coloring of the table that meets the described conditions.
One coloring (let's call it X) is considered lexicographically less than the other one (let's call it Y), if:
* consider all the table cells from left to right and from top to bottom (first, the first cell in the first row, then the second cell in the first row and so on);
* let's find in this order the first cell that has distinct colors in two colorings;
* the letter that marks the color of the cell in X, goes alphabetically before the letter that marks the color of the cell in Y.
Examples
Input
1 3
Output
ABA
Input
2 2
Output
AA
AA
Input
3 4
Output
AAAB
AAAC
AAAB | ```python
import sys
input = sys.stdin.readline
n,m=map(int,input().split())
ANS=[[-1]*m for i in range(n)]
for i in range(n):
for j in range(m):
if ANS[i][j]==-1:
for koma in ["A","B","C","D","E","F"]:
for k,l in [(i-1,j),(i,j-1),(i+1,j),(i,j+1)]:
if 0<=k<n and 0<=l<m and ANS[k][l]==koma:
break
else:
nkoma=koma
break
MAXlength=1
if nkoma=="A":
for length in range(1,101):
if i+length>=n or j+length>=m:
break
for k,l in [(i-1,j+length),(i+length,j-1)]:
if 0<=k<n and 0<=l<m and ANS[k][l]==nkoma:
break
if 0<=i<n and ANS[i][j+length]!=-1:
break
else:
MAXlength=length+1
elif nkoma=="B":
for length in range(1,101):
if i+length>=n or j+length>=m:
break
flag=0
if 0<=i-1<n and ANS[i-1][j+length]=="A":
flag=1
if 0<=j-1<m and ANS[i+length][j-1]==nkoma:
break
if 0<=i<n and ANS[i][j+length]!=-1:
break
if flag==1:
MAXlength=length+1
else:
break
for k in range(i,i+MAXlength):
for l in range(j,j+MAXlength):
ANS[k][l]=nkoma
for a in ANS:
print("".join(a))
``` |
455_B. A Lot of Games | Andrew, Fedor and Alex are inventive guys. Now they invent the game with strings for two players.
Given a group of n non-empty strings. During the game two players build the word together, initially the word is empty. The players move in turns. On his step player must add a single letter in the end of the word, the resulting word must be prefix of at least one string from the group. A player loses if he cannot move.
Andrew and Alex decided to play this game k times. The player who is the loser of the i-th game makes the first move in the (i + 1)-th game. Guys decided that the winner of all games is the player who wins the last (k-th) game. Andrew and Alex already started the game. Fedor wants to know who wins the game if both players will play optimally. Help him.
Input
The first line contains two integers, n and k (1 ≤ n ≤ 105; 1 ≤ k ≤ 109).
Each of the next n lines contains a single non-empty string from the given group. The total length of all strings from the group doesn't exceed 105. Each string of the group consists only of lowercase English letters.
Output
If the player who moves first wins, print "First", otherwise print "Second" (without the quotes).
Examples
Input
2 3
a
b
Output
First
Input
3 1
a
b
c
Output
First
Input
1 2
ab
Output
Second | ```python
"""
Codeforces Contest 260 Div 1 Problem B
Author : chaotic_iak
Language: Python 3.3.4
"""
def main():
n,k = read()
s = set()
for i in range(n): s.add(read(0))
s = list(s)
s.sort()
s = treeify(s)
res = solve(s)
if res == 0: # neither: second player win
print("Second")
if res == 1: # odd: first player win if k is odd
print("First" if k % 2 else "Second")
if res == 2: # even: second player win
print("Second")
if res == 3: # both: first player win
print("First")
def treeify(s):
res = [[] for _ in range(26)]
for i in s:
if i: res[ord(i[0]) - 97].append(i[1:])
fin = []
for i in range(26):
if res[i]: fin.append(treeify(res[i]))
return fin
def solve(s, parity=2):
for i in range(len(s)):
if isinstance(s[i], list): s[i] = solve(s[i], 3-parity)
if not s: return parity # no possible move: current parity
if 0 in s: return 3 # any neither: both
if 1 in s and 2 in s: return 3 # any odd and any even: both
if 1 in s: return 1 # any odd: odd
if 2 in s: return 2 # any even: even
return 0 # all both: neither
################################### NON-SOLUTION STUFF BELOW
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return map(int, inputs.split())
def write(s="\n"):
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
main()
``` |
500_B. New Year Permutation | User ainta has a permutation p1, p2, ..., pn. As the New Year is coming, he wants to make his permutation as pretty as possible.
Permutation a1, a2, ..., an is prettier than permutation b1, b2, ..., bn, if and only if there exists an integer k (1 ≤ k ≤ n) where a1 = b1, a2 = b2, ..., ak - 1 = bk - 1 and ak < bk all holds.
As known, permutation p is so sensitive that it could be only modified by swapping two distinct elements. But swapping two elements is harder than you think. Given an n × n binary matrix A, user ainta can swap the values of pi and pj (1 ≤ i, j ≤ n, i ≠ j) if and only if Ai, j = 1.
Given the permutation p and the matrix A, user ainta wants to know the prettiest permutation that he can obtain.
Input
The first line contains an integer n (1 ≤ n ≤ 300) — the size of the permutation p.
The second line contains n space-separated integers p1, p2, ..., pn — the permutation p that user ainta has. Each integer between 1 and n occurs exactly once in the given permutation.
Next n lines describe the matrix A. The i-th line contains n characters '0' or '1' and describes the i-th row of A. The j-th character of the i-th line Ai, j is the element on the intersection of the i-th row and the j-th column of A. It is guaranteed that, for all integers i, j where 1 ≤ i < j ≤ n, Ai, j = Aj, i holds. Also, for all integers i where 1 ≤ i ≤ n, Ai, i = 0 holds.
Output
In the first and only line, print n space-separated integers, describing the prettiest permutation that can be obtained.
Examples
Input
7
5 2 4 3 6 7 1
0001001
0000000
0000010
1000001
0000000
0010000
1001000
Output
1 2 4 3 6 7 5
Input
5
4 2 1 5 3
00100
00011
10010
01101
01010
Output
1 2 3 4 5
Note
In the first sample, the swap needed to obtain the prettiest permutation is: (p1, p7).
In the second sample, the swaps needed to obtain the prettiest permutation is (p1, p3), (p4, p5), (p3, p4).
<image>
A permutation p is a sequence of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. The i-th element of the permutation p is denoted as pi. The size of the permutation p is denoted as n. | ```python
import sys
n=int(input())
a=list(map(lambda x:int(x),sys.stdin.readline().split()))
matrix=[]
for _ in range(n):
row=input()
row=list(row)
row=list(map(lambda x:int(x),row))
matrix.append(row)
class DisjSet:
def __init__(self, n):
# Constructor to create and
# initialize sets of n items
self.rank = [1] * n
self.parent = [i for i in range(n)]
self.extra = []
# Finds set of given item x
def find(self, x):
# Finds the representative of the set
# that x is an element of
if (self.parent[x] != x):
# if x is not the parent of itself
# Then x is not the representative of
# its set,
self.parent[x] = self.find(self.parent[x])
# so we recursively call Find on its parent
# and move i's node directly under the
# representative of this set
return self.parent[x]
# Do union of two sets represented
# by x and y.
def Union(self, x, y):
# Find current sets of x and y
xset = self.find(x)
yset = self.find(y)
# If they are already in same set
if xset == yset:
self.extra.append((x, y))
return
# Put smaller ranked item under
# bigger ranked item if ranks are
# different
if self.rank[xset] < self.rank[yset]:
self.parent[xset] = yset
elif self.rank[xset] > self.rank[yset]:
self.parent[yset] = xset
# If ranks are same, then move y under
# x (doesn't matter which one goes where)
# and increment rank of x's tree
else:
self.parent[yset] = xset
self.rank[xset] = self.rank[xset] + 1
obj=DisjSet(n)
for i in range(n):
for j in range(n):
if matrix[i][j]==1:
obj.Union(i,j)
hashmap={}
for i in range(n):
temp=obj.find(i)
if temp not in hashmap:
hashmap[temp]=[]
hashmap[temp].append(i)
final=[0 for _ in range(n)]
for k in hashmap:
temp=[a[i] for i in hashmap[k]]
temp.sort()
for i in range(0,len(temp)):
final[hashmap[k][i]]=temp[i]
print(*final)
``` |
525_E. Anya and Cubes | Anya loves to fold and stick. Today she decided to do just that.
Anya has n cubes lying in a line and numbered from 1 to n from left to right, with natural numbers written on them. She also has k stickers with exclamation marks. We know that the number of stickers does not exceed the number of cubes.
Anya can stick an exclamation mark on the cube and get the factorial of the number written on the cube. For example, if a cube reads 5, then after the sticking it reads 5!, which equals 120.
You need to help Anya count how many ways there are to choose some of the cubes and stick on some of the chosen cubes at most k exclamation marks so that the sum of the numbers written on the chosen cubes after the sticking becomes equal to S. Anya can stick at most one exclamation mark on each cube. Can you do it?
Two ways are considered the same if they have the same set of chosen cubes and the same set of cubes with exclamation marks.
Input
The first line of the input contains three space-separated integers n, k and S (1 ≤ n ≤ 25, 0 ≤ k ≤ n, 1 ≤ S ≤ 1016) — the number of cubes and the number of stickers that Anya has, and the sum that she needs to get.
The second line contains n positive integers ai (1 ≤ ai ≤ 109) — the numbers, written on the cubes. The cubes in the input are described in the order from left to right, starting from the first one.
Multiple cubes can contain the same numbers.
Output
Output the number of ways to choose some number of cubes and stick exclamation marks on some of them so that the sum of the numbers became equal to the given number S.
Examples
Input
2 2 30
4 3
Output
1
Input
2 2 7
4 3
Output
1
Input
3 1 1
1 1 1
Output
6
Note
In the first sample the only way is to choose both cubes and stick an exclamation mark on each of them.
In the second sample the only way is to choose both cubes but don't stick an exclamation mark on any of them.
In the third sample it is possible to choose any of the cubes in three ways, and also we may choose to stick or not to stick the exclamation mark on it. So, the total number of ways is six. | ```python
fact = [ 1 ]
for i in range( 1, 20, 1 ):
fact.append( fact[ i - 1 ] * i )
from collections import defaultdict
N, K, S = map( int, input().split() )
A = list( map( int, input().split() ) )
ldp = [ [ defaultdict( int ) for i in range( K + 1 ) ] for j in range( 2 ) ]
ldp[ 0 ][ 0 ][ 0 ] = 1
for i in range( N // 2 ):
for j in range( K + 1 ):
ldp[ ~ i & 1 ][ j ].clear()
for j in range( K + 1 ):
for key in ldp[ i & 1 ][ j ]:
ldp[ ~ i & 1 ][ j ][ key ] += ldp[ i & 1 ][ j ][ key ] # toranai
ldp[ ~ i & 1 ][ j ][ key + A[ i ] ] += ldp[ i & 1 ][ j ][ key ] # toru
if j + 1 <= K and A[ i ] <= 18:
ldp[ ~ i & 1 ][ j + 1 ][ key + fact[ A[ i ] ] ] += ldp[ i & 1 ][ j ][ key ] # kaijyou totte toru
rdp = [ [ defaultdict( int ) for i in range( K + 1 ) ] for j in range( 2 ) ]
rdp[ 0 ][ 0 ][ 0 ] = 1
for i in range( N - N // 2 ):
for j in range( K + 1 ):
rdp[ ~ i & 1 ][ j ].clear()
for j in range( K + 1 ):
for key in rdp[ i & 1 ][ j ]:
rdp[ ~ i & 1 ][ j ][ key ] += rdp[ i & 1 ][ j ][ key ]
rdp[ ~ i & 1 ][ j ][ key + A[ N // 2 + i ] ] += rdp[ i & 1 ][ j ][ key ]
if j + 1 <= K and A[ N // 2 + i ] <= 18:
rdp[ ~ i & 1 ][ j + 1 ][ key + fact[ A[ N // 2 + i ] ] ] += rdp[ i & 1 ][ j ][ key ]
ans = 0
for i in range( K + 1 ):
for key in ldp[ N // 2 & 1 ][ i ]:
for j in range( 0, K - i + 1, 1 ):
ans += ldp[ N // 2 & 1 ][ i ][ key ] * rdp[ N - N // 2 & 1 ][ j ][ S - key ]
print( ans )
``` |
551_A. GukiZ and Contest | Professor GukiZ likes programming contests. He especially likes to rate his students on the contests he prepares. Now, he has decided to prepare a new contest.
In total, n students will attend, and before the start, every one of them has some positive integer rating. Students are indexed from 1 to n. Let's denote the rating of i-th student as ai. After the contest ends, every student will end up with some positive integer position. GukiZ expects that his students will take places according to their ratings.
He thinks that each student will take place equal to <image>. In particular, if student A has rating strictly lower then student B, A will get the strictly better position than B, and if two students have equal ratings, they will share the same position.
GukiZ would like you to reconstruct the results by following his expectations. Help him and determine the position after the end of the contest for each of his students if everything goes as expected.
Input
The first line contains integer n (1 ≤ n ≤ 2000), number of GukiZ's students.
The second line contains n numbers a1, a2, ... an (1 ≤ ai ≤ 2000) where ai is the rating of i-th student (1 ≤ i ≤ n).
Output
In a single line, print the position after the end of the contest for each of n students in the same order as they appear in the input.
Examples
Input
3
1 3 3
Output
3 1 1
Input
1
1
Output
1
Input
5
3 5 3 4 5
Output
4 1 4 3 1
Note
In the first sample, students 2 and 3 are positioned first (there is no other student with higher rating), and student 1 is positioned third since there are two students with higher rating.
In the second sample, first student is the only one on the contest.
In the third sample, students 2 and 5 share the first position with highest rating, student 4 is next with third position, and students 1 and 3 are the last sharing fourth position. | ```python
n,x=int(input()),list(map(int, input().split(" ")))
tmp=sorted(x,reverse=True)
for i in x:
print(tmp.index(i)+1)
``` |
578_B. "Or" Game | You are given n numbers a1, a2, ..., an. You can perform at most k operations. For each operation you can multiply one of the numbers by x. We want to make <image> as large as possible, where <image> denotes the bitwise OR.
Find the maximum possible value of <image> after performing at most k operations optimally.
Input
The first line contains three integers n, k and x (1 ≤ n ≤ 200 000, 1 ≤ k ≤ 10, 2 ≤ x ≤ 8).
The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109).
Output
Output the maximum value of a bitwise OR of sequence elements after performing operations.
Examples
Input
3 1 2
1 1 1
Output
3
Input
4 2 3
1 2 4 8
Output
79
Note
For the first sample, any possible choice of doing one operation will result the same three numbers 1, 1, 2 so the result is <image>.
For the second sample if we multiply 8 by 3 two times we'll get 72. In this case the numbers will become 1, 2, 4, 72 so the OR value will be 79 and is the largest possible result. | ```python
def main():
n, k, x = map(int, input().split())
aa = list(map(int, input().split()))
x, lo, u = x ** k, [0] * n, 0
for i, a in enumerate(aa):
lo[i] = u
u |= a
hi, u = [], 0
for a in reversed(aa):
hi.append(u)
u |= a
hi.reverse()
for i, u, a, v in zip(range(n), lo, aa, hi):
aa[i] = a * x | u | v
print(max(aa))
if __name__ == '__main__':
main()
``` |
59_E. Shortest Path | In Ancient Berland there were n cities and m two-way roads of equal length. The cities are numbered with integers from 1 to n inclusively. According to an ancient superstition, if a traveller visits three cities ai, bi, ci in row, without visiting other cities between them, a great disaster awaits him. Overall there are k such city triplets. Each triplet is ordered, which means that, for example, you are allowed to visit the cities in the following order: ai, ci, bi. Vasya wants to get from the city 1 to the city n and not fulfil the superstition. Find out which minimal number of roads he should take. Also you are required to find one of his possible path routes.
Input
The first line contains three integers n, m, k (2 ≤ n ≤ 3000, 1 ≤ m ≤ 20000, 0 ≤ k ≤ 105) which are the number of cities, the number of roads and the number of the forbidden triplets correspondingly.
Then follow m lines each containing two integers xi, yi (1 ≤ xi, yi ≤ n) which are the road descriptions. The road is described by the numbers of the cities it joins. No road joins a city with itself, there cannot be more than one road between a pair of cities.
Then follow k lines each containing three integers ai, bi, ci (1 ≤ ai, bi, ci ≤ n) which are the forbidden triplets. Each ordered triplet is listed mo more than one time. All three cities in each triplet are distinct.
City n can be unreachable from city 1 by roads.
Output
If there are no path from 1 to n print -1. Otherwise on the first line print the number of roads d along the shortest path from the city 1 to the city n. On the second line print d + 1 numbers — any of the possible shortest paths for Vasya. The path should start in the city 1 and end in the city n.
Examples
Input
4 4 1
1 2
2 3
3 4
1 3
1 4 3
Output
2
1 3 4
Input
3 1 0
1 2
Output
-1
Input
4 4 2
1 2
2 3
3 4
1 3
1 2 3
1 3 4
Output
4
1 3 2 3 4 | ```python
#https://codeforces.com/contest/59/problem/E
class Pathclass:
def __init__(self,node_number,nextnode):
self.number = node_number
self.next = nextnode
import collections
lis = input().split()
n,m,k = int(lis[0]),int(lis[1]),int(lis[2])
adjlis = [collections.deque([]) for i in range(n)]
for i in range(m):
lis = input().split()
x,y = int(lis[0])-1,int(lis[1])-1
adjlis[x].append(y)
adjlis[y].append(x)
triplet = [[] for i in range(n)]
for i in range(k):
lis = input().split()
a,b,c = int(lis[0])-1,int(lis[1])-1,int(lis[2])-1
triplet[a].append((b,c))
node_queue = collections.deque([])
path_queue = collections.deque([])
flag = False
pp = Pathclass(0,None)
while adjlis[0]:
i = adjlis[0].popleft()
if(i==n-1):
flag = True
node_queue.append(i)
path_queue.append(Pathclass(i,pp))
if(flag):
print(1)
print(1,n)
else:
finalpath = None
while node_queue and not flag:
node = node_queue.popleft()
path = path_queue.popleft()
lenn = len(adjlis[node])
for j in range(lenn):
i = adjlis[node].popleft()
if (not (node,i) in triplet[path.next.number]):
if(i==n-1):
flag = True
finalpath = Pathclass(i,path)
break
else:
path2 = Pathclass(i,path)
node_queue.append(i)
path_queue.append(path2)
else:
adjlis[node].append(i)
if not flag:
print(-1)
else:
pathlist = []
while finalpath:
pathlist.append(finalpath.number + 1)
finalpath = finalpath.next
pathlist.reverse()
print(len(pathlist)-1)
for i in pathlist:
print(i,end=" ")
print()
``` |
621_C. Wet Shark and Flowers | There are n sharks who grow flowers for Wet Shark. They are all sitting around the table, such that sharks i and i + 1 are neighbours for all i from 1 to n - 1. Sharks n and 1 are neighbours too.
Each shark will grow some number of flowers si. For i-th shark value si is random integer equiprobably chosen in range from li to ri. Wet Shark has it's favourite prime number p, and he really likes it! If for any pair of neighbouring sharks i and j the product si·sj is divisible by p, then Wet Shark becomes happy and gives 1000 dollars to each of these sharks.
At the end of the day sharks sum all the money Wet Shark granted to them. Find the expectation of this value.
Input
The first line of the input contains two space-separated integers n and p (3 ≤ n ≤ 100 000, 2 ≤ p ≤ 109) — the number of sharks and Wet Shark's favourite prime number. It is guaranteed that p is prime.
The i-th of the following n lines contains information about i-th shark — two space-separated integers li and ri (1 ≤ li ≤ ri ≤ 109), the range of flowers shark i can produce. Remember that si is chosen equiprobably among all integers from li to ri, inclusive.
Output
Print a single real number — the expected number of dollars that the sharks receive in total. You answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
3 2
1 2
420 421
420420 420421
Output
4500.0
Input
3 5
1 4
2 3
11 14
Output
0.0
Note
A prime number is a positive integer number that is divisible only by 1 and itself. 1 is not considered to be prime.
Consider the first sample. First shark grows some number of flowers from 1 to 2, second sharks grows from 420 to 421 flowers and third from 420420 to 420421. There are eight cases for the quantities of flowers (s0, s1, s2) each shark grows:
1. (1, 420, 420420): note that s0·s1 = 420, s1·s2 = 176576400, and s2·s0 = 420420. For each pair, 1000 dollars will be awarded to each shark. Therefore, each shark will be awarded 2000 dollars, for a total of 6000 dollars.
2. (1, 420, 420421): now, the product s2·s0 is not divisible by 2. Therefore, sharks s0 and s2 will receive 1000 dollars, while shark s1 will receive 2000. The total is 4000.
3. (1, 421, 420420): total is 4000
4. (1, 421, 420421): total is 0.
5. (2, 420, 420420): total is 6000.
6. (2, 420, 420421): total is 6000.
7. (2, 421, 420420): total is 6000.
8. (2, 421, 420421): total is 4000.
The expected value is <image>.
In the second sample, no combination of quantities will garner the sharks any money. | ```python
import math
def numberOfMultiples(n, z):
return n // z
if __name__ == "__main__":
n, p = map(int, input().split())
f = [0] * n
g = [0] * n
for i in range(n):
l, r = map(int, input().split())
#print((r - l + 1) - len([i for i in range(l, r + 1) if i % p == 0]))
f[i] = (r - l + 1) - (numberOfMultiples(r, p) - numberOfMultiples(l - 1, p))
g[i] = (r - l + 1)
def compute_frac_gain(index):
return 1 - ((f[index - 1] * f[index]) / (g[index - 1] * g[index]))
frac_gains = 0
for i in range(1, n):
frac_gain = compute_frac_gain(i)
frac_gains += frac_gain
frac_gain = 1 - ((f[-1] * f[0]) / (g[-1] * g[0]))
frac_gains += frac_gain
print(frac_gains * 2000)
``` |
643_A. Bear and Colors | Bear Limak has n colored balls, arranged in one long row. Balls are numbered 1 through n, from left to right. There are n possible colors, also numbered 1 through n. The i-th ball has color ti.
For a fixed interval (set of consecutive elements) of balls we can define a dominant color. It's a color occurring the biggest number of times in the interval. In case of a tie between some colors, the one with the smallest number (index) is chosen as dominant.
There are <image> non-empty intervals in total. For each color, your task is to count the number of intervals in which this color is dominant.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 5000) — the number of balls.
The second line contains n integers t1, t2, ..., tn (1 ≤ ti ≤ n) where ti is the color of the i-th ball.
Output
Print n integers. The i-th of them should be equal to the number of intervals where i is a dominant color.
Examples
Input
4
1 2 1 2
Output
7 3 0 0
Input
3
1 1 1
Output
6 0 0
Note
In the first sample, color 2 is dominant in three intervals:
* An interval [2, 2] contains one ball. This ball's color is 2 so it's clearly a dominant color.
* An interval [4, 4] contains one ball, with color 2 again.
* An interval [2, 4] contains two balls of color 2 and one ball of color 1.
There are 7 more intervals and color 1 is dominant in all of them. | ```python
# n=int(input())
# n,k=map(int,input().split())
'''l=0
r=10**13
while l+1<r:
mid=(l+r)//2
val=(max(0,b_b*mid-b)*rb+max(0,b_s*mid-s)*rs+max(0,b_c*mid-b)*rc)
if val>money:
r=mid
if val<=money:
l=mid'''
# arr=list(map(int,input().split()))
# n=int(input())
#if all([size%ele==0 for ele,size in s.items()]):
# n,k=map(int,input().split())
# arr=list(map(int,input().split()))
#from collections import Counter
#arr=sorted([(n-int(x),i) for i,x in enumerate(input().split())])
n=int(input())
arr=[int(q)-1 for q in input().split()]
ans=[0]*n
for i in range(n):
cnt = [0] * n
best=0
for j in arr[i:]:
cnt[j]+=1
if cnt[j]>cnt[best] or j<best and cnt[j]==cnt[best] :
best = j
ans[best]+=1
print(*ans)
``` |
670_A. Holidays | On the planet Mars a year lasts exactly n days (there are no leap years on Mars). But Martians have the same weeks as earthlings — 5 work days and then 2 days off. Your task is to determine the minimum possible and the maximum possible number of days off per year on Mars.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 1 000 000) — the number of days in a year on Mars.
Output
Print two integers — the minimum possible and the maximum possible number of days off per year on Mars.
Examples
Input
14
Output
4 4
Input
2
Output
0 2
Note
In the first sample there are 14 days in a year on Mars, and therefore independently of the day a year starts with there will be exactly 4 days off .
In the second sample there are only 2 days in a year on Mars, and they can both be either work days or days off. | ```python
n = int(input())
if n % 7 == 0:
print(n // 7 * 2, n // 7 * 2)
else:
x = (n // 7 + 1) * 7
if x - n == 6:
print((n // 7) * 2, (n // 7) * 2 + 1)
else:
if x - n == 1:
print((n // 7) * 2 + 1, (n // 7) * 2 + 2)
else:
print((n // 7) * 2, (n // 7) * 2 + 2)
``` |
691_C. Exponential notation | You are given a positive decimal number x.
Your task is to convert it to the "simple exponential notation".
Let x = a·10b, where 1 ≤ a < 10, then in general case the "simple exponential notation" looks like "aEb". If b equals to zero, the part "Eb" should be skipped. If a is an integer, it should be written without decimal point. Also there should not be extra zeroes in a and b.
Input
The only line contains the positive decimal number x. The length of the line will not exceed 106. Note that you are given too large number, so you can't use standard built-in data types "float", "double" and other.
Output
Print the only line — the "simple exponential notation" of the given number x.
Examples
Input
16
Output
1.6E1
Input
01.23400
Output
1.234
Input
.100
Output
1E-1
Input
100.
Output
1E2 | ```python
import sys
import bisect
from bisect import bisect_left as lb
input_=lambda: sys.stdin.readline().strip("\r\n")
from math import log
from math import gcd
from math import atan2,acos
from random import randint
sa=lambda :input_()
sb=lambda:int(input_())
sc=lambda:input_().split()
sd=lambda:list(map(int,input_().split()))
sflo=lambda:list(map(float,input_().split()))
se=lambda:float(input_())
sf=lambda:list(input_())
flsh=lambda: sys.stdout.flush()
#sys.setrecursionlimit(10**6)
mod=10**9+7
mod1=998244353
gp=[]
cost=[]
dp=[]
mx=[]
ans1=[]
ans2=[]
special=[]
specnode=[]
a=0
kthpar=[]
def dfs(root,par):
if par!=-1:
dp[root]=dp[par]+1
for i in range(1,20):
if kthpar[root][i-1]!=-1:
kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
for child in gp[root]:
if child==par:continue
kthpar[child][0]=root
dfs(child,root)
ans=0
def hnbhai(tc):
s=sa()+"."
a,b=s.split(".")[:2]
i=0
while(i<len(a) and a[i]=="0"):
i+=1
a=a[i:]
i=len(b)-1
while(i>=0 and b[i]=="0"):
i-=1
b=b[:i+1]
a1=len(a)-1
if len(b)==0:
i=len(a)-1
while(i>=0 and a[i]=="0"):
i-=1
a=a[:i+1]
if len(a)==0:
a1=len(b)+1
i=0
while(i<len(b) and b[i]=="0"):
i+=1
b=b[i:]
a1=len(b)-a1
ans=a+b
if len(ans)>1:
ans=ans[0]+"."+ans[1:]
if a1!=0 and ans:
print(ans+"E"+str(a1))
return
print(ans)
for _ in range(1):
hnbhai(_+1)
``` |
716_C. Plus and Square Root | ZS the Coder is playing a game. There is a number displayed on the screen and there are two buttons, ' + ' (plus) and '<image>' (square root). Initially, the number 2 is displayed on the screen. There are n + 1 levels in the game and ZS the Coder start at the level 1.
When ZS the Coder is at level k, he can :
1. Press the ' + ' button. This increases the number on the screen by exactly k. So, if the number on the screen was x, it becomes x + k.
2. Press the '<image>' button. Let the number on the screen be x. After pressing this button, the number becomes <image>. After that, ZS the Coder levels up, so his current level becomes k + 1. This button can only be pressed when x is a perfect square, i.e. x = m2 for some positive integer m.
Additionally, after each move, if ZS the Coder is at level k, and the number on the screen is m, then m must be a multiple of k. Note that this condition is only checked after performing the press. For example, if ZS the Coder is at level 4 and current number is 100, he presses the '<image>' button and the number turns into 10. Note that at this moment, 10 is not divisible by 4, but this press is still valid, because after it, ZS the Coder is at level 5, and 10 is divisible by 5.
ZS the Coder needs your help in beating the game — he wants to reach level n + 1. In other words, he needs to press the '<image>' button n times. Help him determine the number of times he should press the ' + ' button before pressing the '<image>' button at each level.
Please note that ZS the Coder wants to find just any sequence of presses allowing him to reach level n + 1, but not necessarily a sequence minimizing the number of presses.
Input
The first and only line of the input contains a single integer n (1 ≤ n ≤ 100 000), denoting that ZS the Coder wants to reach level n + 1.
Output
Print n non-negative integers, one per line. i-th of them should be equal to the number of times that ZS the Coder needs to press the ' + ' button before pressing the '<image>' button at level i.
Each number in the output should not exceed 1018. However, the number on the screen can be greater than 1018.
It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.
Examples
Input
3
Output
14
16
46
Input
2
Output
999999999999999998
44500000000
Input
4
Output
2
17
46
97
Note
In the first sample case:
On the first level, ZS the Coder pressed the ' + ' button 14 times (and the number on screen is initially 2), so the number became 2 + 14·1 = 16. Then, ZS the Coder pressed the '<image>' button, and the number became <image>.
After that, on the second level, ZS pressed the ' + ' button 16 times, so the number becomes 4 + 16·2 = 36. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
After that, on the third level, ZS pressed the ' + ' button 46 times, so the number becomes 6 + 46·3 = 144. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
Note that 12 is indeed divisible by 4, so ZS the Coder can reach level 4.
Also, note that pressing the ' + ' button 10 times on the third level before levelling up does not work, because the number becomes 6 + 10·3 = 36, and when the '<image>' button is pressed, the number becomes <image> and ZS the Coder is at Level 4. However, 6 is not divisible by 4 now, so this is not a valid solution.
In the second sample case:
On the first level, ZS the Coder pressed the ' + ' button 999999999999999998 times (and the number on screen is initially 2), so the number became 2 + 999999999999999998·1 = 1018. Then, ZS the Coder pressed the '<image>' button, and the number became <image>.
After that, on the second level, ZS pressed the ' + ' button 44500000000 times, so the number becomes 109 + 44500000000·2 = 9·1010. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.
Note that 300000 is a multiple of 3, so ZS the Coder can reach level 3. | ```python
n=int(input())
print(2)
for lvl in range(2,n+1):
print(lvl*(lvl+1)*(lvl+1)-(lvl-1))
``` |
784_A. Numbers Joke |
Input
The input contains a single integer a (1 ≤ a ≤ 30).
Output
Output a single integer.
Example
Input
3
Output
27 | ```python
ls = [0, 4, 22, 27, 58, 85, 94, 121, 166, 202, 265, 274, 319, 346, 355, 378, 382, 391, 438, 454, 483, 517, 526, 535, 562, 576, 588, 627, 634, 636, 645, 648, 654, 663, 666, 690, 706, 728, 729, 762, 778, 825, ]
print(ls[int(input())])
``` |
851_A. Arpa and a research in Mexican wave | Arpa is researching the Mexican wave.
There are n spectators in the stadium, labeled from 1 to n. They start the Mexican wave at time 0.
* At time 1, the first spectator stands.
* At time 2, the second spectator stands.
* ...
* At time k, the k-th spectator stands.
* At time k + 1, the (k + 1)-th spectator stands and the first spectator sits.
* At time k + 2, the (k + 2)-th spectator stands and the second spectator sits.
* ...
* At time n, the n-th spectator stands and the (n - k)-th spectator sits.
* At time n + 1, the (n + 1 - k)-th spectator sits.
* ...
* At time n + k, the n-th spectator sits.
Arpa wants to know how many spectators are standing at time t.
Input
The first line contains three integers n, k, t (1 ≤ n ≤ 109, 1 ≤ k ≤ n, 1 ≤ t < n + k).
Output
Print single integer: how many spectators are standing at time t.
Examples
Input
10 5 3
Output
3
Input
10 5 7
Output
5
Input
10 5 12
Output
3
Note
In the following a sitting spectator is represented as -, a standing spectator is represented as ^.
* At t = 0 ---------- <image> number of standing spectators = 0.
* At t = 1 ^--------- <image> number of standing spectators = 1.
* At t = 2 ^^-------- <image> number of standing spectators = 2.
* At t = 3 ^^^------- <image> number of standing spectators = 3.
* At t = 4 ^^^^------ <image> number of standing spectators = 4.
* At t = 5 ^^^^^----- <image> number of standing spectators = 5.
* At t = 6 -^^^^^---- <image> number of standing spectators = 5.
* At t = 7 --^^^^^--- <image> number of standing spectators = 5.
* At t = 8 ---^^^^^-- <image> number of standing spectators = 5.
* At t = 9 ----^^^^^- <image> number of standing spectators = 5.
* At t = 10 -----^^^^^ <image> number of standing spectators = 5.
* At t = 11 ------^^^^ <image> number of standing spectators = 4.
* At t = 12 -------^^^ <image> number of standing spectators = 3.
* At t = 13 --------^^ <image> number of standing spectators = 2.
* At t = 14 ---------^ <image> number of standing spectators = 1.
* At t = 15 ---------- <image> number of standing spectators = 0. | ```python
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()
def main():
n,k,t=LI()
if t<=k:
return t
if n<t:
if n+k<t:
return 0
else:
return n+k-t
return k
# main()
print(main())
``` |
875_C. National Property | You all know that the Library of Bookland is the largest library in the world. There are dozens of thousands of books in the library.
Some long and uninteresting story was removed...
The alphabet of Bookland is so large that its letters are denoted by positive integers. Each letter can be small or large, the large version of a letter x is denoted by x'. BSCII encoding, which is used everywhere in Bookland, is made in that way so that large letters are presented in the order of the numbers they are denoted by, and small letters are presented in the order of the numbers they are denoted by, but all large letters are before all small letters. For example, the following conditions hold: 2 < 3, 2' < 3', 3' < 2.
A word x1, x2, ..., xa is not lexicographically greater than y1, y2, ..., yb if one of the two following conditions holds:
* a ≤ b and x1 = y1, ..., xa = ya, i.e. the first word is the prefix of the second word;
* there is a position 1 ≤ j ≤ min(a, b), such that x1 = y1, ..., xj - 1 = yj - 1 and xj < yj, i.e. at the first position where the words differ the first word has a smaller letter than the second word has.
For example, the word "3' 7 5" is before the word "2 4' 6" in lexicographical order. It is said that sequence of words is in lexicographical order if each word is not lexicographically greater than the next word in the sequence.
Denis has a sequence of words consisting of small letters only. He wants to change some letters to large (let's call this process a capitalization) in such a way that the sequence of words is in lexicographical order. However, he soon realized that for some reason he can't change a single letter in a single word. He only can choose a letter and change all of its occurrences in all words to large letters. He can perform this operation any number of times with arbitrary letters of Bookland's alphabet.
Help Denis to choose which letters he needs to capitalize (make large) in order to make the sequence of words lexicographically ordered, or determine that it is impossible.
Note that some words can be equal.
Input
The first line contains two integers n and m (2 ≤ n ≤ 100 000, 1 ≤ m ≤ 100 000) — the number of words and the number of letters in Bookland's alphabet, respectively. The letters of Bookland's alphabet are denoted by integers from 1 to m.
Each of the next n lines contains a description of one word in format li, si, 1, si, 2, ..., si, li (1 ≤ li ≤ 100 000, 1 ≤ si, j ≤ m), where li is the length of the word, and si, j is the sequence of letters in the word. The words are given in the order Denis has them in the sequence.
It is guaranteed that the total length of all words is not greater than 100 000.
Output
In the first line print "Yes" (without quotes), if it is possible to capitalize some set of letters in such a way that the sequence of words becomes lexicographically ordered. Otherwise, print "No" (without quotes).
If the required is possible, in the second line print k — the number of letters Denis has to capitalize (make large), and in the third line print k distinct integers — these letters. Note that you don't need to minimize the value k.
You can print the letters in any order. If there are multiple answers, print any of them.
Examples
Input
4 3
1 2
1 1
3 1 3 2
2 1 1
Output
Yes
2
2 3
Input
6 5
2 1 2
2 1 2
3 1 2 3
2 1 5
2 4 4
2 4 4
Output
Yes
0
Input
4 3
4 3 2 2 1
3 1 1 3
3 2 3 3
2 3 1
Output
No
Note
In the first example after Denis makes letters 2 and 3 large, the sequence looks like the following:
* 2'
* 1
* 1 3' 2'
* 1 1
The condition 2' < 1 holds, so the first word is not lexicographically larger than the second word. The second word is the prefix of the third word, so the are in lexicographical order. As the first letters of the third and the fourth words are the same, and 3' < 1, then the third word is not lexicographically larger than the fourth word.
In the second example the words are in lexicographical order from the beginning, so Denis can do nothing.
In the third example there is no set of letters such that if Denis capitalizes them, the sequence becomes lexicographically ordered. | ```python
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
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,m=map(int,input().split())
l=[]
for i in range(n):
l.append(list(map(int,input().split())))
c=[0]*(m+1)
ans=[]
f=0
graph=defaultdict(list)
for i in range(n-1):
for j in range(1,int(l[i][0])+1):
if j==int(l[i+1][0]) and int(l[i+1][0])<int(l[i][0]):
if c[l[i+1][j]]>c[l[i][j]]:
if c[l[i][j]] == 0:
c[l[i][j]] = 1
break
else:
f = 1
break
if l[i][j] >=l[i + 1][j] and c[l[i][j]] <= c[l[i + 1][j]]:
if c[l[i][j]] == 0:
c[l[i][j]] = 1
break
else:
f = 1
break
else:
graph[l[i + 1][j]].append(l[i][j])
break
elif c[l[i+1][j]]>c[l[i][j]]:
if c[l[i][j]] == 0:
c[l[i][j]] = 1
break
else:
f = 1
break
elif l[i][j]>l[i+1][j] and c[l[i][j]]<=c[l[i+1][j]]:
if c[l[i][j]]==0:
c[l[i][j]]=1
break
else:
f=1
break
elif l[i][j]<l[i+1][j] or c[l[i][j]]>c[l[i+1][j]]:
graph[l[i+1][j]].append(l[i][j])
break
if f==1:
break
if f==1:
print("No")
sys.exit(0)
f=0
visited=[False]*(m+1)
def dfs(v,t):
stack=[]
stack.append((v,t))
while(len(stack)>0):
v,t=stack.pop()
c[v] = max(t, c[v])
visited[v] = True
for i in graph[v]:
c[i]=max(c[i],c[v])
if visited[i]==False:
stack.append((i,c[v]))
for i in range(1,m+1):
if visited[i]==False and c[i]==1:
dfs(i,c[i])
for i in range(1,m+1):
if c[i]==1:
ans.append(i)
for i in range(n-1):
for j in range(1,int(l[i][0])+1):
if j == int(l[i + 1][0]) and int(l[i+1][0])<int(l[i][0]):
if c[l[i+1][j]]>c[l[i][j]]:
f=1
break
if l[i][j] >=l[i + 1][j] and c[l[i][j]] <= c[l[i + 1][j]]:
f=1
break
else:
break
if c[l[i + 1][j]] > c[l[i][j]]:
f = 1
break
elif l[i][j]>l[i+1][j] and c[l[i][j]]<=c[l[i+1][j]]:
f=1
break
elif l[i][j] < l[i + 1][j] or c[l[i][j]]>c[l[i+1][j]]:
break
if f==1:
print("No")
else:
print("Yes")
print(len(ans))
print(*ans)
``` |
89_B. Widget Library | Vasya writes his own library for building graphical user interface. Vasya called his creation VTK (VasyaToolKit). One of the interesting aspects of this library is that widgets are packed in each other.
A widget is some element of graphical interface. Each widget has width and height, and occupies some rectangle on the screen. Any widget in Vasya's library is of type Widget. For simplicity we will identify the widget and its type.
Types HBox and VBox are derivatives of type Widget, so they also are types Widget. Widgets HBox and VBox are special. They can store other widgets. Both those widgets can use the pack() method to pack directly in itself some other widget. Widgets of types HBox and VBox can store several other widgets, even several equal widgets — they will simply appear several times. As a result of using the method pack() only the link to the packed widget is saved, that is when the packed widget is changed, its image in the widget, into which it is packed, will also change.
We shall assume that the widget a is packed in the widget b if there exists a chain of widgets a = c1, c2, ..., ck = b, k ≥ 2, for which ci is packed directly to ci + 1 for any 1 ≤ i < k. In Vasya's library the situation when the widget a is packed in the widget a (that is, in itself) is not allowed. If you try to pack the widgets into each other in this manner immediately results in an error.
Also, the widgets HBox and VBox have parameters border and spacing, which are determined by the methods set_border() and set_spacing() respectively. By default both of these options equal 0.
<image>
The picture above shows how the widgets are packed into HBox and VBox. At that HBox and VBox automatically change their size depending on the size of packed widgets. As for HBox and VBox, they only differ in that in HBox the widgets are packed horizontally and in VBox — vertically. The parameter spacing sets the distance between adjacent widgets, and border — a frame around all packed widgets of the desired width. Packed widgets are placed exactly in the order in which the pack() method was called for them. If within HBox or VBox there are no packed widgets, their sizes are equal to 0 × 0, regardless of the options border and spacing.
The construction of all the widgets is performed using a scripting language VasyaScript. The description of the language can be found in the input data.
For the final verification of the code Vasya asks you to write a program that calculates the sizes of all the widgets on the source code in the language of VasyaScript.
Input
The first line contains an integer n — the number of instructions (1 ≤ n ≤ 100). Next n lines contain instructions in the language VasyaScript — one instruction per line. There is a list of possible instructions below.
* "Widget [name]([x],[y])" — create a new widget [name] of the type Widget possessing the width of [x] units and the height of [y] units.
* "HBox [name]" — create a new widget [name] of the type HBox.
* "VBox [name]" — create a new widget [name] of the type VBox.
* "[name1].pack([name2])" — pack the widget [name2] in the widget [name1]. At that, the widget [name1] must be of type HBox or VBox.
* "[name].set_border([x])" — set for a widget [name] the border parameter to [x] units. The widget [name] must be of type HBox or VBox.
* "[name].set_spacing([x])" — set for a widget [name] the spacing parameter to [x] units. The widget [name] must be of type HBox or VBox.
All instructions are written without spaces at the beginning and at the end of the string. The words inside the instruction are separated by exactly one space. There are no spaces directly before the numbers and directly after them.
The case matters, for example, "wiDget x" is not a correct instruction. The case of the letters is correct in the input data.
All names of the widgets consist of lowercase Latin letters and has the length from 1 to 10 characters inclusive. The names of all widgets are pairwise different. All numbers in the script are integers from 0 to 100 inclusive
It is guaranteed that the above-given script is correct, that is that all the operations with the widgets take place after the widgets are created and no widget is packed in itself. It is guaranteed that the script creates at least one widget.
Output
For each widget print on a single line its name, width and height, separated by spaces. The lines must be ordered lexicographically by a widget's name.
Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use cout stream (also you may use %I64d specificator)
Examples
Input
12
Widget me(50,40)
VBox grandpa
HBox father
grandpa.pack(father)
father.pack(me)
grandpa.set_border(10)
grandpa.set_spacing(20)
Widget brother(30,60)
father.pack(brother)
Widget friend(20,60)
Widget uncle(100,20)
grandpa.pack(uncle)
Output
brother 30 60
father 80 60
friend 20 60
grandpa 120 120
me 50 40
uncle 100 20
Input
15
Widget pack(10,10)
HBox dummy
HBox x
VBox y
y.pack(dummy)
y.set_border(5)
y.set_spacing(55)
dummy.set_border(10)
dummy.set_spacing(20)
x.set_border(10)
x.set_spacing(10)
x.pack(pack)
x.pack(dummy)
x.pack(pack)
x.set_border(0)
Output
dummy 0 0
pack 10 10
x 40 10
y 10 10
Note
In the first sample the widgets are arranged as follows:
<image> | ```python
n = int(input())
widgets = {}
class Widget:
def __init__(self, w, h):
self.w = w
self.h = h
def calc_size(self):
return (self.w, self.h)
class Box:
def __init__(self, direction):
self.dir = direction
self.packed = []
self.border = 0
self.spacing = 0
self.size = None
def calc_size(self):
if self.size is not None: return self.size
if not len(self.packed):
self.size = (0, 0)
return self.size
child_sizes = []
for kid in self.packed:
child_sizes.append(kid.calc_size())
s = 0
for kid in child_sizes: s += kid[self.dir=='V']
s += self.spacing*max(0, len(self.packed)-1)
mx = 0
for kid in child_sizes: mx = max(mx, kid[self.dir=='H'])
self.size = (mx + 2*self.border, s + 2*self.border)
if self.dir == 'H':
self.size = (self.size[1], self.size[0])
return self.size
for _ in range(n):
s = input().strip()
spacespl = s.split(' ')
if len(spacespl) > 1:
cmd, rest = spacespl
if cmd == 'Widget':
name, rest = rest.split('(')
w, h = map(int, rest[:-1].split(','))
widgets[name] = Widget(w, h)
elif cmd == 'HBox':
widgets[rest] = Box('H')
elif cmd == 'VBox':
widgets[rest] = Box('V')
else:
name1, rest = s.split('.')
method, args = rest[:-1].split('(')
if method == 'pack':
widgets[name1].packed.append(widgets[args])
elif method == 'set_border':
widgets[name1].border = int(args)
elif method == 'set_spacing':
widgets[name1].spacing = int(args)
for name, thing in sorted(widgets.items()):
print(name, *thing.calc_size())
``` |
920_D. Tanks | Petya sometimes has to water his field. To water the field, Petya needs a tank with exactly V ml of water.
Petya has got N tanks, i-th of them initially containing ai ml of water. The tanks are really large, any of them can contain any amount of water (no matter how large this amount is).
Also Petya has got a scoop that can contain up to K ml of water (initially the scoop is empty). This scoop can be used to get some water from some tank, and after that pour it all into some tank (it is impossible to get water from multiple tanks without pouring it, or leave some water in the scoop when pouring it). When Petya tries to get some water from a tank, he gets min(v, K) water, where v is the current volume of water in the tank.
Is it possible to obtain a tank with exactly V ml of water using these operations? If it is possible, print a sequence of operations that allows to do it. If there are multiple ways to obtain needed amount of water in some tank, print any of them.
Input
The first line contains 3 integers: N (2 ≤ N ≤ 5000), K (1 ≤ K ≤ 5000), and V (0 ≤ V ≤ 109) — the number of tanks, the maximum volume of water the scoop can contain, and the required amount of water in some tank, respectively.
The second line contains N integers ai (0 ≤ ai ≤ 105), where ai is initial volume of water in i-th tank.
Output
If it is impossible to obtain a tank with exactly V ml of water, print NO.
Otherwise print YES in the first line, and beginning from the second line, print the sequence of operations in the following format:
Each line has to contain 3 numbers denoting a compressed operation: "cnt x y" (1 ≤ cnt ≤ 109, 1 ≤ x, y ≤ N), where x is the index of the tank where we get water, y is the index of the tank where we pour water, and cnt is the number of times we transfer water from tank x to tank y.
The number of these lines must not exceed N + 5.
Examples
Input
2 3 5
2 3
Output
YES
1 2 1
Input
2 3 4
2 3
Output
NO
Input
5 2 0
1 3 5 7 9
Output
YES
2 2 1
3 3 1
4 4 1
5 5 1 | ```python
import sys
n, k, v = map(int, input().split())
a = list(map(int, input().split()))
total = sum(a)
if total < v:
print('NO')
exit()
dp = [[0]*k for _ in range(n+1)]
prev = [[-1]*(k+1) for _ in range(n+1)]
dp[0][0] = 1
for i in range(n):
for j in range(k):
if not dp[i][j]:
continue
dp[i+1][j] = 1
prev[i+1][j] = j
dp[i+1][(j+a[i]) % k] = 1
prev[i+1][(j+a[i]) % k] = j
if not dp[n][v % k]:
print('NO')
exit()
group_a, group_b = [], []
j = v % k
for i in range(n, 0, -1):
if prev[i][j] == j:
group_b.append(i-1)
else:
group_a.append(i-1)
j = prev[i][j]
ans = []
water_a, water_b = 0, 0
if not group_b:
water_a = total
for i in range(2, n+1):
ans.append(f'5000 {i} 1')
rem = (total - v) // k
if rem > 0:
ans.append(f'{rem} 1 2')
water_a -= rem * k
water_b += rem * k
elif not group_a:
water_b = total
for i in range(2, n+1):
ans.append(f'5000 {i} 1')
req = v // k
water_a += req * k
water_b -= req * k
if req > 0:
ans.append(f'{req} 1 2')
else:
water_a, water_b = sum(a[i] for i in group_a), sum(a[i] for i in group_b)
for i in range(1, len(group_a)):
ans.append(f'5000 {group_a[i]+1} {group_a[0]+1}')
for i in range(1, len(group_b)):
ans.append(f'5000 {group_b[i]+1} {group_b[0]+1}')
if water_a > v:
rem = (water_a - v) // k
ans.append(f'{rem} {group_a[0]+1} {group_b[0]+1}')
water_a -= rem * k
water_b += rem * k
elif water_a < v:
req = (v - water_a) // k
ans.append(f'{req} {group_b[0]+1} {group_a[0]+1}')
water_a += req * k
water_b -= req * k
if not (water_a == v and min(water_a, water_b) >= 0):
print('NO')
else:
sys.stdout.buffer.write(('YES\n'+'\n'.join(ans)).encode('utf-8'))
``` |
949_B. A Leapfrog in the Array | Dima is a beginner programmer. During his working process, he regularly has to repeat the following operation again and again: to remove every second element from the array. One day he has been bored with easy solutions of this problem, and he has come up with the following extravagant algorithm.
Let's consider that initially array contains n numbers from 1 to n and the number i is located in the cell with the index 2i - 1 (Indices are numbered starting from one) and other cells of the array are empty. Each step Dima selects a non-empty array cell with the maximum index and moves the number written in it to the nearest empty cell to the left of the selected one. The process continues until all n numbers will appear in the first n cells of the array. For example if n = 4, the array is changing as follows:
<image>
You have to write a program that allows you to determine what number will be in the cell with index x (1 ≤ x ≤ n) after Dima's algorithm finishes.
Input
The first line contains two integers n and q (1 ≤ n ≤ 1018, 1 ≤ q ≤ 200 000), the number of elements in the array and the number of queries for which it is needed to find the answer.
Next q lines contain integers xi (1 ≤ xi ≤ n), the indices of cells for which it is necessary to output their content after Dima's algorithm finishes.
Output
For each of q queries output one integer number, the value that will appear in the corresponding array cell after Dima's algorithm finishes.
Examples
Input
4 3
2
3
4
Output
3
2
4
Input
13 4
10
5
4
8
Output
13
3
8
9
Note
The first example is shown in the picture.
In the second example the final array is [1, 12, 2, 8, 3, 11, 4, 9, 5, 13, 6, 10, 7]. | ```python
import sys
input=sys.stdin.readline
n,q=list(map(int,input().split()))
for i in range(q):
a=int(input())
if a%2!=0:
print((a+1)//2)
else:
b=a//2
while 1>0:
a=a+(n-b)
b=a//2
if a%2!=0:
print((a+1)//2)
break
``` |
977_A. Wrong Subtraction | Little girl Tanya is learning how to decrease a number by one, but she does it wrong with a number consisting of two or more digits. Tanya subtracts one from a number by the following algorithm:
* if the last digit of the number is non-zero, she decreases the number by one;
* if the last digit of the number is zero, she divides the number by 10 (i.e. removes the last digit).
You are given an integer number n. Tanya will subtract one from it k times. Your task is to print the result after all k subtractions.
It is guaranteed that the result will be positive integer number.
Input
The first line of the input contains two integer numbers n and k (2 ≤ n ≤ 10^9, 1 ≤ k ≤ 50) — the number from which Tanya will subtract and the number of subtractions correspondingly.
Output
Print one integer number — the result of the decreasing n by one k times.
It is guaranteed that the result will be positive integer number.
Examples
Input
512 4
Output
50
Input
1000000000 9
Output
1
Note
The first example corresponds to the following sequence: 512 → 511 → 510 → 51 → 50. | ```python
a, b = input().split(' ')
a=int(a)
for i in range(int(b)):
if (a%10 != 0):
a -= 1
else:
a /= 10
print(int(a))
``` |
996_E. Leaving the Bar | For a vector \vec{v} = (x, y), define |v| = √{x^2 + y^2}.
Allen had a bit too much to drink at the bar, which is at the origin. There are n vectors \vec{v_1}, \vec{v_2}, ⋅⋅⋅, \vec{v_n}. Allen will make n moves. As Allen's sense of direction is impaired, during the i-th move he will either move in the direction \vec{v_i} or -\vec{v_i}. In other words, if his position is currently p = (x, y), he will either move to p + \vec{v_i} or p - \vec{v_i}.
Allen doesn't want to wander too far from home (which happens to also be the bar). You need to help him figure out a sequence of moves (a sequence of signs for the vectors) such that his final position p satisfies |p| ≤ 1.5 ⋅ 10^6 so that he can stay safe.
Input
The first line contains a single integer n (1 ≤ n ≤ 10^5) — the number of moves.
Each of the following lines contains two space-separated integers x_i and y_i, meaning that \vec{v_i} = (x_i, y_i). We have that |v_i| ≤ 10^6 for all i.
Output
Output a single line containing n integers c_1, c_2, ⋅⋅⋅, c_n, each of which is either 1 or -1. Your solution is correct if the value of p = ∑_{i = 1}^n c_i \vec{v_i}, satisfies |p| ≤ 1.5 ⋅ 10^6.
It can be shown that a solution always exists under the given constraints.
Examples
Input
3
999999 0
0 999999
999999 0
Output
1 1 -1
Input
1
-824590 246031
Output
1
Input
8
-67761 603277
640586 -396671
46147 -122580
569609 -2112
400 914208
131792 309779
-850150 -486293
5272 721899
Output
1 1 1 1 1 1 1 -1 | ```python
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
def D(V, S):
x = 0
y = 0
for s, v in zip(S, V):
x += s*v[0]
y += s*v[1]
# error_print(math.sqrt(x**2+y**2))
return math.sqrt(x**2+y**2)
def XY(V, S):
x = 0
y = 0
for s, v in zip(S, V):
x += s*v[0]
y += s*v[1]
return x, y
@mt
def slv(N, V):
V1 = [[*v, i, 1] for i, v in enumerate(V) if v[0] * v[1] > 0]
V2 = [[*v, i, 1] for i, v in enumerate(V) if v[0] * v[1] < 0]
V3 = [[*v, i, 1] for i, v in enumerate(V) if v[0] == 0]
V4 = [[*v, i, 1] for i, v in enumerate(V) if v[0] != 0 and v[1] == 0]
V1.sort(reverse=True, key=lambda x: abs(x[0]) + abs(x[1]))
V2.sort(reverse=True, key=lambda x: abs(x[0]) + abs(x[1]))
V3.sort(reverse=True, key=lambda x: abs(x[0]) + abs(x[1]))
V4.sort(reverse=True, key=lambda x: abs(x[0]) + abs(x[1]))
def f(V):
sx, sy = 0, 0
for i, v in enumerate(V):
if abs(sx + v[0]) + abs(sy + v[1]) < abs(sx - v[0]) + abs(sy - v[1]):
v[3] = 1
else:
v[3] = -1
sx += v[3]*v[0]
sy += v[3]*v[1]
return sx, sy
SV = [f(V_) for V_ in [V1, V2, V3, V4]]
S = min([(D(SV, s), s) for s in product([-1, 1], repeat=4)])
for s, V_ in zip(S[1], [V1, V2, V3, V4]):
for v in V_:
v[3] *= s
V1.extend(V2)
V1.extend(V3)
V1.extend(V4)
V1.sort(key=lambda x: x[2])
ans = [v[3] for v in V1]
error_print(D(V, ans) < 1.5e+6)
return ' '.join(map(str, ans))
def main():
N = read_int()
V = [read_int_n() for _ in range(N)]
print(slv(N, V))
if __name__ == '__main__':
main()
``` |
p02651 AtCoder Grand Contest 045 - Xor Battle | There are two persons, numbered 0 and 1, and a variable x whose initial value is 0. The two persons now play a game. The game is played in N rounds. The following should be done in the i-th round (1 \leq i \leq N):
* Person S_i does one of the following:
* Replace x with x \oplus A_i, where \oplus represents bitwise XOR.
* Do nothing.
Person 0 aims to have x=0 at the end of the game, while Person 1 aims to have x \neq 0 at the end of the game.
Determine whether x becomes 0 at the end of the game when the two persons play optimally.
Solve T test cases for each input file.
Constraints
* 1 \leq T \leq 100
* 1 \leq N \leq 200
* 1 \leq A_i \leq 10^{18}
* S is a string of length N consisting of `0` and `1`.
* All numbers in input are integers.
Input
Input is given from Standard Input in the following format. The first line is as follows:
T
Then, T test cases follow. Each test case is given in the following format:
N
A_1 A_2 \cdots A_N
S
Output
For each test case, print a line containing `0` if x becomes 0 at the end of the game, and `1` otherwise.
Example
Input
3
2
1 2
10
2
1 1
10
6
2 3 4 5 6 7
111000
Output
1
0
0 | ```python
def slv(n,a,s):
base=[0]
for i in range(n-1,-1,-1):
v=a[i]
for j in sorted(base,reverse=True):
v=min(v,j^v)
if v==0:
pass
else:
if s[i]=='0':base.append(v)
if s[i]=='1':return 1
if base:return 0
return 1
t=int(input())
n=[]
a=[]
s=[]
for _ in range(t):
n.append(int(input()))
a.append(list(map(int,input().split())))
s.append(input())
for i in range(t):
print(slv(n[i],a[i],s[i]))
``` |
p02780 AtCoder Beginner Contest 154 - Dice in Line | We have N dice arranged in a line from left to right. The i-th die from the left shows p_i numbers from 1 to p_i with equal probability when thrown.
We will choose K adjacent dice, throw each of them independently, and compute the sum of the numbers shown. Find the maximum possible value of the expected value of this sum.
Constraints
* 1 ≤ K ≤ N ≤ 200000
* 1 ≤ p_i ≤ 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
p_1 ... p_N
Output
Print the maximum possible value of the expected value of the sum of the numbers shown.
Your output will be considered correct when its absolute or relative error from our answer is at most 10^{-6}.
Examples
Input
5 3
1 2 2 4 5
Output
7.000000000000
Input
4 1
6 6 6 6
Output
3.500000000000
Input
10 4
17 13 13 12 15 20 10 13 17 11
Output
32.000000000000 | ```python
n, k = map(int, input().split())
p = list(map(int, input().split()))
s = sum(p[:k])
m = s
for i in range(1, n-k+1):
s = s-p[i-1]+p[i+k-1]
if s > m:
m = s
print((m+k)/2)
``` |
p02915 AtCoder Beginner Contest 140 - Password | Takahashi is going to set a 3-character password.
How many possible passwords are there if each of its characters must be a digit between 1 and N (inclusive)?
Constraints
* 1 \leq N \leq 9
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of possible passwords.
Examples
Input
2
Output
8
Input
1
Output
1 | ```python
x=int(input())
print(pow(x,3))
``` |
p03051 diverta 2019 Programming Contest - XOR Partitioning | The beauty of a sequence a of length n is defined as a_1 \oplus \cdots \oplus a_n, where \oplus denotes the bitwise exclusive or (XOR).
You are given a sequence A of length N. Snuke will insert zero or more partitions in A to divide it into some number of non-empty contiguous subsequences.
There are 2^{N-1} possible ways to insert partitions. How many of them divide A into sequences whose beauties are all equal? Find this count modulo 10^{9}+7.
Constraints
* All values in input are integers.
* 1 \leq N \leq 5 \times 10^5
* 0 \leq A_i < 2^{20}
Input
Input is given from Standard Input in the following format:
N
A_1 A_2 \ldots A_{N}
Output
Print the answer.
Examples
Input
3
1 2 3
Output
3
Input
3
1 2 2
Output
1
Input
32
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Output
147483634
Input
24
1 2 5 3 3 6 1 1 8 8 0 3 3 4 6 6 4 0 7 2 5 4 6 2
Output
292 | ```python
N = int(input())
A = [int(i) for i in input().split()]
mod = 10**9 + 7
b = [0]*N
b[0] = A[0]
for n in range(1,N):
b[n] = A[n] ^ b[n-1]
#print('累積論理和',b)
m = max(b)
dp = [[0]*(m+1) for j in range(2)]
dp[0] = [1]*(m+1)
cnt = [0]*(m+1)
z = 0
for i in range(N):
if b[i] == 0:
z +=1
dp[0][b[i]] += dp[1][b[i]]*(z-cnt[b[i]])
dp[0][b[i]] %= mod
dp[1][b[i]] += dp[0][b[i]]
dp[1][b[i]] %= mod
cnt[b[i]] = z
if b[N-1]:
print(dp[0][b[N-1]])
else:
ans = pow(2, z-1, mod)
for i in range(1,m+1):
ans += dp[1][i]
ans %= mod
print(ans)
``` |
p03192 CADDi 2018 for Beginners - 12/22 | You are given an integer N that has exactly four digits in base ten. How many times does `2` occur in the base-ten representation of N?
Constraints
* 1000 \leq N \leq 9999
Input
Input is given from Standard Input in the following format:
N
Output
Print the answer.
Examples
Input
1222
Output
3
Input
3456
Output
0
Input
9592
Output
1 | ```python
a=str(input())
b=0
for i in range(4):
if(a[i]=="2"):
b+=1
print(b)
``` |
p03341 AtCoder Regular Contest 098 - Attention | There are N people standing in a row from west to east. Each person is facing east or west. The directions of the people is given as a string S of length N. The i-th person from the west is facing east if S_i = `E`, and west if S_i = `W`.
You will appoint one of the N people as the leader, then command the rest of them to face in the direction of the leader. Here, we do not care which direction the leader is facing.
The people in the row hate to change their directions, so you would like to select the leader so that the number of people who have to change their directions is minimized. Find the minimum number of people who have to change their directions.
Constraints
* 2 \leq N \leq 3 \times 10^5
* |S| = N
* S_i is `E` or `W`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the minimum number of people who have to change their directions.
Examples
Input
5
WEEWW
Output
1
Input
12
WEWEWEEEWWWE
Output
4
Input
8
WWWWWEEE
Output
3 | ```python
N = input()
s = input()
#累積和 前処理 Eの数を集計
count = s.count('E')
ans = count
#左端1番目からリーダーをずらしながらチェック。
for ch in s:
if ch == 'E':
count -= 1
ans = min(count,ans)
else:
count += 1
print(ans)
``` |
p03502 AtCoder Beginner Contest 080 - Harshad Number | An integer X is called a Harshad number if X is divisible by f(X), where f(X) is the sum of the digits in X when written in base 10.
Given an integer N, determine whether it is a Harshad number.
Constraints
* 1?N?10^8
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print `Yes` if N is a Harshad number; print `No` otherwise.
Examples
Input
12
Output
Yes
Input
57
Output
No
Input
148
Output
No | ```python
#2019/09/26
N = input()
print("Yes" if int(N) % sum(map(int, N)) == 0 else "No")
``` |
p03662 AtCoder Regular Contest 078 - Fennec VS. Snuke | Fennec and Snuke are playing a board game.
On the board, there are N cells numbered 1 through N, and N-1 roads, each connecting two cells. Cell a_i is adjacent to Cell b_i through the i-th road. Every cell can be reached from every other cell by repeatedly traveling to an adjacent cell. In terms of graph theory, the graph formed by the cells and the roads is a tree.
Initially, Cell 1 is painted black, and Cell N is painted white. The other cells are not yet colored. Fennec (who goes first) and Snuke (who goes second) alternately paint an uncolored cell. More specifically, each player performs the following action in her/his turn:
* Fennec: selects an uncolored cell that is adjacent to a black cell, and paints it black.
* Snuke: selects an uncolored cell that is adjacent to a white cell, and paints it white.
A player loses when she/he cannot paint a cell. Determine the winner of the game when Fennec and Snuke play optimally.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq a_i, b_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
If Fennec wins, print `Fennec`; if Snuke wins, print `Snuke`.
Examples
Input
7
3 6
1 2
3 1
7 4
5 7
1 4
Output
Fennec
Input
4
1 4
4 2
2 3
Output
Snuke | ```python
from collections import deque
def bfs(start):
queue = deque([start])
visited = []
while queue:
label = queue.pop()
#if label not in visited:
visited.append(label)
for v in d[label]:
if tekazu[v] == float("inf"):
tekazu[v] = tekazu[label] + 1
queue.appendleft(v)
return
n = int(input())
d = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = map(int, input().split())
d[a - 1].append(b - 1)
d[b - 1].append(a - 1)
tekazu = [float("inf") for _ in range(n)] # nは頂点数
tekazu[0] = 0
bfs(0)
tekazu_Fennec = tekazu
tekazu = [float("inf") for _ in range(n)] # nは頂点数
tekazu[-1] = 0
bfs(n - 1)
tekazu_Snuke = tekazu
Fennec = 0
Snuke = 0
for i in range(n):
if tekazu_Fennec[i] <= tekazu_Snuke[i]:
Fennec += 1
else:
Snuke += 1
#print(tekazu_Fennec, tekazu_Snuke)
if Fennec > Snuke:
print("Fennec")
else:
print("Snuke")
``` |
p03816 AtCoder Beginner Contest 053 - Card Eater | Snuke has decided to play a game using cards. He has a deck consisting of N cards. On the i-th card from the top, an integer A_i is written.
He will perform the operation described below zero or more times, so that the values written on the remaining cards will be pairwise distinct. Find the maximum possible number of remaining cards. Here, N is odd, which guarantees that at least one card can be kept.
Operation: Take out three arbitrary cards from the deck. Among those three cards, eat two: one with the largest value, and another with the smallest value. Then, return the remaining one card to the deck.
Constraints
* 3 ≦ N ≦ 10^{5}
* N is odd.
* 1 ≦ A_i ≦ 10^{5}
* A_i is an integer.
Input
The input is given from Standard Input in the following format:
N
A_1 A_2 A_3 ... A_{N}
Output
Print the answer.
Examples
Input
5
1 2 1 3 7
Output
3
Input
15
1 3 5 2 1 3 2 8 8 6 2 6 11 1 1
Output
7 | ```python
N = int(input())
A_arr = [int(x) for x in input().split()]
A_set = set(A_arr)
ans = len(A_set)
if ans%2 == 0:
ans -= 1
print(ans)
``` |
p03985 Kyoto University Programming Contest 2016 - Hundred Eyes Monster | Two circles A, B are given on a two-dimensional plane. The coordinate of the center and radius of circle A is (x_A, y_A) and r_A respectively. The coordinate of the center and radius of circle B is (x_B, y_B) and r_B respectively. These two circles have no intersection inside. Here, we consider a set of circles S that satisfies the following conditions.
* Each circle in S touches both A and B, and does not have common points with them inside the circle.
* Any two different circles in S have no common points inside them.
Write a program that finds the maximum number of elements in S.
Constraints
* 1 \leq T \leq 50000
* -10^5 \leq x_A \leq 10^5
* -10^5 \leq y_A \leq 10^5
* -10^5 \leq x_B \leq 10^5
* -10^5 \leq y_B \leq 10^5
* 1 \leq r_A \leq 10^5
* 1 \leq r_B \leq 10^5
* {r_A}^2 + {r_B}^2 < (x_A - x_B)^2 + (y_A - y_B)^2
* All values given as input are integers.
* It is guaranteed that, when the radiuses of A and B change by 0.0005, the answer does not change.
Input
The input consists of multiple test cases and is given from Standard Input in the following format:
T
testcase_1
:
testcase_T
Each test case is given with the following format.
x_A y_A r_A x_B y_B r_B
Output
The output consists of T lines. On line i (1 \leq i \leq T), putput the maximum number of elements in S in i-th test case.
Example
Input
4
0 -3 2 0 3 2
0 0 9 8 8 2
0 0 9 10 10 5
0 0 707 1000 1000 707
Output
3
10
21
180 | ```python
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
import math
# 反転で同心円に帰着する
T = int(input())
query = [[int(x) for x in input().split()] for _ in range(T)]
def solve_2_eq(a,b,c):
return (-b + (b*b-4*a*c)**.5) / (2*a)
def F(r,R,d):
# 複比
ratio = ((d+r+R)*(d-R-r)) / (4*r*R)
R = solve_2_eq(1,-2-4*ratio, 1)
# 内側の円が1, 外側の円が半径Rであるような同心円に帰着
r = (R-1)/2
theta = math.asin(r/(1+r))
return int(math.pi // theta)
answer = []
for data in query:
d = ((data[3]-data[0])**2 + (data[4]-data[1])**2) ** .5
answer.append(str(F(data[2],data[5],d)))
print('\n'.join(answer))
``` |
p00073 Surface Area of Quadrangular Pyramid | Create a program that outputs the surface area S of a square cone with a height of h, with a square with one side x as the base. However, assume that the line segment connecting the apex and the center of the base is orthogonal to the base. Also, x and h are positive integers less than or equal to 100.
Input
Given multiple datasets. Each dataset is given in the following format:
x
h
When both x and h are 0, it indicates the end of input.
Output
Output S (real number) on one line for each data set. The output may contain an error of 0.00001 or less.
Example
Input
6
4
7
9
0
0
Output
96.000000
184.192455 | ```python
from math import sqrt
while True:
x, h = int(input()), int(input())
if x==h==0: break
sh = sqrt((x/2)**2 + h**2)
print((x*x) + sum([sh*x*0.5 for _ in range(4)]))
``` |
p00205 Rock | I decided to play rock-paper-scissors with a group of five good friends. Rock-paper-scissors has three hands: goo, choki, and par. If the game between goo and choki is a match between goo and choki, goo is "winning" and choki is "losing". , Par and Goo have the rule that Par is "winning" and Goo is "losing". If everyone has the same hand, or if all of Goo, Choki, and Par come out, it will be "Aiko".
Create a program that inputs the hands of five rock-paper-scissors players and outputs the wins and losses of each person. Rock-paper-scissors hands are represented by the numbers 1 for goo, 2 for choki, and 3 for par. Win / loss is represented by a number of 1, "win" is 1, "los" is 2, and "Aiko" is 3, and they are output according to the input order.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
h1
h2
h3
h4
h5
The i-th line is given the i-th hand hi (1, 2 or 3).
The number of datasets does not exceed 200.
Output
Outputs the wins and losses of 5 players for each input dataset. Output the win / loss (1, 2 or 3) of the i-th person on the i-line.
Example
Input
1
2
3
2
1
1
2
2
2
1
0
Output
3
3
3
3
3
1
2
2
2
1 | ```python
d = {1:2, 2:3, 3:1}
while True:
h = int(input())
if h == 0:
break
h = [h] + [int(input()) for _ in range(4)]
if len(set(h)) == 3 or len(set(h)) == 1:
print(*[3]*5, sep='\n')
continue
for c in h:
print([2, 1][d[c] in h])
``` |
p00364 Bange Hills Tower | A project is underway to build a new viewing tower in Bange town called “Bange Hills Tower” whose selling point will be the gorgeous view of the entire main keep of Wakamatsu Castle from top to bottom. Therefore, the view line from the top of the tower must reach the bottom of the keep without being hindered by any of the buildings in the town.
<image>
Write a program to calculate the minimum tower height required to view the keep in its entirety based on the following information: the planned location of the tower and the heights and locations of existing buildings. Assume all the buildings, including the keep, are vertical lines without horizontal stretch. “view of the entire keep” means that the view line from the tower top can cover the keep from the bottom to the top without intersecting (contacts at the top are exempted) any of the other vertical lines (i.e., buildings).
Input
The input is given in the following format.
N t
x_1 h_1
x_2 h_2
:
x_N h_N
The first line provides the number of existing buildings N (1≤N≤1000) and the planned location of the tower t (2≤t≤105) in integers. Each of the subsequent N lines provides the information of the i-th building: location x_i (1 ≤ x_i < t) and height from the ground h_i (1 ≤ h_i ≤ 100). All position information is one-dimensional along the ground line whose origin coincides with the Keep location. No more than one building is located in the same location (i.e. if i ≠ j, then x_i ≠ x_j).
Output
Output the required height as a real number. No limits on the number of decimal places as long as the error does not exceed ± 10-3.
Example
Input
3 10
6 4
4 2
3 2
Output
6.666667 | ```python
n, t = map(int, input().split())
min_height = 0
for _ in range(n):
x, h = map(int, input().split())
min_height = max(min_height, h / x * t)
print(min_height)
``` |
p00719 Traveling by Stagecoach | Once upon a time, there was a traveler.
He plans to travel using stagecoaches (horse wagons). His starting point and destination are fixed, but he cannot determine his route. Your job in this problem is to write a program which determines the route for him.
There are several cities in the country, and a road network connecting them. If there is a road between two cities, one can travel by a stagecoach from one of them to the other. A coach ticket is needed for a coach ride. The number of horses is specified in each of the tickets. Of course, with more horses, the coach runs faster.
At the starting point, the traveler has a number of coach tickets. By considering these tickets and the information on the road network, you should find the best possible route that takes him to the destination in the shortest time. The usage of coach tickets should be taken into account.
The following conditions are assumed.
* A coach ride takes the traveler from one city to another directly connected by a road. In other words, on each arrival to a city, he must change the coach.
* Only one ticket can be used for a coach ride between two cities directly connected by a road.
* Each ticket can be used only once.
* The time needed for a coach ride is the distance between two cities divided by the number of horses.
* The time needed for the coach change should be ignored.
Input
The input consists of multiple datasets, each in the following format. The last dataset is followed by a line containing five zeros (separated by a space).
> n m p a b
> t1 t2 ... tn
> x1 y1 z1
> x2 y2 z2
> ...
> xp yp zp
>
Every input item in a dataset is a non-negative integer. If a line contains two or more input items, they are separated by a space.
n is the number of coach tickets. You can assume that the number of tickets is between 1 and 8. m is the number of cities in the network. You can assume that the number of cities is between 2 and 30. p is the number of roads between cities, which may be zero.
a is the city index of the starting city. b is the city index of the destination city. a is not equal to b. You can assume that all city indices in a dataset (including the above two) are between 1 and m.
The second line of a dataset gives the details of coach tickets. ti is the number of horses specified in the i-th coach ticket (1<=i<=n). You can assume that the number of horses is between 1 and 10.
The following p lines give the details of roads between cities. The i-th road connects two cities with city indices xi and yi, and has a distance zi (1<=i<=p). You can assume that the distance is between 1 and 100.
No two roads connect the same pair of cities. A road never connects a city with itself. Each road can be traveled in both directions.
Output
For each dataset in the input, one line should be output as specified below. An output line should not contain extra characters such as spaces.
If the traveler can reach the destination, the time needed for the best route (a route with the shortest time) should be printed. The answer should not have an error greater than 0.001. You may output any number of digits after the decimal point, provided that the above accuracy condition is satisfied.
If the traveler cannot reach the destination, the string "`Impossible`" should be printed. One cannot reach the destination either when there are no routes leading to the destination, or when the number of tickets is not sufficient. Note that the first letter of "`Impossible`" is in uppercase, while the other letters are in lowercase.
Example
Input
3 4 3 1 4
3 1 2
1 2 10
2 3 30
3 4 20
2 4 4 2 1
3 1
2 3 3
1 3 3
4 1 2
4 2 5
2 4 3 4 1
5 5
1 2 10
2 3 10
3 4 10
1 2 0 1 2
1
8 5 10 1 5
2 7 1 8 4 5 6 3
1 2 5
2 3 4
3 4 7
4 5 3
1 3 25
2 4 23
3 5 22
1 4 45
2 5 51
1 5 99
0 0 0 0 0
Output
30.000
3.667
Impossible
Impossible
2.856 | ```python
INF = 10 ** 20
def search(rest, now, goal, dp, edges):
if now == goal:
return 0
if rest == ():
if now == goal:
return 0
else:
return INF
if (rest, now) in dp:
return dp[(rest, now)]
ret = INF
for i, t in enumerate(rest):
for dist, to in edges[now]:
ret = min(ret, search(tuple(v for j, v in enumerate(rest) if i != j), to, goal, dp, edges) + dist / t)
dp[(rest, now)] = ret
return ret
def main():
while True:
n, m, p, a, b = map(int, input().split())
if n == 0:
break
a -= 1
b -= 1
tlst = list(map(int, input().split()))
edges = [[] for _ in range(m)]
for _ in range(p):
x, y, z = map(int, input().split())
x -= 1
y -= 1
edges[x].append((z, y))
edges[y].append((z, x))
tlst.sort()
rest = tuple(tlst)
dp = {}
ans = search(rest, a, b, dp, edges)
if ans == INF:
print("Impossible")
else:
print(ans)
main()
``` |
p00859 Slim Span | Given an undirected weighted graph G, you should find one of spanning trees specified as follows.
The graph G is an ordered pair (V, E), where V is a set of vertices {v1, v2, ... , vn} and E is a set of undirected edges {e1, e2, ... , em}. Each edge e ∈ E has its weight w(e).
A spanning tree T is a tree (a connected subgraph without cycles) which connects all the n vertices with n - 1 edges. The slimness of a spanning tree T is defined as the difference between the largest weight and the smallest weight among the n - 1 edges of T.
<image>
Figure 5: A graph G and the weights of the edges
For example, a graph G in Figure 5(a) has four vertices {v1, v2, v3, v4} and five undirected edges {e1, e2, e3, e4, e5}. The weights of the edges are w(e1) = 3, w(e2) = 5, w(e3) = 6, w(e4) = 6, w(e5) = 7 as shown in Figure 5(b).
<image>
Figure 6: Examples of the spanning trees of G
There are several spanning trees for G. Four of them are depicted in Figure 6(a)-(d). The spanning tree Ta in Figure 6(a) has three edges whose weights are 3, 6 and 7. The largest weight is 7 and the smallest weight is 3 so that the slimness of the tree Ta is 4. The slimnesses of spanning trees Tb , Tc and Td shown in Figure 6(b), (c) and (d) are 3, 2 and 1, respectively. You can easily see the slimness of any other spanning tree is greater than or equal to 1, thus the spanning tree Td in Figure 6(d) is one of the slimmest spanning trees whose slimness is 1.
Your job is to write a program that computes the smallest slimness.
Input
The input consists of multiple datasets, followed by a line containing two zeros separated by a space. Each dataset has the following format.
n m
a1 b1 w1
.
.
.
am bm wm
Every input item in a dataset is a non-negative integer. Items in a line are separated by a space.
n is the number of the vertices and m the number of the edges. You can assume 2 ≤ n ≤ 100 and 0 ≤ m ≤ n(n - 1)/2. ak and bk (k = 1, ... , m) are positive integers less than or equal to n, which represent the two vertices vak and vbk connected by the kth edge ek. wk is a positive integer less than or equal to 10000, which indicates the weight of ek . You can assume that the graph G = (V, E) is simple, that is, there are no self-loops (that connect the same vertex) nor parallel edges (that are two or more edges whose both ends are the same two vertices).
Output
For each dataset, if the graph has spanning trees, the smallest slimness among them should be printed. Otherwise, -1 should be printed. An output should not contain extra characters.
Example
Input
4 5
1 2 3
1 3 5
1 4 6
2 4 6
3 4 7
4 6
1 2 10
1 3 100
1 4 90
2 3 20
2 4 80
3 4 40
2 1
1 2 1
3 0
3 1
1 2 1
3 3
1 2 2
2 3 5
1 3 6
5 10
1 2 110
1 3 120
1 4 130
1 5 120
2 3 110
2 4 120
2 5 130
3 4 120
3 5 110
4 5 120
5 10
1 2 9384
1 3 887
1 4 2778
1 5 6916
2 3 7794
2 4 8336
2 5 5387
3 4 493
3 5 6650
4 5 1422
5 8
1 2 1
2 3 100
3 4 100
4 5 100
1 5 50
2 5 50
3 5 50
4 1 150
0 0
Output
1
20
0
-1
-1
1
0
1686
50 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
class UnionFind:
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
return False
def subsetall(self):
a = []
for i in range(len(self.table)):
if self.table[i] < 0:
a.append((i, -self.table[i]))
return a
def main():
rr = []
while True:
n,m = LI()
if n == 0:
break
a = sorted([LI()[::-1] for _ in range(m)])
for i in range(2,n+1):
a.append([inf, 1, i])
r = inf
for i in range(m):
uf = UnionFind(n+1)
mt = 0
uc = 0
for t,x,y in a[i:]:
if uf.union(x,y):
mt = t
uc += 1
if uc == n-1:
break
if mt == inf:
break
tr = mt - a[i][0]
if r > tr:
r = tr
if r == inf:
r = -1
rr.append(r)
return '\n'.join(map(str, rr))
print(main())
``` |
p00990 ID | At University A, there were many mistakes in entering IDs.
Therefore, University A decided to issue a new ID to prevent typos.
There is a way to check if the new ID is correct to prevent typos.
・ Calculate the sum of all digits.
・ However, the number of even-numbered digits is doubled, with the rightmost digit as the first digit.
-When the number becomes 10 or more by doubling, the number obtained by adding the 1st digit and the 10th digit is used as the digit number.
・ If the sum is divisible by 10, the ID is correct, otherwise it is incorrect.
As an example, check the ID 53579.
Since the sum of all digits is calculated,
5 + 3 + 5 + 7 + 9
However, since the number of even-numbered digits is doubled,
5 + 6 + 5 + 14 + 9
When the number becomes 10 or more by doubling, the number obtained by adding the ones digit and the tens digit is the digit number.
5 + 6 + 5 + (1 + 4) + 9
From the above, the total sum is 30. Since 30 is divisible by 10, 53579 is the correct ID.
Mr. B is a college student at University A and was issued a new ID, but he forgot some digits of the ID.
However, I succeeded in narrowing down some candidates as to what kind of numbers will be included in the forgotten part.
Your job is to find out how many correct combinations of B's IDs are available.
Input
The input is given in the following format.
n
ID
m
a0 a1 ... am-1
n is the number of digits in the ID.
Each digit of the ID contains a number from 0 to 9 or the letter'*' to indicate that it is a forgotten digit.
m is the number of candidate numbers in the'*'.
ai is a candidate for numbers in'*'.
Input meets the following constraints
1 ≤ n ≤ 100,000
1 ≤ m ≤ 10
0 ≤ ai ≤ 9
Number of 1 ≤'*' ≤ 7
Output
Output the answer value on one line
Examples
Input
5
5*57*
2
3 9
Output
1
Input
15
2***9*2*6*1199*
9
0 1 2 3 4 6 7 8 9
Output
478297 | ```python
import itertools
n = int(input())
id = input()[::-1]
count = 0
a = []
odd, even = 0 , 0
tmp = 0
for i in range(1,n+1):
if id[i-1] == "*":
if i % 2:
odd += 1
else:
even += 1
elif i % 2 == 0:
x = int(id[i-1])
if x >= 5:
tmp += (x * 2 - 9)
else:
tmp += (x * 2)
else:
tmp += (int(id[i-1]))
m = int(input())
data = list(map(int, input().split()))
def sum2(ls):
ans = 0
for k in ls:
if k >= 5:
ans += (k * 2 - 9)
else:
ans += (k * 2)
return ans
odd_list = list(map(lambda x: (sum(x) % 10),list(itertools.product(data, repeat=odd))))
even_list = list(map(lambda x: ((sum2(x)) % 10),list(itertools.product(data, repeat=even))))
odd_mod = [odd_list.count(i) for i in range(10)]
even_mod = [even_list.count(i) for i in range(10)]
for i in range(10):
for j in range(10):
if ((i + j + tmp) % 10) == 0:
count += odd_mod[i] * even_mod[j]
print(count)
``` |
p01421 Reverse Roads | ICP city has an express company whose trucks run from the crossing S to the crossing T. The president of the company is feeling upset because all the roads in the city are one-way, and are severely congested. So, he planned to improve the maximum flow (edge disjoint paths) from the crossing S to the crossing T by reversing the traffic direction on some of the roads.
Your task is writing a program to calculate the maximized flow from S to T by reversing some roads, and the list of the reversed roads.
Input
The first line of a data set contains two integers N (2 \leq N \leq 300) and M (0 \leq M \leq {\rm min} (1\,000,\ N(N-1)/2)). N is the number of crossings in the city and M is the number of roads.
The following M lines describe one-way roads in the city. The i-th line (1-based) contains two integers X_i and Y_i (1 \leq X_i, Y_i \leq N, X_i \neq Y_i). X_i is the ID number (1-based) of the starting point of the i-th road and Y_i is that of the terminal point. The last line contains two integers S and T (1 \leq S, T \leq N, S \neq T, 1-based).
The capacity of each road is 1. You can assume that i \neq j implies either X_i \neq X_j or Y_i \neq Y_j, and either X_i \neq Y_j or X_j \neq Y_i.
Output
In the first line, print the maximized flow by reversing some roads. In the second line, print the number R of the reversed roads. In each of the following R lines, print the ID number (1-based) of a reversed road. You may not print the same ID number more than once.
If there are multiple answers which would give us the same flow capacity, you can print any of them.
Examples
Input
2 1
2 1
2 1
Output
1
0
Input
2 1
1 2
2 1
Output
1
1
1
Input
3 3
3 2
1 2
3 1
1 3
Output
2
2
1
3 | ```python
# AOJ 2304 Reverse Roads
# Python3 2018.7.21 bal4u
# *******************************************
# Dinic's Max Flow Algorithm
# *******************************************
INF = 0x7fffffff
class Donic:
def __init__(self, V):
self.V = V
self.level = [0] * V
self.iter = [0] * V
self.edge = [[] for i in range(V)]
def add_edge(self, frm, to, cap):
f, t = len(self.edge[frm]), len(self.edge[to])
self.edge[frm].append([to, cap, t])
self.edge[to].append([frm, cap, f])
def bfs(self, s):
self.level = [-1] * self.V
self.level[s] = 0
Q = []
Q.append(s)
while Q:
v = Q.pop()
for to, cap, rev in self.edge[v]:
if cap > 0 and self.level[to] < 0:
self.level[to] = self.level[v] + 1
Q.append(to)
def dfs(self, v, t, f):
if v == t: return f
k = self.iter[v]
while k < len(self.edge[v]):
to, cap, rev = self.edge[v][k]
if cap > 0 and self.level[v] < self.level[to]:
d = self.dfs(to, t, f if f <= cap else cap)
if d > 0:
self.edge[v][k][1] -= d
self.edge[to][rev][1] += d
return d
self.iter[v] += 1
k += 1
return 0
def maxFlow(self, s, t):
flow = 0
while True:
self.bfs(s)
if self.level[t] < 0: break
self.iter = [0] * self.V
while True:
f = self.dfs(s, t, INF)
if f <= 0: break
flow += f
return flow
N, M = map(int, input().split())
dir = [[0 for j in range(N)] for i in range(N)]
id = [[0 for j in range(N)] for i in range(N)]
d = Donic(N)
for i in range(M):
x, y = map(int, input().split())
x, y = x-1, y-1
dir[y][x] = 1
id[y][x] = i+1
d.add_edge(x, y, 1)
S, T = map(int, input().split())
print(d.maxFlow(S-1, T-1))
ans = []
for i in range(N):
for to, cap, rev in d.edge[i]:
if cap < 1 and dir[i][to]: ans.append(id[i][to])
ans.sort()
print(len(ans))
if len(ans) > 0: print(*ans, sep='\n')
``` |
p02156 Ghost | Problem
Ghosts line up in a straight line from left to right with $ N $ people.
At first, the $ i $ th ghost from the left is facing left if $ U_i $ is'L', and facing right if it is'R'.
They are so timid that I don't want to see scary ghosts as much as possible.
You can instruct each ghost to look back.
It's scary to look back, so once the $ i $ th ghost looks back, it creates a fear of $ A_i $.
When the ghost looking to the left looks back, it turns to the right.
When the ghost looking to the right looks back, it turns to the left.
For $ i <j $, if the $ i $ th ghost is pointing to the right and the $ j $ th ghost is pointing to the left, then the $ i $ th ghost and the $ j $ th ghost are pointing to the left. Is defined as facing each other.
The following constraints are given in $ M $.
The $ S_i $ th ghost is scared of the $ T_i $ th ghost.
In the final state, if the $ S_i $ th ghost and the $ T_i $ th ghost face each other, a fear level of $ B_i $ will occur.
Find the minimum value of the total fear that occurs when you give the optimal instructions.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ le 500 $
* $ 0 \ le M \ le \ min (N \ times (N-1), 1000) $
* $ | U | = N $
* $ U_i = $'L' or'R'
* $ 1 \ le A_i \ le 1000 $
* $ 1 \ le B_i \ le 1000 $
* $ 1 \ le S_i, T_i \ le N $
* $ (S_i, T_i) \ ne (S_j, T_j), $ if $ i \ ne j $
* $ S_i \ ne T_i $
Input
The input is given in the following format.
$ N $ $ M $
$ U $
$ A_1 $ $ A_2 $ $ ... $ $ A_N $
$ S_1 $ $ T_1 $ $ B_1 $
$ S_2 $ $ T_2 $ $ B_2 $
$ \ vdots $
$ S_M $ $ T_M $ $ B_M $
All inputs are given as integers.
Output
Output the minimum value of the total fear level.
Examples
Input
3 1
RRL
5 5 1
3 1 10
Output
1
Input
5 5
RLRLL
9 5 1 3 10
1 3 5
2 4 9
4 2 16
1 5 2
3 5 10
Output
8 | ```python
from collections import deque
N,M = map(int,input().split())
U = input()
A = list(map(int,input().split()))
src = [tuple(map(int,input().split())) for i in range(M)]
edges = {}
for s,t,b in src:
s,t = s-1,t-1
if s>t: s,t = t,s
if (s,t) in edges:
edges[(s,t)] += b
else:
edges[(s,t)] = b
P = N+2
es = [[] for i in range(P)] # [[to1,cap1,rev1], ...]
def add_edge(fr,to,cap):
es[fr].append([to,cap,len(es[to])])
es[to].append([fr,0,len(es[fr])-1])
for i,(u,a) in enumerate(zip(U,A)):
if u == 'L':
add_edge(0,i+2,a)
add_edge(i+2,1,0)
else:
add_edge(0,i+2,0)
add_edge(i+2,1,a)
for (s,t),b in edges.items():
add_edge(t+2,s+2,b)
INF = float('inf')
level = [0] * P
iters = [0] * P
def dinic_max_flow(s,t):
global iters
def _bfs(s):
global level
level = [-1] * P
level[s] = 0
q = deque([s])
while q:
v = q.popleft()
for to,cap,rev in es[v]:
if cap > 0 and level[to] < 0:
level[to] = level[v] + 1
q.append(to)
def _dfs(v,t,f):
if v == t: return f
for i in range(iters[v],len(es[v])):
iters[v] += 1
to,cap,rev = es[v][i]
if es[v][i][1] > 0 and level[v] < level[to]:
d = _dfs(to,t,min(f,es[v][i][1]))
if d > 0:
es[v][i][1] -= d #cap
es[to][rev][1] += d
return d
return 0
flow = 0
while True:
_bfs(s)
if level[t] < 0: return flow
iters = [0] * P
f = 0
while True:
f = _dfs(s,t,INF)
if f <= 0: break
flow += f
print(dinic_max_flow(0,1))
``` |
p02297 Area | For a given polygon g, computes the area of the polygon.
g is represented by a sequence of points p1, p2,..., pn where line segments connecting pi and pi+1 (1 ≤ i ≤ n-1) are sides of g. The line segment connecting pn and p1 is also a side of the polygon.
Note that the polygon is not necessarily convex.
Constraints
* 3 ≤ n ≤ 100
* -10000 ≤ xi, yi ≤ 10000
* No point will occur more than once.
* Two sides can intersect only at a common endpoint.
Input
The input consists of coordinates of the points p1,..., pn in the following format:
n
x1 y1
x2 y2
:
xn yn
The first integer n is the number of points. The coordinate of a point pi is given by two integers xi and yi. The coordinates of points are given in the order of counter-clockwise visit of them.
Output
Print the area of the polygon in a line. The area should be printed with one digit to the right of the decimal point.
Examples
Input
3
0 0
2 2
-1 1
Output
2.0
Input
4
0 0
1 1
1 2
0 2
Output
1.5 | ```python
x=range(int(input()))
P=[]
for _ in reversed(x):P+=[[int(i) for i in input().split()]]
P+=[P[0]]
for j in x:_+=P[j+1][1]*P[j][0]-P[j][1]*P[j+1][0]
print(_*0.5)
``` |
p02444 Rotate | Write a program which reads a sequence of integers $A = \\{a_0, a_1, ..., a_{n-1}\\}$ and rotate specified elements by a list of the following operation:
* rotate($b, m, e$): For each integer $k$ ($0 \leq k < (e - b)$), move element $b + k$ to the place of element $b + ((k + (e - m)) \mod (e - b))$.
Constraints
* $1 \leq n \leq 1,000$
* $-1,000,000,000 \leq a_i \leq 1,000,000,000$
* $1 \leq q \leq 1,000$
* $0 \leq b_i \leq m_i < e_i \leq n$
Input
The input is given in the following format.
$n$
$a_0 \; a_1 \; ...,\; a_{n-1}$
$q$
$b_1 \; m_1 \; e_1$
$b_2 \; m_2 \; e_2$
:
$b_{q} \; m_{q} \; e_{q}$
In the first line, $n$ (the number of elements in $A$) is given. In the second line, $a_i$ (each element in $A$) are given. In the third line, the number of queries $q$ is given and each query is given by three integers $b_i \; m_i \; e_i$ in the following $q$ lines.
Output
Print all elements of $A$ in a line after performing the given operations. Put a single space character between adjacency elements and a newline at the end of the last element.
Example
Input
11
1 2 3 4 5 6 7 8 9 10 11
1
2 6 9
Output
1 2 7 8 9 3 4 5 6 10 11 | ```python
input()
a = list(map(int, input().split()))
for _ in range(int(input())):
b,m,e = map(int, input().split())
x=a[m:e]
a[b+e-m:e]=a[b:m]
a[b:b+e-m]=x
print(" ".join(list(map(str,a))))
``` |
1023_A. Single Wildcard Pattern Matching | You are given two strings s and t. The string s consists of lowercase Latin letters and at most one wildcard character '*', the string t consists only of lowercase Latin letters. The length of the string s equals n, the length of the string t equals m.
The wildcard character '*' in the string s (if any) can be replaced with an arbitrary sequence (possibly empty) of lowercase Latin letters. No other character of s can be replaced with anything. If it is possible to replace a wildcard character '*' in s to obtain a string t, then the string t matches the pattern s.
For example, if s="aba*aba" then the following strings match it "abaaba", "abacaba" and "abazzzaba", but the following strings do not match: "ababa", "abcaaba", "codeforces", "aba1aba", "aba?aba".
If the given string t matches the given string s, print "YES", otherwise print "NO".
Input
The first line contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the length of the string s and the length of the string t, respectively.
The second line contains string s of length n, which consists of lowercase Latin letters and at most one wildcard character '*'.
The third line contains string t of length m, which consists only of lowercase Latin letters.
Output
Print "YES" (without quotes), if you can obtain the string t from the string s. Otherwise print "NO" (without quotes).
Examples
Input
6 10
code*s
codeforces
Output
YES
Input
6 5
vk*cup
vkcup
Output
YES
Input
1 1
v
k
Output
NO
Input
9 6
gfgf*gfgf
gfgfgf
Output
NO
Note
In the first example a wildcard character '*' can be replaced with a string "force". So the string s after this replacement is "codeforces" and the answer is "YES".
In the second example a wildcard character '*' can be replaced with an empty string. So the string s after this replacement is "vkcup" and the answer is "YES".
There is no wildcard character '*' in the third example and the strings "v" and "k" are different so the answer is "NO".
In the fourth example there is no such replacement of a wildcard character '*' that you can obtain the string t so the answer is "NO". | ```python
#Stanley Tantysco - 2201814670
#Problem B - Wild Card
def str_limit(n):
if (n >= 1 and n <= 200000):
return True
else:
return False
def wild_counter(s):
count=0
for i in s:
if i == '*':
count += 1
if count <= 1:
return True
else:
return False
limit_in=input()
parse=limit_in.split(' ')
n=int(parse[0])
m=int(parse[1])
s=input()
t=input()
parse2=list(s)
parse3=list(t)
#print(parse2)
#print(parse3)
wildcard=False
wildindex=-1
firststr=""
laststr=""
for i in range(0,len(parse2)):
if parse2[i]=='*':
wildcard=True
wildindex=i
firststr=s[:wildindex]
laststr=s[wildindex+1:len(parse2)]
break
if wildcard:
if n <= m:
if len(s) != 1:
if s[0] == '*':
temp1=t[:(len(t)+1)-len(s)]
temp3=temp1+laststr
elif s[len(parse2)-1] == '*':
temp1=t[len(s)-1:len(t)]
temp3=firststr+temp1
else:
temp1=t.replace(laststr,"")
temp2=temp1.replace(firststr,"")
temp3=firststr+temp2+laststr
else:
temp3=s.replace('*',t)
if temp3 == t:
print('Yes')
else:
print('No')
else:
temp2=s.replace("*","")
if temp2 == t:
print('Yes')
else:
print('No')
else:
if s == t:
print("Yes")
else:
print("No")
``` |
1044_B. Intersecting Subtrees | You are playing a strange game with Li Chen. You have a tree with n nodes drawn on a piece of paper. All nodes are unlabeled and distinguishable. Each of you independently labeled the vertices from 1 to n. Neither of you know the other's labelling of the tree.
You and Li Chen each chose a subtree (i.e., a connected subgraph) in that tree. Your subtree consists of the vertices labeled x_1, x_2, …, x_{k_1} in your labeling, Li Chen's subtree consists of the vertices labeled y_1, y_2, …, y_{k_2} in his labeling. The values of x_1, x_2, …, x_{k_1} and y_1, y_2, …, y_{k_2} are known to both of you.
<image> The picture shows two labelings of a possible tree: yours on the left and Li Chen's on the right. The selected trees are highlighted. There are two common nodes.
You want to determine whether your subtrees have at least one common vertex. Luckily, your friend Andrew knows both labelings of the tree. You can ask Andrew at most 5 questions, each of which is in one of the following two forms:
* A x: Andrew will look at vertex x in your labeling and tell you the number of this vertex in Li Chen's labeling.
* B y: Andrew will look at vertex y in Li Chen's labeling and tell you the number of this vertex in your labeling.
Determine whether the two subtrees have at least one common vertex after asking some questions. If there is at least one common vertex, determine one of your labels for any of the common vertices.
Interaction
Each test consists of several test cases.
The first line of input contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.
For each testcase, your program should interact in the following format.
The first line contains a single integer n (1 ≤ n ≤ 1 000) — the number of nodes in the tree.
Each of the next n-1 lines contains two integers a_i and b_i (1≤ a_i, b_i≤ n) — the edges of the tree, indicating an edge between node a_i and b_i according to your labeling of the nodes.
The next line contains a single integer k_1 (1 ≤ k_1 ≤ n) — the number of nodes in your subtree.
The next line contains k_1 distinct integers x_1,x_2,…,x_{k_1} (1 ≤ x_i ≤ n) — the indices of the nodes in your subtree, according to your labeling. It is guaranteed that these vertices form a subtree.
The next line contains a single integer k_2 (1 ≤ k_2 ≤ n) — the number of nodes in Li Chen's subtree.
The next line contains k_2 distinct integers y_1, y_2, …, y_{k_2} (1 ≤ y_i ≤ n) — the indices (according to Li Chen's labeling) of the nodes in Li Chen's subtree. It is guaranteed that these vertices form a subtree according to Li Chen's labelling of the tree's nodes.
Test cases will be provided one by one, so you must complete interacting with the previous test (i.e. by printing out a common node or -1 if there is not such node) to start receiving the next one.
You can ask the Andrew two different types of questions.
* You can print "A x" (1 ≤ x ≤ n). Andrew will look at vertex x in your labeling and respond to you with the number of this vertex in Li Chen's labeling.
* You can print "B y" (1 ≤ y ≤ n). Andrew will look at vertex y in Li Chen's labeling and respond to you with the number of this vertex in your labeling.
You may only ask at most 5 questions per tree.
When you are ready to answer, print "C s", where s is your label of a vertex that is common to both subtrees, or -1, if no such vertex exists. Printing the answer does not count as a question. Remember to flush your answer to start receiving the next test case.
After printing a question do not forget to print end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
If the judge responds with -1, it means that you asked more queries than allowed, or asked an invalid query. Your program should immediately terminate (for example, by calling exit(0)). You will receive Wrong Answer; it means that you asked more queries than allowed, or asked an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.
Hack Format
To hack, use the following format. Note that you can only hack with one test case.
The first line should contain a single integer t (t=1).
The second line should contain a single integer n (1 ≤ n ≤ 1 000).
The third line should contain n integers p_1, p_2, …, p_n (1≤ p_i≤ n) — a permutation of 1 to n. This encodes the labels that Li Chen chose for his tree. In particular, Li Chen chose label p_i for the node you labeled i.
Each of the next n-1 lines should contain two integers a_i and b_i (1≤ a_i, b_i≤ n). These edges should form a tree.
The next line should contain a single integer k_1 (1 ≤ k_1 ≤ n).
The next line should contain k_1 distinct integers x_1,x_2,…,x_{k_1} (1 ≤ x_i ≤ n). These vertices should form a subtree.
The next line should contain a single integer k_2 (1 ≤ k_2 ≤ n).
The next line should contain k_2 distinct integers y_1, y_2, …, y_{k_2} (1 ≤ y_i ≤ n). These vertices should form a subtree in Li Chen's tree according to the permutation above.
Examples
Input
1
3
1 2
2 3
1
1
1
2
2
1
Output
A 1
B 2
C 1
Input
2
6
1 2
1 3
1 4
4 5
4 6
4
1 3 4 5
3
3 5 2
3
6
1 2
1 3
1 4
4 5
4 6
3
1 2 3
3
4 1 6
5
Output
B 2
C 1
A 1
C -1
Note
For the first sample, Li Chen's hidden permutation is [2, 3, 1], and for the second, his hidden permutation is [5, 3, 2, 4, 1, 6] for both cases.
In the first sample, there is a tree with three nodes in a line. On the top, is how you labeled the tree and the subtree you chose, and the bottom is how Li Chen labeled the tree and the subtree he chose:
<image>
In the first question, you ask Andrew to look at node 1 in your labelling and tell you the label of it in Li Chen's labelling. Andrew responds with 2. At this point, you know that both of your subtrees contain the same node (i.e. node 1 according to your labeling), so you can output "C 1" and finish. However, you can also ask Andrew to look at node 2 in Li Chen's labelling and tell you the label of it in your labelling. Andrew responds with 1 (this step was given with the only reason — to show you how to ask questions).
For the second sample, there are two test cases. The first looks is the one from the statement:
<image>
We first ask "B 2", and Andrew will tell us 3. In this case, we know 3 is a common vertex, and moreover, any subtree with size 3 that contains node 3 must contain node 1 as well, so we can output either "C 1" or "C 3" as our answer.
In the second case in the second sample, the situation looks as follows:
<image>
In this case, you know that the only subtree of size 3 that doesn't contain node 1 is subtree 4,5,6. You ask Andrew for the label of node 1 in Li Chen's labelling and Andrew says 5. In this case, you know that Li Chen's subtree doesn't contain node 1, so his subtree must be consist of the nodes 4,5,6 (in your labelling), thus the two subtrees have no common nodes. | ```python
import sys
from collections import deque
t=int(sys.stdin.readline())
for i in range(t):
n=int(sys.stdin.readline())#node
EDGE=[list(map(int,sys.stdin.readline().split())) for i in range(n-1)]
k1=int(sys.stdin.readline())
X=list(map(int,sys.stdin.readline().split()))
k2=int(sys.stdin.readline())
Y=list(map(int,sys.stdin.readline().split()))
print("B",Y[0],flush=True)
yans=int(input())
if yans in X:
print("C",yans,flush=True)
else:
QUE=deque([yans])
EDGELIST=[[] for i in range(n+1)]
for i,j in EDGE:
EDGELIST[i].append(j)
EDGELIST[j].append(i)
checked=[0]*(n+1)
XLIST=[0]*(n+1)
for xver in X:
XLIST[xver]=1
while QUE:
now=QUE.pop()
checked[now]=1
for ver in EDGELIST[now]:
if checked[ver]==1:
continue
else:
QUE.append(ver)
if XLIST[now]==1:
break
print("A",now,flush=True)
if int(input()) in Y:
print("C",now,flush=True)
else:
print("C",-1,flush=True)
``` |
1067_A. Array Without Local Maximums | Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
a_{1} ≤ a_{2},
a_{n} ≤ a_{n-1} and
a_{i} ≤ max(a_{i-1}, a_{i+1}) for all i from 2 to n-1.
Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
Input
First line of input contains one integer n (2 ≤ n ≤ 10^{5}) — size of the array.
Second line of input contains n integers a_{i} — elements of array. Either a_{i} = -1 or 1 ≤ a_{i} ≤ 200. a_{i} = -1 means that i-th element can't be read.
Output
Print number of ways to restore the array modulo 998244353.
Examples
Input
3
1 -1 2
Output
1
Input
2
-1 -1
Output
200
Note
In the first example, only possible value of a_{2} is 2.
In the second example, a_{1} = a_{2} so there are 200 different values because all restored elements should be integers between 1 and 200. | ```python
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
MOD = 998244353
MODF = 1.0*MOD
from math import trunc
def quickmod(a):
return a-MODF*trunc(a/MODF)
def main():
n = int(input())
a = [int(i) for i in input().split()]
f0, f1 = [1.0] * 201, [0.0] * 201
nf0, nf1 = [0.0] * 201, [0.0] * 201
for i in range(n):
if a[i] == -1:
for j in range(200):
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
else:
for j in range(200):
nf0[j + 1], nf1[j + 1] = nf0[j], nf1[j]
if j + 1 == a[i]:
nf0[j + 1] = quickmod(nf0[j] + f0[j] + f1[j])
nf1[j + 1] = quickmod(nf1[j] - f0[j] + f0[j + 1] - f1[j] + f1[200])
f0, f1, nf0, nf1 = nf0, nf1, f0, f1
nf0[0]=0.0
os.write(1, str(int(quickmod(f1[200]))%MOD).encode())
if __name__ == '__main__':
main()
``` |
1108_E1. Array and Segments (Easy version) | The only difference between easy and hard versions is a number of elements in the array.
You are given an array a consisting of n integers. The value of the i-th element of the array is a_i.
You are also given a set of m segments. The j-th segment is [l_j; r_j], where 1 ≤ l_j ≤ r_j ≤ n.
You can choose some subset of the given set of segments and decrease values on each of the chosen segments by one (independently). For example, if the initial array a = [0, 0, 0, 0, 0] and the given segments are [1; 3] and [2; 4] then you can choose both of them and the array will become b = [-1, -2, -2, -1, 0].
You have to choose some subset of the given segments (each segment can be chosen at most once) in such a way that if you apply this subset of segments to the array a and obtain the array b then the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i will be maximum possible.
Note that you can choose the empty set.
If there are multiple answers, you can print any.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ 300) — the length of the array a and the number of segments, respectively.
The second line of the input contains n integers a_1, a_2, ..., a_n (-10^6 ≤ a_i ≤ 10^6), where a_i is the value of the i-th element of the array a.
The next m lines are contain two integers each. The j-th of them contains two integers l_j and r_j (1 ≤ l_j ≤ r_j ≤ n), where l_j and r_j are the ends of the j-th segment.
Output
In the first line of the output print one integer d — the maximum possible value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i if b is the array obtained by applying some subset of the given segments to the array a.
In the second line of the output print one integer q (0 ≤ q ≤ m) — the number of segments you apply.
In the third line print q distinct integers c_1, c_2, ..., c_q in any order (1 ≤ c_k ≤ m) — indices of segments you apply to the array a in such a way that the value max_{i=1}^{n}b_i - min_{i=1}^{n}b_i of the obtained array b is maximum possible.
If there are multiple answers, you can print any.
Examples
Input
5 4
2 -2 3 1 2
1 3
4 5
2 5
1 3
Output
6
2
1 4
Input
5 4
2 -2 3 1 4
3 5
3 4
2 4
2 5
Output
7
2
3 2
Input
1 0
1000000
Output
0
0
Note
In the first example the obtained array b will be [0, -4, 1, 1, 2] so the answer is 6.
In the second example the obtained array b will be [2, -3, 1, -1, 4] so the answer is 7.
In the third example you cannot do anything so the answer is 0. | ```python
n,m=map(int, input().split())
a=list(map(int,input().split()))
i=0
l1=[]
l2=[]
while i<m:
e,f=map(int,input().split())
l1.append(e)
l2.append(f)
i+=1
i=0
j=0
ans=-1
s=[]
while i<n:
j=0
while j<n:
k=0
l=a[j]-a[i]
m1=[]
while k<m:
if l1[k]<=i+1 and l2[k]>=i+1:
if l1[k]>j+1 or l2[k]<j+1:
l+=1
m1.append(k+1)
k+=1
if l>ans:
s=m1
ans=l
j+=1
i+=1
print(ans)
print(len(s))
for i in s:
print(i,end=" ")
``` |
1138_A. Sushi for Two | Arkady invited Anna for a dinner to a sushi restaurant. The restaurant is a bit unusual: it offers n pieces of sushi aligned in a row, and a customer has to choose a continuous subsegment of these sushi to buy.
The pieces of sushi are of two types: either with tuna or with eel. Let's denote the type of the i-th from the left sushi as t_i, where t_i = 1 means it is with tuna, and t_i = 2 means it is with eel.
Arkady does not like tuna, Anna does not like eel. Arkady wants to choose such a continuous subsegment of sushi that it has equal number of sushi of each type and each half of the subsegment has only sushi of one type. For example, subsegment [2, 2, 2, 1, 1, 1] is valid, but subsegment [1, 2, 1, 2, 1, 2] is not, because both halves contain both types of sushi.
Find the length of the longest continuous subsegment of sushi Arkady can buy.
Input
The first line contains a single integer n (2 ≤ n ≤ 100 000) — the number of pieces of sushi.
The second line contains n integers t_1, t_2, ..., t_n (t_i = 1, denoting a sushi with tuna or t_i = 2, denoting a sushi with eel), representing the types of sushi from left to right.
It is guaranteed that there is at least one piece of sushi of each type. Note that it means that there is at least one valid continuous segment.
Output
Print a single integer — the maximum length of a valid continuous segment.
Examples
Input
7
2 2 2 1 1 2 2
Output
4
Input
6
1 2 1 2 1 2
Output
2
Input
9
2 2 1 1 1 2 2 2 2
Output
6
Note
In the first example Arkady can choose the subsegment [2, 2, 1, 1] or the subsegment [1, 1, 2, 2] with length 4.
In the second example there is no way but to choose one of the subsegments [2, 1] or [1, 2] with length 2.
In the third example Arkady's best choice is the subsegment [1, 1, 1, 2, 2, 2]. | ```python
n = int(input())
a = [int(s) for s in input().split()]
i = 0
j = 0
cur1 = 0
cur = 0
res = 0
b = a[0]
prev = 0
while j < n and a[j] == b:
j+=1
cur1 += 1
cur += 1
while i < n and j < n:
if b == 1:
b = 2
else:
b = 1
prev = cur
cur = 0
while j < n and a[j] == b:
j += 1
cur1 += 1
cur += 1
if 2*min(prev, cur) > res:
res = 2*min(prev, cur)
while i < n and a[i] == 3 - b:
i += 1
cur1 -= 1
print(res)
``` |
1156_C. Match Points | You are given a set of points x_1, x_2, ..., x_n on the number line.
Two points i and j can be matched with each other if the following conditions hold:
* neither i nor j is matched with any other point;
* |x_i - x_j| ≥ z.
What is the maximum number of pairs of points you can match with each other?
Input
The first line contains two integers n and z (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ z ≤ 10^9) — the number of points and the constraint on the distance between matched points, respectively.
The second line contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9).
Output
Print one integer — the maximum number of pairs of points you can match with each other.
Examples
Input
4 2
1 3 3 7
Output
2
Input
5 5
10 9 5 8 7
Output
1
Note
In the first example, you may match point 1 with point 2 (|3 - 1| ≥ 2), and point 3 with point 4 (|7 - 3| ≥ 2).
In the second example, you may match point 1 with point 3 (|5 - 10| ≥ 5). | ```python
n,z=(int(i) for i in input().split())
k=0
x=sorted([int(i) for i in input().split()])
i,j=0,n//2
while i<n//2 and j<n:
if x[j]-x[i]>=z:
i+=1
k+=1
j+=1
print(k)
``` |
1178_F1. Short Colorful Strip | This is the first subtask of problem F. The only differences between this and the second subtask are the constraints on the value of m and the time limit. You need to solve both subtasks in order to hack this one.
There are n+1 distinct colours in the universe, numbered 0 through n. There is a strip of paper m centimetres long initially painted with colour 0.
Alice took a brush and painted the strip using the following process. For each i from 1 to n, in this order, she picks two integers 0 ≤ a_i < b_i ≤ m, such that the segment [a_i, b_i] is currently painted with a single colour, and repaints it with colour i.
Alice chose the segments in such a way that each centimetre is now painted in some colour other than 0. Formally, the segment [i-1, i] is painted with colour c_i (c_i ≠ 0). Every colour other than 0 is visible on the strip.
Count the number of different pairs of sequences \\{a_i\}_{i=1}^n, \\{b_i\}_{i=1}^n that result in this configuration.
Since this number may be large, output it modulo 998244353.
Input
The first line contains a two integers n, m (1 ≤ n ≤ 500, n = m) — the number of colours excluding the colour 0 and the length of the paper, respectively.
The second line contains m space separated integers c_1, c_2, …, c_m (1 ≤ c_i ≤ n) — the colour visible on the segment [i-1, i] after the process ends. It is guaranteed that for all j between 1 and n there is an index k such that c_k = j.
Note that since in this subtask n = m, this means that c is a permutation of integers 1 through n.
Output
Output a single integer — the number of ways Alice can perform the painting, modulo 998244353.
Examples
Input
3 3
1 2 3
Output
5
Input
7 7
4 5 1 6 2 3 7
Output
165
Note
In the first example, there are 5 ways, all depicted in the figure below. Here, 0 is white, 1 is red, 2 is green and 3 is blue.
<image>
Below is an example of a painting process that is not valid, as in the second step the segment 1 3 is not single colour, and thus may not be repainted with colour 2.
<image> | ```python
class SparseTable():
"""区間取得クエリをO(1)で答えるデータ構造をO(NlogN)で構築する
query(l, r): 区間[l, r)に対するクエリに答える
"""
def __init__(self, array, n):
n = len(array)
self.row_size = n.bit_length()
# log_tableを構築する
# log_table = [0, 0, 1, 1, 2, 2, 2, 2, ...]
self.log_table = [0] * (n + 1)
for i in range(2, n + 1):
self.log_table[i] = self.log_table[i//2] + 1
# sparse_tableを構築する
self.sparse_table = [[0] * n for _ in range(self.row_size)]
for i in range(n):
self.sparse_table[0][i] = array[i]
for row in range(1, self.row_size):
for i in range(n - (1 << row) + 1):
self.sparse_table[row][i] = self._merge(self.sparse_table[row - 1][i], \
self.sparse_table[row - 1][i + (1 << row - 1)])
def _merge(self, num1, num2):
"""クエリの内容"""
return min(num1, num2)
def query(self, l, r):
"""区間[l, r)に対するクエリに答える"""
row = self.log_table[r - l]
return self._merge(self.sparse_table[row][l], self.sparse_table[row][r - (1 << row)])
n, m = map(int, input().split())
a = list(map(int, input().split()))
MOD = 998244353
sp = SparseTable(a, n)
to_ind = {}
for i in range(n):
to_ind[a[i]] = i
dp = [[-1]*(n+1) for i in range(n+1)]
def solve(l, r):
if dp[l][r] != -1:
return dp[l][r]
if l == r:
dp[l][r] = 1
return 1
if r - l == 1:
dp[l][r] = 1
return 1
ind = to_ind[sp.query(l, r)]
res1 = 0
res2 = 0
for i in range(ind+1, r+1):
res1 += solve(ind+1, i) * solve(i, r)
res1 %= MOD
for i in range(l, ind+1):
res2 += solve(l, i) * solve(i, ind)
res2 %= MOD
dp[l][r] = max(res1, 1)*max(res2, 1)
dp[l][r] %= MOD
return dp[l][r]
print(solve(0, n) % MOD)
``` |
1196_E. Connected Component on a Chessboard | You are given two integers b and w. You have a chessboard of size 10^9 × 10^9 with the top left cell at (1; 1), the cell (1; 1) is painted white.
Your task is to find a connected component on this chessboard that contains exactly b black cells and exactly w white cells. Two cells are called connected if they share a side (i.e. for the cell (x, y) there are at most four connected cells: (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)). A set of cells is called a connected component if for every pair of cells C_1 and C_2 from this set, there exists a sequence of cells c_1, c_2, ..., c_k such that c_1 = C_1, c_k = C_2, all c_i from 1 to k are belong to this set of cells and for every i ∈ [1, k - 1], cells c_i and c_{i + 1} are connected.
Obviously, it can be impossible to find such component. In this case print "NO". Otherwise, print "YES" and any suitable connected component.
You have to answer q independent queries.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 10^5) — the number of queries. Then q queries follow.
The only line of the query contains two integers b and w (1 ≤ b, w ≤ 10^5) — the number of black cells required and the number of white cells required.
It is guaranteed that the sum of numbers of cells does not exceed 2 ⋅ 10^5 (∑ w + ∑ b ≤ 2 ⋅ 10^5).
Output
For each query, print the answer to it.
If it is impossible to find the required component, print "NO" on the first line.
Otherwise, print "YES" on the first line. In the next b + w lines print coordinates of cells of your component in any order. There should be exactly b black cells and w white cells in your answer. The printed component should be connected.
If there are several answers, you can print any. All coordinates in the answer should be in the range [1; 10^9].
Example
Input
3
1 1
1 4
2 5
Output
YES
2 2
1 2
YES
2 3
1 3
3 3
2 2
2 4
YES
2 3
2 4
2 5
1 3
1 5
3 3
3 5 | ```python
''' CODED WITH LOVE BY SATYAM KUMAR '''
from sys import stdin, stdout
import cProfile, math
from collections import Counter,defaultdict,deque
from bisect import bisect_left,bisect,bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
sys.setrecursionlimit(10**6) # max depth of recursion
threading.stack_size(2**27) # new thread will get stack of such size
fac_warmup = False
printHeap = str()
memory_constrained = False
P = 10**9+7
import sys
class merge_find:
def __init__(self,n):
self.parent = list(range(n))
self.size = [1]*n
self.num_sets = n
self.lista = [[_] for _ in range(n)]
def find(self,a):
to_update = []
while a != self.parent[a]:
to_update.append(a)
a = self.parent[a]
for b in to_update:
self.parent[b] = a
return self.parent[a]
def merge(self,a,b):
a = self.find(a)
b = self.find(b)
if a==b:
return
if self.size[a]<self.size[b]:
a,b = b,a
self.num_sets -= 1
self.parent[b] = a
self.size[a] += self.size[b]
self.lista[a] += self.lista[b]
def set_size(self, a):
return self.size[self.find(a)]
def __len__(self):
return self.num_sets
def display(string_to_print):
stdout.write(str(string_to_print) + "\n")
def primeFactors(n): #n**0.5 complex
factors = dict()
for i in range(2,math.ceil(math.sqrt(n))+1):
while n % i== 0:
if i in factors:
factors[i]+=1
else: factors[i]=1
n = n // i
if n>2:
factors[n]=1
return (factors)
def all_factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
def fibonacci_modP(n,MOD):
if n<2: return 1
#print (n,MOD)
return (cached_fn(fibonacci_modP, (n+1)//2, MOD)*cached_fn(fibonacci_modP, n//2, MOD) + cached_fn(fibonacci_modP, (n-1) // 2, MOD)*cached_fn(fibonacci_modP, (n-2) // 2, MOD)) % MOD
def factorial_modP_Wilson(n , p):
if (p <= n):
return 0
res = (p - 1)
for i in range (n + 1, p):
res = (res * cached_fn(InverseEuler,i, p)) % p
return res
def binary(n,digits = 20):
b = bin(n)[2:]
b = '0'*(digits-len(b))+b
return b
def isprime(n):
"""Returns True if n is prime."""
if n < 4:
return True
if n % 2 == 0:
return False
if n % 3 == 0:
return False
i = 5
w = 2
while i * i <= n:
if n % i == 0:
return False
i += w
w = 6 - w
return True
def generate_primes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n+1, p):
prime[i] = False
p += 1
return prime
factorial_modP = []
def warm_up_fac(MOD):
global factorial_modP,fac_warmup
if fac_warmup: return
factorial_modP= [1 for _ in range(fac_warmup_size+1)]
for i in range(2,fac_warmup_size):
factorial_modP[i]= (factorial_modP[i-1]*i) % MOD
fac_warmup = True
def InverseEuler(n,MOD):
return pow(n,MOD-2,MOD)
def nCr(n, r, MOD):
global fac_warmup,factorial_modP
if not fac_warmup:
warm_up_fac(MOD)
fac_warmup = True
return (factorial_modP[n]*((pow(factorial_modP[r], MOD-2, MOD) * pow(factorial_modP[n-r], MOD-2, MOD)) % MOD)) % MOD
def test_print(*args):
if testingMode:
print(args)
def display_list(list1, sep=" "):
stdout.write(sep.join(map(str, list1)) + "\n")
def display_2D_list(li):
for i in li:
print(i)
def prefix_sum(li):
sm = 0
res = []
for i in li:
sm+=i
res.append(sm)
return res
def get_int():
return int(stdin.readline().strip())
def get_tuple():
return map(int, stdin.readline().split())
def get_list():
return list(map(int, stdin.readline().split()))
import heapq,itertools
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = '<removed-task>'
def add_task(task, priority=0):
'Add a new task or update the priority of an existing task'
if task in entry_finder:
remove_task(task)
count = next(counter)
entry = [priority, count, task]
entry_finder[task] = entry
heapq.heappush(pq, entry)
def remove_task(task):
'Mark an existing task as REMOVED. Raise KeyError if not found.'
entry = entry_finder.pop(task)
entry[-1] = REMOVED
def pop_task():
'Remove and return the lowest priority task. Raise KeyError if empty.'
while pq:
priority, count, task = heapq.heappop(pq)
if task is not REMOVED:
del entry_finder[task]
return task
raise KeyError('pop from an empty priority queue')
memory = dict()
def clear_cache():
global memory
memory = dict()
def cached_fn(fn, *args):
global memory
if args in memory:
return memory[args]
else:
result = fn(*args)
memory[args] = result
return result
def ncr (n,r):
return math.factorial(n)/(math.factorial(n-r)*math.factorial(r))
def binary_serach(i,li):
#print("Search for ",i)
fn = lambda x: li[x]-x//i
x = -1
b = len(li)
while b>=1:
#print(b,x)
while b+x<len(li) and fn(b+x)>0: #Change this condition 2 to whatever you like
x+=b
b=b//2
return x
# -------------------------------------------------------------- MAIN PROGRAM
TestCases = True
testingMode = False
fac_warmup_size = 10**5+100
optimiseForReccursion = False #Can not be used clubbed with TestCases # WHen using recursive functions, use Python 3
from math import factorial
def main():
b, w = get_tuple()
maxi,mini = max(b,w), min(b,w)
points = []
if maxi<=mini*3 + 1:
print("YES")
if w>b:
z = 0
else:
z = 1
for i in range(2*mini):
points.append([2+i+z,2])
rem = maxi-mini
if rem!=0:
points.append([3+z+i,2])
rem-=1
for j in range(3+z, 3+i+z+1, 2):
if rem>0:
points.append([j,1])
rem-=1
if rem>0:
points.append([j,3])
rem-=1
for i in points:
display_list(i)
else:
print("NO")
# --------------------------------------------------------------------- END=
if TestCases:
for i in range(get_int()):
cProfile.run('main()') if testingMode else main()
else: (cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()
``` |
1213_G. Path Queries | You are given a weighted tree consisting of n vertices. Recall that a tree is a connected graph without cycles. Vertices u_i and v_i are connected by an edge with weight w_i.
You are given m queries. The i-th query is given as an integer q_i. In this query you need to calculate the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of vertices in the tree and the number of queries.
Each of the next n - 1 lines describes an edge of the tree. Edge i is denoted by three integers u_i, v_i and w_i — the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) and the weight of the edge (1 ≤ w_i ≤ 2 ⋅ 10^5). It is guaranteed that the given edges form a tree.
The last line of the input contains m integers q_1, q_2, ..., q_m (1 ≤ q_i ≤ 2 ⋅ 10^5), where q_i is the maximum weight of an edge in the i-th query.
Output
Print m integers — the answers to the queries. The i-th value should be equal to the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.
Queries are numbered from 1 to m in the order of the input.
Examples
Input
7 5
1 2 1
3 2 3
2 4 1
4 5 2
5 7 4
3 6 2
5 2 3 4 1
Output
21 7 15 21 3
Input
1 2
1 2
Output
0 0
Input
3 3
1 2 1
2 3 2
1 3 2
Output
1 3 3
Note
The picture shows the tree from the first example: <image> | ```python
n,m=map(int,input().split())
"""L=[]
for i in range(n):
s=[]
L.append(s)"""
dp=[]
for i in range(n-1):
u,v,w=map(int,input().split())
#L[u-1].append(v-1)
#L[v-1].append(u-1)
dp.append((w,u-1,v-1))
dp=sorted(dp)
q=[int(x) for x in input().split()]
pos=[]
for i in range(m):
pos.append(i)
Q=sorted(zip(q,pos))
par=[]
for i in range(0,n):
par.append(i)
rank=[1]*n
def find(x):
if(par[x]!=x):
par[x]=find(par[x])
return par[x]
global res
res=0
def union(x,y):
global res
X=find(x)
Y=find(y)
if(rank[X]<rank[Y]):
temp=X
X=Y
Y=temp
res=res-(rank[X]*(rank[X]-1)//2)
res=res-(rank[Y]*(rank[Y]-1)//2)
rank[X]+=rank[Y]
res=res+(rank[X]*(rank[X]-1)//2)
par[Y]=X
"""if(X==Y):
return
if(rank[X]<rank[Y]):
par[X]=Y
elif(rank[X]>rank[Y]):
par[Y]=X
else:
par[Y]=X
rank[X]=rank[Y]+1"""
ans=[0]*m
ptr=0
for i in range(0,m):
while(ptr<n-1 and dp[ptr][0]<=Q[i][0]):
a=dp[ptr][1]
b=dp[ptr][2]
union(a,b)
ptr+=1
ans[Q[i][1]]=res
"""temp=Q[0][0]
ptr=0
for i in range(0,len(dp)):
if(dp[i][0]>temp):
ans[Q[ptr][1]]=res
ptr+=1
temp=Q[ptr][0]
union(dp[i][1],dp[i][2])
for i in range(ptr,len(Q)):
ans[Q[i][1]]=res"""
print(*ans)
``` |
1237_C1. Balanced Removals (Easier) | This is an easier version of the problem. In this version, n ≤ 2000.
There are n distinct points in three-dimensional space numbered from 1 to n. The i-th point has coordinates (x_i, y_i, z_i). The number of points n is even.
You'd like to remove all n points using a sequence of n/2 snaps. In one snap, you can remove any two points a and b that have not been removed yet and form a perfectly balanced pair. A pair of points a and b is perfectly balanced if no other point c (that has not been removed yet) lies within the axis-aligned minimum bounding box of points a and b.
Formally, point c lies within the axis-aligned minimum bounding box of points a and b if and only if min(x_a, x_b) ≤ x_c ≤ max(x_a, x_b), min(y_a, y_b) ≤ y_c ≤ max(y_a, y_b), and min(z_a, z_b) ≤ z_c ≤ max(z_a, z_b). Note that the bounding box might be degenerate.
Find a way to remove all points in n/2 snaps.
Input
The first line contains a single integer n (2 ≤ n ≤ 2000; n is even), denoting the number of points.
Each of the next n lines contains three integers x_i, y_i, z_i (-10^8 ≤ x_i, y_i, z_i ≤ 10^8), denoting the coordinates of the i-th point.
No two points coincide.
Output
Output n/2 pairs of integers a_i, b_i (1 ≤ a_i, b_i ≤ n), denoting the indices of points removed on snap i. Every integer between 1 and n, inclusive, must appear in your output exactly once.
We can show that it is always possible to remove all points. If there are many solutions, output any of them.
Examples
Input
6
3 1 0
0 3 0
2 2 0
1 0 0
1 3 0
0 1 0
Output
3 6
5 1
2 4
Input
8
0 1 1
1 0 1
1 1 0
1 1 1
2 2 2
3 2 2
2 3 2
2 2 3
Output
4 5
1 6
2 7
3 8
Note
In the first example, here is what points and their corresponding bounding boxes look like (drawn in two dimensions for simplicity, as all points lie on z = 0 plane). Note that order of removing matters: for example, points 5 and 1 don't form a perfectly balanced pair initially, but they do after point 3 is removed.
<image> | ```python
def d(le):
for i in range(0,len(le),2):
# if le[i][3]==29 and le[i+1][3]==38:
# print(me)
# return ''
print(le[i][3],le[i+1][3])
def dd(it):
global do
# print(it)
tt={}
ddd=[]
it.sort(key=lambda x:x[1])
l=list(set([i[1] for i in it]))
l.sort()
for i in l:
tt[i]=[]
for i in it:
tt[i[1]].append(i)
for i in l:
x=tt[i]
if len(x)%2==1:
ddd.append(x[-1][:])
x=x[:-1]
if len(x)>0:
x.sort(key=lambda x:x[0])
d(x[:])
if len(ddd)%2==1:
do.append(ddd[-1][:])
ddd=ddd[:-1]
if len(ddd)>0:
ddd.sort(key=lambda x:x[1])
d(ddd)
n=int(input())
it=[]
for i in range(n):
it.append(list(map(int,input().split()))+[i+1])
ss={}
it.sort(key=lambda x:[x[2],x[1],x[0],x[3]])
l=list(set([i[2] for i in it]))
l.sort()
for i in l:
ss[i]=[]
for i in it:
ss[i[2]].append(i)
do=[]
for i in l:
x=ss[i]
dd(x[:])
#do.sort(key=lambda x:x[2])
d(do)
``` |
1255_B. Fridge Lockers | Hanh lives in a shared apartment. There are n people (including Hanh) living there, each has a private fridge.
n fridges are secured by several steel chains. Each steel chain connects two different fridges and is protected by a digital lock. The owner of a fridge knows passcodes of all chains connected to it. A fridge can be open only if all chains connected to it are unlocked. For example, if a fridge has no chains connected to it at all, then any of n people can open it.
<image> For exampe, in the picture there are n=4 people and 5 chains. The first person knows passcodes of two chains: 1-4 and 1-2. The fridge 1 can be open by its owner (the person 1), also two people 2 and 4 (acting together) can open it.
The weights of these fridges are a_1, a_2, …, a_n. To make a steel chain connecting fridges u and v, you have to pay a_u + a_v dollars. Note that the landlord allows you to create multiple chains connecting the same pair of fridges.
Hanh's apartment landlord asks you to create exactly m steel chains so that all fridges are private. A fridge is private if and only if, among n people living in the apartment, only the owner can open it (i.e. no other person acting alone can do it). In other words, the fridge i is not private if there exists the person j (i ≠ j) that the person j can open the fridge i.
For example, in the picture all the fridges are private. On the other hand, if there are n=2 fridges and only one chain (which connects them) then both fridges are not private (both fridges can be open not only by its owner but also by another person).
Of course, the landlord wants to minimize the total cost of all steel chains to fulfill his request. Determine whether there exists any way to make exactly m chains, and if yes, output any solution that minimizes the total cost.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 10). Then the descriptions of the test cases follow.
The first line of each test case contains two integers n, m (2 ≤ n ≤ 1000, 1 ≤ m ≤ n) — the number of people living in Hanh's apartment and the number of steel chains that the landlord requires, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 10^4) — weights of all fridges.
Output
For each test case:
* If there is no solution, print a single integer -1.
* Otherwise, print a single integer c — the minimum total cost. The i-th of the next m lines contains two integers u_i and v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i), meaning that the i-th steel chain connects fridges u_i and v_i. An arbitrary number of chains can be between a pair of fridges.
If there are multiple answers, print any.
Example
Input
3
4 4
1 1 1 1
3 1
1 2 3
3 3
1 2 3
Output
8
1 2
4 3
3 2
4 1
-1
12
3 2
1 2
3 1 | ```python
t = int(input())
for i in range(t):
n, m = map(int, input().split())
dop = list(map(int, input().split()))
suma = sum(dop)
mas = []
for i in range(n):
mas.append([dop[i], i])
if m < n or n == 2:
print (-1)
continue
mas.sort()
print(suma * 2 + (mas[0][0] + mas[1][0]) * (m - n))
for i in range(1, n):
print (i, i + 1)
print (n, 1)
for i in range(m - n):
print(mas[0][1] + 1, mas[1][1] + 1)
``` |
1279_A. New Year Garland | Polycarp is sad — New Year is coming in few days but there is still no snow in his city. To bring himself New Year mood, he decided to decorate his house with some garlands.
The local store introduced a new service this year, called "Build your own garland". So you can buy some red, green and blue lamps, provide them and the store workers will solder a single garland of them. The resulting garland will have all the lamps you provided put in a line. Moreover, no pair of lamps of the same color will be adjacent to each other in this garland!
For example, if you provide 3 red, 3 green and 3 blue lamps, the resulting garland can look like this: "RGBRBGBGR" ("RGB" being the red, green and blue color, respectively). Note that it's ok to have lamps of the same color on the ends of the garland.
However, if you provide, say, 1 red, 10 green and 2 blue lamps then the store workers won't be able to build any garland of them. Any garland consisting of these lamps will have at least one pair of lamps of the same color adjacent to each other. Note that the store workers should use all the lamps you provided.
So Polycarp has bought some sets of lamps and now he wants to know if the store workers can build a garland from each of them.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of sets of lamps Polycarp has bought.
Each of the next t lines contains three integers r, g and b (1 ≤ r, g, b ≤ 10^9) — the number of red, green and blue lamps in the set, respectively.
Output
Print t lines — for each set of lamps print "Yes" if the store workers can build a garland from them and "No" otherwise.
Example
Input
3
3 3 3
1 10 2
2 1 1
Output
Yes
No
Yes
Note
The first two sets are desribed in the statement.
The third set produces garland "RBRG", for example. | ```python
n = int(input())
for i in range(n):
l = [int(k) for k in input().split()]
l.sort()
if l[2] <= l[1]+l[0]+1 :
print("YES")
else :
print("NO")
``` |
1322_B. Present | Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | ```python
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
L = max(A).bit_length()+1
ans = 0
for l in range(L+1):
A1 = []
A2 = []
for a in A:
if a&(1<<l):
A1.append(a)
else:
A2.append(a)
A = A2 + A1
D = 1<<(l+1)
i1 = N
i2 = N
i3 = N
k = 0
for i, a in enumerate(A):
while i1 > 0 and a%D + A[i1-1]%D >= D//2:
i1 -= 1
while i2 > 0 and a%D + A[i2-1]%D >= D:
i2 -= 1
while i3 > 0 and a%D + A[i3-1]%D >= D//2*3:
i3 -= 1
k += (i2 - i1) + (N - i3)
if i1 <= i < i2 or i3 <= i < N:
k -= 1
if k%4 != 0:
ans += D//2
print(ans)
``` |
1341_A. Nastya and Rice | Nastya just made a huge mistake and dropped a whole package of rice on the floor. Mom will come soon. If she sees this, then Nastya will be punished.
In total, Nastya dropped n grains. Nastya read that each grain weighs some integer number of grams from a - b to a + b, inclusive (numbers a and b are known), and the whole package of n grains weighs from c - d to c + d grams, inclusive (numbers c and d are known). The weight of the package is the sum of the weights of all n grains in it.
Help Nastya understand if this information can be correct. In other words, check whether each grain can have such a mass that the i-th grain weighs some integer number x_i (a - b ≤ x_i ≤ a + b), and in total they weigh from c - d to c + d, inclusive (c - d ≤ ∑_{i=1}^{n}{x_i} ≤ c + d).
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The next t lines contain descriptions of the test cases, each line contains 5 integers: n (1 ≤ n ≤ 1000) — the number of grains that Nastya counted and a, b, c, d (0 ≤ b < a ≤ 1000, 0 ≤ d < c ≤ 1000) — numbers that determine the possible weight of one grain of rice (from a - b to a + b) and the possible total weight of the package (from c - d to c + d).
Output
For each test case given in the input print "Yes", if the information about the weights is not inconsistent, and print "No" if n grains with masses from a - b to a + b cannot make a package with a total mass from c - d to c + d.
Example
Input
5
7 20 3 101 18
11 11 10 234 2
8 9 7 250 122
19 41 21 321 10
3 10 8 6 1
Output
Yes
No
Yes
No
Yes
Note
In the first test case of the example, we can assume that each grain weighs 17 grams, and a pack 119 grams, then really Nastya could collect the whole pack.
In the third test case of the example, we can assume that each grain weighs 16 grams, and a pack 128 grams, then really Nastya could collect the whole pack.
In the fifth test case of the example, we can be assumed that 3 grains of rice weigh 2, 2, and 3 grams, and a pack is 7 grams, then really Nastya could collect the whole pack.
In the second and fourth test cases of the example, we can prove that it is impossible to determine the correct weight of all grains of rice and the weight of the pack so that the weight of the pack is equal to the total weight of all collected grains. | ```python
def main():
T = int(input())
for t in range(T):
n,a,b,c,d = list(map(int,input().split()))
pos = True
if((a-b)*n>(c+d)):
pos = False
elif((a-b)*n < (c-d)) and ((c-d)-(a-b)*n) > 2*b*n:
pos = False
print("YES") if pos else print("NO")
if __name__ == "__main__":
main()
``` |
1363_A. Odd Selection | Shubham has an array a of size n, and wants to select exactly x elements from it, such that their sum is odd. These elements do not have to be consecutive. The elements of the array are not guaranteed to be distinct.
Tell him whether he can do so.
Input
The first line of the input 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 and x (1 ≤ x ≤ n ≤ 1000) — the length of the array and the number of elements you need to choose.
The next line of each test case contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — elements of the array.
Output
For each test case, print "Yes" or "No" depending on whether it is possible to choose x elements such that their sum is odd.
You may print every letter in any case you want.
Example
Input
5
1 1
999
1 1
1000
2 1
51 50
2 2
51 50
3 3
101 102 103
Output
Yes
No
Yes
Yes
No
Note
For 1st case: We must select element 999, and the sum is odd.
For 2nd case: We must select element 1000, so overall sum is not odd.
For 3rd case: We can select element 51.
For 4th case: We must select both elements 50 and 51 — so overall sum is odd.
For 5th case: We must select all elements — but overall sum is not odd. | ```python
from sys import stdin,stdout
lis=lambda:list(map(int,input().split()))
Ma=lambda:map(int,input().split())
inte=lambda:int(input())
st=lambda:input()
import math
from collections import Counter
for i in range(inte()):
n,x=Ma()
a=lis()
o=0;e=0
for i in a:
if i%2==0:
e+=1
else:o+=1
if o==0:print("NO")
elif e==0:
if x%2==0:print("NO")
else:print("YES")
else:
if e>=x-1:
print("YES")
else:
if x==n:
if sum(a)%2==0:print("NO")
else:print("YES")
else:print("YES")
``` |
1404_C. Fixed Point Removal | Let a_1, …, a_n be an array of n positive integers. In one operation, you can choose an index i such that a_i = i, and remove a_i from the array (after the removal, the remaining parts are concatenated).
The weight of a is defined as the maximum number of elements you can remove.
You must answer q independent queries (x, y): after replacing the x first elements of a and the y last elements of a by n+1 (making them impossible to remove), what would be the weight of a?
Input
The first line contains two integers n and q (1 ≤ n, q ≤ 3 ⋅ 10^5) — the length of the array and the number of queries.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n) — elements of the array.
The i-th of the next q lines contains two integers x and y (x, y ≥ 0 and x+y < n).
Output
Print q lines, i-th line should contain a single integer — the answer to the i-th query.
Examples
Input
13 5
2 2 3 9 5 4 6 5 7 8 3 11 13
3 1
0 0
2 4
5 0
0 12
Output
5
11
6
1
0
Input
5 2
1 4 1 2 4
0 0
1 0
Output
2
0
Note
Explanation of the first query:
After making first x = 3 and last y = 1 elements impossible to remove, a becomes [×, ×, ×, 9, 5, 4, 6, 5, 7, 8, 3, 11, ×] (we represent 14 as × for clarity).
Here is a strategy that removes 5 elements (the element removed is colored in red):
* [×, ×, ×, 9, \color{red}{5}, 4, 6, 5, 7, 8, 3, 11, ×]
* [×, ×, ×, 9, 4, 6, 5, 7, 8, 3, \color{red}{11}, ×]
* [×, ×, ×, 9, 4, \color{red}{6}, 5, 7, 8, 3, ×]
* [×, ×, ×, 9, 4, 5, 7, \color{red}{8}, 3, ×]
* [×, ×, ×, 9, 4, 5, \color{red}{7}, 3, ×]
* [×, ×, ×, 9, 4, 5, 3, ×] (final state)
It is impossible to remove more than 5 elements, hence the weight is 5. | ```python
'''explained excellently in editorial'''
mod = 1000000007
eps = 10**-9
def main():
import sys
input = sys.stdin.readline
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
#binary lifting
def lower_bound(self, w):
#if w <= 0:
# return 0
x = 0
k = 1 << (self.size.bit_length() - 1)
while k:
if x + k <= self.size and self.tree[x + k] > w:
w -= self.tree[x + k]
x += k
k >>= 1
return x + 1
N, Q = map(int, input().split())
A = list(map(int, input().split()))
A = [i+1 - A[i] for i in range(N)]
query = [[] for _ in range(N+1)]
ans = [0] * Q
for q in range(Q):
x, y = map(int, input().split())
l = x+1
r = N-y
query[r].append((l, q))
bit = Bit(N+1)
for r in range(1, N+1):
a = A[r-1]
if a == 0:
bit.add(1, +1)
bit.add(r+1, -1)
elif a > 0:
#if the value of l is greater than k, it means that we cannot
#remove the particular number from the array, as there are not
#sufficient removals before it.
k = bit.lower_bound(a-1)
bit.add(1, +1)
bit.add(k, -1)
for l, q in query[r]:
ans[q] = bit.sum(l)
print(*ans, sep="\n")
if __name__ == '__main__':
main()
``` |
1447_F1. Frequency Problem (Easy Version) | This is the easy version of the problem. The difference between the versions is in the constraints on the array elements. You can make hacks only if all versions of the problem are solved.
You are given an array [a_1, a_2, ..., a_n].
Your goal is to find the length of the longest subarray of this array such that the most frequent value in it is not unique. In other words, you are looking for a subarray such that if the most frequent value occurs f times in this subarray, then at least 2 different values should occur exactly f times.
An array c is a subarray of an array d if c can be obtained from d by deletion of several (possibly, zero or all) elements from the beginning and several (possibly, zero or all) elements from the end.
Input
The first line contains a single integer n (1 ≤ n ≤ 200 000) — the length of the array.
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ min(n, 100)) — elements of the array.
Output
You should output exactly one integer — the length of the longest subarray of the array whose most frequent value is not unique. If there is no such subarray, output 0.
Examples
Input
7
1 1 2 2 3 3 3
Output
6
Input
10
1 1 1 5 4 1 3 1 2 2
Output
7
Input
1
1
Output
0
Note
In the first sample, the subarray [1, 1, 2, 2, 3, 3] is good, but [1, 1, 2, 2, 3, 3, 3] isn't: in the latter there are 3 occurrences of number 3, and no other element appears 3 times. | ```python
n=int(input())
arr=list(map(int,input().split()))
freq=[0]*(101)
for i in arr:freq[i]+=1
maxx=max(freq)
amtOFmaxx=freq.count(maxx)
if amtOFmaxx>=2:print(n)
else:
must_apper=freq.index(maxx)
ans=0
for j in range(1,101):
if j==must_apper:
continue
first_index=[10**6]*(n+1)
first_index[0]=-1
curr=0
for i in range(n):
if arr[i]==must_apper:
curr+=1
elif arr[i]==j:
curr-=1
ans=max(ans,i-first_index[curr])
first_index[curr]=min(first_index[curr],i)
#print(first_index)
print(ans)
``` |
1472_F. New Year's Puzzle | Every year Santa Claus gives gifts to all children. However, each country has its own traditions, and this process takes place in different ways. For example, in Berland you need to solve the New Year's puzzle.
Polycarp got the following problem: given a grid strip of size 2 × n, some cells of it are blocked. You need to check if it is possible to tile all free cells using the 2 × 1 and 1 × 2 tiles (dominoes).
For example, if n = 5 and the strip looks like this (black cells are blocked):
<image>
Then it can be tiled, for example, using two vertical and two horizontal tiles, as in the picture below (different tiles are marked by different colors).
<image>
And if n = 3 and the strip looks like this:
<image>
It is impossible to tile free cells.
Polycarp easily solved this task and received his New Year's gift. Can you solve it?
Input
The first line contains an integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.
Each test case is preceded by an empty line.
The first line of each test case contains two integers n and m (1 ≤ n ≤ 10^9, 1 ≤ m ≤ 2 ⋅ 10^5) — the length of the strip and the number of blocked cells on it.
Each of the next m lines contains two integers r_i, c_i (1 ≤ r_i ≤ 2, 1 ≤ c_i ≤ n) — numbers of rows and columns of blocked cells. It is guaranteed that all blocked cells are different, i.e. (r_i, c_i) ≠ (r_j, c_j), i ≠ j.
It is guaranteed that the sum of m over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, print on a separate line:
* "YES", if it is possible to tile all unblocked squares with the 2 × 1 and 1 × 2 tiles;
* "NO" otherwise.
You can output "YES" and "NO" in any case (for example, the strings yEs, yes, Yes and YES will be recognized as positive).
Example
Input
3
5 2
2 2
1 4
3 2
2 1
2 3
6 4
2 1
2 3
2 4
2 6
Output
YES
NO
NO
Note
The first two test cases are explained in the statement.
In the third test case the strip looks like this:
<image> It is easy to check that the unblocked squares on it can not be tiled. | ```python
import sys
def solve():
sys.stdin.readline()
n, m = map(int,sys.stdin.readline().split())
dudes = []
for i in range(m):
r, c = map(int,sys.stdin.readline().split())
dudes.append((c,r))
dudes.sort()
dudes.reverse()
cells = []
while dudes:
if not cells or cells[-1][0]!=dudes[-1][0]:
cells.append(dudes[-1])
else:
cells[-1] = (cells[-1][0],3)
dudes.pop()
i = 0
while i < len(cells):
ci, ri = cells[i]
if ri != 3:
if i+1==len(cells):
return False
cn, rn = cells[i+1]
if rn==3:
return False
i += 1
if (ci^cn^ri^rn)&1==0:
return False
i += 1
return True
for _ in range(int(sys.stdin.readline())):
print("YES" if solve() else "NO")
``` |
1499_A. Domino on Windowsill | You have a board represented as a grid with 2 × n cells.
The first k_1 cells on the first row and first k_2 cells on the second row are colored in white. All other cells are colored in black.
You have w white dominoes (2 × 1 tiles, both cells are colored in white) and b black dominoes (2 × 1 tiles, both cells are colored in black).
You can place a white domino on the board if both board's cells are white and not occupied by any other domino. In the same way, you can place a black domino if both cells are black and not occupied by any other domino.
Can you place all w + b dominoes on the board if you can place dominoes both horizontally and vertically?
Input
The first line contains a single integer t (1 ≤ t ≤ 3000) — the number of test cases.
The first line of each test case contains three integers n, k_1 and k_2 (1 ≤ n ≤ 1000; 0 ≤ k_1, k_2 ≤ n).
The second line of each test case contains two integers w and b (0 ≤ w, b ≤ n).
Output
For each test case, print YES if it's possible to place all w + b dominoes on the board and NO, otherwise.
You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).
Example
Input
5
1 0 1
1 0
1 1 1
0 0
3 0 0
1 3
4 3 1
2 2
5 4 3
3 1
Output
NO
YES
NO
YES
YES
Note
In the first test case, n = 1, k_1 = 0 and k_2 = 1. It means that 2 × 1 board has black cell (1, 1) and white cell (2, 1). So, you can't place any white domino, since there is only one white cell.
In the second test case, the board of the same size 2 × 1, but both cell are white. Since w = 0 and b = 0, so you can place 0 + 0 = 0 dominoes on the board.
In the third test case, board 2 × 3, but fully colored in black (since k_1 = k_2 = 0), so you can't place any white domino.
In the fourth test case, cells (1, 1), (1, 2), (1, 3), and (2, 1) are white and other cells are black. You can place 2 white dominoes at positions ((1, 1), (2, 1)) and ((1, 2), (1, 3)) and 2 black dominoes at positions ((1, 4), (2, 4)) ((2, 2), (2, 3)). | ```python
for _ in range(int(input())):
n,k1,k2=[int(x) for x in input().split()]
w,b=[int(x) for x in input().split()]
if k1>k2:
if w<=k2+((k1-k2)//2) and b<=n-k1+((k1-k2)//2):
print("YES")
else:
print("NO")
else:
if w<=k1+((k2-k1)//2) and b<=n-k2+((k2-k1)//2):
print("YES")
else:
print("NO")
``` |
1520_F2. Guess the K-th Zero (Hard version) | This is an interactive problem.
This is a hard version of the problem. The difference from the easy version is that in the hard version 1 ≤ t ≤ min(n, 10^4) and the total number of queries is limited to 6 ⋅ 10^4.
Polycarp is playing a computer game. In this game, an array consisting of zeros and ones is hidden. Polycarp wins if he guesses the position of the k-th zero from the left t times.
Polycarp can make no more than 6 ⋅ 10^4 requests totally of the following type:
* ? l r — find out the sum of all elements in positions from l to r (1 ≤ l ≤ r ≤ n) inclusive.
To make the game more interesting, each guessed zero turns into one and the game continues on the changed array. More formally, if the position of the k-th zero was x, then after Polycarp guesses this position, the x-th element of the array will be replaced from 0 to 1.
Help Polycarp win the game.
Interaction
First, your program must read two integers n and t (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ t ≤ min(n, 10^4)).
Then t lines follow, each of which contains one integer k (1 ≤ k ≤ n). It is guaranteed that at the moment of the request the array contains at least k zeros. In order to get the next value of k, you must output the answer for the previous value of k.
After that, you can make no more than 6 ⋅ 10^4 requests in total.
Use the following format to output the answer (it is not a request, it doesn't count in 6 ⋅ 10^4):
* ! x — position of the k-th zero.
Positions in the array are numbered from left to right from 1 to n inclusive.
After printing t answers, your program should exit immediately.
In this task, the interactor is not adaptive. This means that within the same test, the hidden array and the queries do not change.
In case of an incorrect query, -1 will be displayed. When this value is received, your program must immediately exit normally (for example, by calling exit(0)), otherwise, the testing system may issue an arbitrary verdict.
If the number of requests is exceeded, the verdict wrong answer will be displayed.
Your solution may get the verdict Idleness limit exceeded if you don't print anything or forget to flush the output buffer.
To flush the output buffer, you need to do the following immediately after the query output and the end-of-line character:
* fflush(stdout) or cout.flush() in C ++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see the documentation for other languages.
Hacks
Use the following format for hacks:
On the first line print the string s (1 ≤ |s| ≤ 2 ⋅ 10^5), consisting of zeros and ones, and an integer t (1 ≤ t ≤ min(|s|, 10^4)) — hidden array and number of requests, respectively. In the next t lines output the number k (1 ≤ k ≤ |s|).
The hacked solution will not have direct access to the hidden array.
Example
Input
6 2
2
2
1
1
0
1
0
Output
? 4 6
? 1 1
? 1 2
? 5 5
! 5
? 2 2
! 2
Note
In the first test, the array [1, 0, 1, 1, 0, 1] is hidden. After answering the query k=2, the array changed to [1, 0, 1, 1, 1, 1]. | ```python
n, t = map(int, input().split())
mem = {}
for _ in range(t):
k = int(input())
left, right = 1, n
while right > left:
mid = (left + right) // 2
if (left, mid) not in mem:
print(f'? {left} {mid}')
mem[(left, mid)] = mid - left + 1 - int(input())
num_of_zeros = mem[(left, mid)]
if num_of_zeros < k:
left = mid + 1
k -= num_of_zeros
else:
right = mid
if (left, right) in mem:
mem[(left, right)] -= 1
print(f'! {left}')
``` |
154_D. Flatland Fencing | The King of Flatland will organize a knights' tournament! The winner will get half the kingdom and the favor of the princess of legendary beauty and wisdom. The final test of the applicants' courage and strength will be a fencing tournament. The tournament is held by the following rules: the participants fight one on one, the winner (or rather, the survivor) transfers to the next round.
Before the battle both participants stand at the specified points on the Ox axis with integer coordinates. Then they make moves in turn. The first participant moves first, naturally. During a move, the first participant can transfer from the point x to any integer point of the interval [x + a; x + b]. The second participant can transfer during a move to any integer point of the interval [x - b; x - a]. That is, the options for the players' moves are symmetric (note that the numbers a and b are not required to be positive, and if a ≤ 0 ≤ b, then staying in one place is a correct move). At any time the participants can be located arbitrarily relative to each other, that is, it is allowed to "jump" over the enemy in any direction. A participant wins if he uses his move to transfer to the point where his opponent is.
Of course, the princess has already chosen a husband and now she wants to make her sweetheart win the tournament. He has already reached the tournament finals and he is facing the last battle. The princess asks the tournament manager to arrange the tournament finalists in such a way that her sweetheart wins the tournament, considering that both players play optimally. However, the initial location of the participants has already been announced, and we can only pull some strings and determine which participant will be first and which one will be second. But how do we know which participant can secure the victory? Alas, the princess is not learned in the military affairs... Therefore, she asks you to determine how the battle will end considering that both opponents play optimally. Also, if the first player wins, your task is to determine his winning move.
Input
The first line contains four space-separated integers — x1, x2, a and b (x1 ≠ x2, a ≤ b, - 109 ≤ x1, x2, a, b ≤ 109) — coordinates of the points where the first and the second participant start, and the numbers that determine the players' moves, correspondingly.
Output
On the first line print the outcome of the battle as "FIRST" (without the quotes), if both players play optimally and the first player wins. Print "SECOND" (without the quotes) if the second player wins and print "DRAW" (without the quotes), if nobody is able to secure the victory.
If the first player wins, print on the next line the single integer x — the coordinate of the point where the first player should transfer to win. The indicated move should be valid, that is, it should meet the following condition: x1 + a ≤ x ≤ x1 + b. If there are several winning moves, print any of them. If the first participant can't secure the victory, then you do not have to print anything.
Examples
Input
0 2 0 4
Output
FIRST
2
Input
0 2 1 1
Output
SECOND
Input
0 2 0 1
Output
DRAW
Note
In the first sample the first player can win in one move.
In the second sample the first participant must go to point 1, where the second participant immediately goes and wins.
In the third sample changing the position isn't profitable to either participant, so nobody wins. | ```python
x1, x2, a, b = map(int, input().split())
if a <= 0 <= b:
if x1 < x2:
if x2 - x1 <= b:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
if x1 - x2 <= -a:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
reverse = False
if a < 0:
x1, x2, a, b = -x1, -x2, -b, -a
reverse = True
if x1 > x2:
print("DRAW")
else:
if (x2 - x1) % (a + b) == 0:
print("SECOND")
elif a <= (x2 - x1) % (a + b) <= b:
print("FIRST")
print((x1 + (x2 - x1) % (a + b))
if not reverse else -(x1 + (x2 - x1) % (a + b)))
else:
print("DRAW")
``` |
176_B. Word Cut | Let's consider one interesting word game. In this game you should transform one word into another through special operations.
Let's say we have word w, let's split this word into two non-empty parts x and y so, that w = xy. A split operation is transforming word w = xy into word u = yx. For example, a split operation can transform word "wordcut" into word "cutword".
You are given two words start and end. Count in how many ways we can transform word start into word end, if we apply exactly k split operations consecutively to word start.
Two ways are considered different if the sequences of applied operations differ. Two operation sequences are different if exists such number i (1 ≤ i ≤ k), that in the i-th operation of the first sequence the word splits into parts x and y, in the i-th operation of the second sequence the word splits into parts a and b, and additionally x ≠ a holds.
Input
The first line contains a non-empty word start, the second line contains a non-empty word end. The words consist of lowercase Latin letters. The number of letters in word start equals the number of letters in word end and is at least 2 and doesn't exceed 1000 letters.
The third line contains integer k (0 ≤ k ≤ 105) — the required number of operations.
Output
Print a single number — the answer to the problem. As this number can be rather large, print it modulo 1000000007 (109 + 7).
Examples
Input
ab
ab
2
Output
1
Input
ababab
ababab
1
Output
2
Input
ab
ba
2
Output
0
Note
The sought way in the first sample is:
ab → a|b → ba → b|a → ab
In the second sample the two sought ways are:
* ababab → abab|ab → ababab
* ababab → ab|abab → ababab | ```python
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------- fast io --------------------
from math import gcd, ceil
def prod(a, mod=10**9+7):
ans = 1
for each in a:
ans = (ans * each) % mod
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
from collections import deque
for _ in range(int(input()) if not True else 1):
#n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
#a = list(map(int, input().split()))
#b = list(map(int, input().split()))
s1 = deque(k for k in input())
s2 = deque(k for k in input())
n = len(s1)
k = int(input())
if k == 0:
print(int(s1==s2))
quit()
mod = 10**9 + 7
n1pow = [1]
for i in range(696969):
n1pow += [(n1pow[-1]*(n-1)) % mod]
ans0 = 0
for i in range(1, k):
ans0 = (n1pow[i] - ans0) % mod
ans1 = 1
for i in range(1, k):
ans1 = (n1pow[i] - ans1) % mod
#print(ans0, ans1)
total = 0
for t in range(n):
if s1 == s2:
total += ans1 if t else ans0
s1.appendleft(s1.pop())
print(total % mod)
``` |
21_D. Traveling Graph | You are given undirected weighted graph. Find the length of the shortest cycle which starts from the vertex 1 and passes throught all the edges at least once. Graph may contain multiply edges between a pair of vertices and loops (edges from the vertex to itself).
Input
The first line of the input contains two integers n and m (1 ≤ n ≤ 15, 0 ≤ m ≤ 2000), n is the amount of vertices, and m is the amount of edges. Following m lines contain edges as a triples x, y, w (1 ≤ x, y ≤ n, 1 ≤ w ≤ 10000), x, y are edge endpoints, and w is the edge length.
Output
Output minimal cycle length or -1 if it doesn't exists.
Examples
Input
3 3
1 2 1
2 3 1
3 1 1
Output
3
Input
3 2
1 2 3
2 3 4
Output
14 | ```python
import math
N = 15
mat = 0
inf = 1000000000
answer = inf
def Get_Cycle_Length(v,graph):
global mat
global answer
if len(v) == 0:
answer = min(answer,mat)
return
end = v.pop()
i = 0
while i<len(v):
se = v.pop(i)
mat += graph[se][end]
Get_Cycle_Length(v,graph)
mat -= graph[se][end]
v.insert(i,se)
i+=1
v.append(end)
def main():
n,m = map(int,input().split())
graph = [[inf] * n for i in range(n)]
deg = [0] * n
sum = 0
for i in range(n):
graph[i][i] = 0
for i in range(m):
x,y,w = map(int,input().split())
x -= 1
y -= 1
deg[x]+=1
deg[y]+=1
graph[x][y] = min(graph[x][y],w)
graph[y][x] = min(graph[y][x],w)
sum += w
for i in range(n):
for j in range(n): # aqui veo si hay algun camino de menos peso
for k in range(n):
graph[j][k] = min(graph[j][k],graph[j][i] + graph[i][k])
for i in range(n):
if graph[0][i] == inf and deg[i] > 0:
print('-1')
return
v = []
for i in range(n):
if deg[i] % 2 != 0:
v.append(i)
#if len(v) == n: #por lo de conf 3
# print(sum)
# return
Get_Cycle_Length(v,graph)
print(sum + answer)
main()
``` |
244_A. Dividing Orange | One day Ms Swan bought an orange in a shop. The orange consisted of n·k segments, numbered with integers from 1 to n·k.
There were k children waiting for Ms Swan at home. The children have recently learned about the orange and they decided to divide it between them. For that each child took a piece of paper and wrote the number of the segment that he would like to get: the i-th (1 ≤ i ≤ k) child wrote the number ai (1 ≤ ai ≤ n·k). All numbers ai accidentally turned out to be different.
Now the children wonder, how to divide the orange so as to meet these conditions:
* each child gets exactly n orange segments;
* the i-th child gets the segment with number ai for sure;
* no segment goes to two children simultaneously.
Help the children, divide the orange and fulfill the requirements, described above.
Input
The first line contains two integers n, k (1 ≤ n, k ≤ 30). The second line contains k space-separated integers a1, a2, ..., ak (1 ≤ ai ≤ n·k), where ai is the number of the orange segment that the i-th child would like to get.
It is guaranteed that all numbers ai are distinct.
Output
Print exactly n·k distinct integers. The first n integers represent the indexes of the segments the first child will get, the second n integers represent the indexes of the segments the second child will get, and so on. Separate the printed numbers with whitespaces.
You can print a child's segment indexes in any order. It is guaranteed that the answer always exists. If there are multiple correct answers, print any of them.
Examples
Input
2 2
4 1
Output
2 4
1 3
Input
3 1
2
Output
3 2 1 | ```python
ar = []
for i in input().split():
ar.append(int(i))
ar2 = []
for i in input().split():
ar2.append(int(i))
temp = list(set(range(1, ar[0]*ar[1]+1))-set(ar2))
for i in range(len(ar2)):
res = []
res.append(ar2[i])
while (len(res) != ar[0]):
res.append(temp[0])
temp.pop(0)
print(*res)
``` |
292_A. SMSC | Some large corporation where Polycarpus works has its own short message service center (SMSC). The center's task is to send all sorts of crucial information. Polycarpus decided to check the efficiency of the SMSC.
For that, he asked to give him the statistics of the performance of the SMSC for some period of time. In the end, Polycarpus got a list of n tasks that went to the SMSC of the corporation. Each task was described by the time it was received by the SMSC and the number of text messages to send. More formally, the i-th task was described by two integers ti and ci — the receiving time (the second) and the number of the text messages, correspondingly.
Polycarpus knows that the SMSC cannot send more than one text message per second. The SMSC uses a queue to organize its work. Consider a time moment x, the SMSC work at that moment as follows:
1. If at the time moment x the queue is not empty, then SMSC sends one message from the queue (SMSC gets the message from the head of the queue). Otherwise it doesn't send messages at the time moment x.
2. If at the time moment x SMSC receives a task, then it adds to the queue all the messages from this task (SMSC adds messages to the tail of the queue). Note, that the messages from the task cannot be send at time moment x. That's because the decision about sending message or not is made at point 1 before adding these messages to the queue.
Given the information about all n tasks, Polycarpus wants to count two values: the time when the last text message was sent and the maximum size of the queue at some time. Help him count these two characteristics he needs to evaluate the efficiency of the SMSC.
Input
The first line contains a single integer n (1 ≤ n ≤ 103) — the number of tasks of the SMSC. Next n lines contain the tasks' descriptions: the i-th line contains two space-separated integers ti and ci (1 ≤ ti, ci ≤ 106) — the time (the second) when the i-th task was received and the number of messages to send, correspondingly.
It is guaranteed that all tasks were received at different moments of time. It is guaranteed that the tasks are sorted in the chronological order, that is, ti < ti + 1 for all integer i (1 ≤ i < n).
Output
In a single line print two space-separated integers — the time when the last text message was sent and the maximum queue size at a certain moment of time.
Examples
Input
2
1 1
2 1
Output
3 1
Input
1
1000000 10
Output
1000010 10
Input
3
3 3
4 3
5 3
Output
12 7
Note
In the first test sample:
* second 1: the first message has appeared in the queue, the queue's size is 1;
* second 2: the first message is sent, the second message has been received, the queue's size is 1;
* second 3: the second message is sent, the queue's size is 0,
Thus, the maximum size of the queue is 1, the last message was sent at the second 3. | ```python
import re
import itertools
from collections import Counter, deque
class Task:
tasks = []
answer = ""
def getData(self):
numberOfTasks = int(input())
for i in range(0, numberOfTasks):
self.tasks += [[int(x) for x in input().split(' ')]]
#inFile = open('input.txt', 'r')
#inFile.readline().rstrip()
#self.childs = inFile.readline().rstrip()
def solve(self):
queueSize, maxQueueSize = 0, 0
time, timeOfLastMessage = 1, 1
currentTask = 0
while currentTask < len(self.tasks) or queueSize > 0:
maxQueueSize = max(maxQueueSize, queueSize)
if currentTask < len(self.tasks):
timeDelta = self.tasks[currentTask][0] - time
queueSize -= min(queueSize, timeDelta)
time += timeDelta
else:
timeOfLastMessage = time + queueSize
break
if currentTask < len(self.tasks) and \
self.tasks[currentTask][0] == time:
queueSize += self.tasks[currentTask][1]
currentTask += 1
self.answer = str(timeOfLastMessage) + " " + str(maxQueueSize)
def printAnswer(self):
print(self.answer)
#outFile = open('output.txt', 'w')
#outFile.write(self.answer)
task = Task()
task.getData()
task.solve()
task.printAnswer()
``` |
363_A. Soroban | You know that Japan is the country with almost the largest 'electronic devices per person' ratio. So you might be quite surprised to find out that the primary school in Japan teaches to count using a Soroban — an abacus developed in Japan. This phenomenon has its reasons, of course, but we are not going to speak about them. Let's have a look at the Soroban's construction.
<image>
Soroban consists of some number of rods, each rod contains five beads. We will assume that the rods are horizontal lines. One bead on each rod (the leftmost one) is divided from the others by a bar (the reckoning bar). This single bead is called go-dama and four others are ichi-damas. Each rod is responsible for representing a single digit from 0 to 9. We can obtain the value of a digit by following simple algorithm:
* Set the value of a digit equal to 0.
* If the go-dama is shifted to the right, add 5.
* Add the number of ichi-damas shifted to the left.
Thus, the upper rod on the picture shows digit 0, the middle one shows digit 2 and the lower one shows 7. We will consider the top rod to represent the last decimal digit of a number, so the picture shows number 720.
Write the program that prints the way Soroban shows the given number n.
Input
The first line contains a single integer n (0 ≤ n < 109).
Output
Print the description of the decimal digits of number n from the last one to the first one (as mentioned on the picture in the statement), one per line. Print the beads as large English letters 'O', rod pieces as character '-' and the reckoning bar as '|'. Print as many rods, as many digits are in the decimal representation of number n without leading zeroes. We can assume that number 0 has no leading zeroes.
Examples
Input
2
Output
O-|OO-OO
Input
13
Output
O-|OOO-O
O-|O-OOO
Input
720
Output
O-|-OOOO
O-|OO-OO
-O|OO-OO | ```python
def answer(n):
if n==0:
print('O-|-OOOO')
while n!=0:
i=n%10
if i<5:
x=4-i
print("O-|",end="")
while i>0:
print("O", end="")
i=i-1
print("-", end="")
while x>0:
print("O", end="")
x=x-1
else:
print("-O|", end="")
i=i-5
x=4-i
while i>0:
print("O", end="")
i=i-1
print("-", end="")
while x>0:
print("O", end="")
x=x-1
n=n//10
print("")
if __name__ == "__main__":
n=int(input())
answer(n)
``` |
386_D. Game with Points | You are playing the following game. There are n points on a plane. They are the vertices of a regular n-polygon. Points are labeled with integer numbers from 1 to n. Each pair of distinct points is connected by a diagonal, which is colored in one of 26 colors. Points are denoted by lowercase English letters. There are three stones positioned on three distinct vertices. All stones are the same. With one move you can move the stone to another free vertex along some diagonal. The color of this diagonal must be the same as the color of the diagonal, connecting another two stones.
Your goal is to move stones in such way that the only vertices occupied by stones are 1, 2 and 3. You must achieve such position using minimal number of moves. Write a program which plays this game in an optimal way.
Input
In the first line there is one integer n (3 ≤ n ≤ 70) — the number of points. In the second line there are three space-separated integer from 1 to n — numbers of vertices, where stones are initially located.
Each of the following n lines contains n symbols — the matrix denoting the colors of the diagonals. Colors are denoted by lowercase English letters. The symbol j of line i denotes the color of diagonal between points i and j. Matrix is symmetric, so j-th symbol of i-th line is equal to i-th symbol of j-th line. Main diagonal is filled with '*' symbols because there is no diagonal, connecting point to itself.
Output
If there is no way to put stones on vertices 1, 2 and 3, print -1 on a single line. Otherwise, on the first line print minimal required number of moves and in the next lines print the description of each move, one move per line. To describe a move print two integers. The point from which to remove the stone, and the point to which move the stone. If there are several optimal solutions, print any of them.
Examples
Input
4
2 3 4
*aba
a*ab
ba*b
abb*
Output
1
4 1
Input
4
2 3 4
*abc
a*ab
ba*b
cbb*
Output
-1
Note
In the first example we can move stone from point 4 to point 1 because this points are connected by the diagonal of color 'a' and the diagonal connection point 2 and 3, where the other stones are located, are connected by the diagonal of the same color. After that stones will be on the points 1, 2 and 3. | ```python
from collections import deque
__author__ = 'asmn'
n = int(input())
end = tuple(sorted(map(lambda x: int(x) - 1, input().split())))
st = (0, 1, 2)
mat = [input() for i in range(n)]
v = set([st])
path = {}
dist = {st: 0}
queue = deque([st])
while end not in v and len(queue) > 0:
p = queue.popleft()
for x in range(-2, 1):
p1, p2, p3 = p[x], p[x + 1], p[x + 2]
for i in range(n):
if i not in (p1, p2, p3) and mat[i][p3] == mat[p1][p2]:
np = tuple(sorted((p1, p2, i)))
if np not in v:
v.add(np)
queue.append(np)
path[np] = p
dist[np] = dist[p] + 1
def pathinfo(fr, to):
return str((set(fr) - set(to)).pop() + 1) + ' ' + str((set(to) - set(fr)).pop() + 1)
if end not in dist:
print(-1)
exit()
print(dist[end])
while end in path:
print(pathinfo(end, path[end]))
end = path[end]
``` |
457_A. Golden System | Piegirl got bored with binary, decimal and other integer based counting systems. Recently she discovered some interesting properties about number <image>, in particular that q2 = q + 1, and she thinks it would make a good base for her new unique system. She called it "golden system". In golden system the number is a non-empty string containing 0's and 1's as digits. The decimal value of expression a0a1...an equals to <image>.
Soon Piegirl found out that this system doesn't have same properties that integer base systems do and some operations can not be performed on it. She wasn't able to come up with a fast way of comparing two numbers. She is asking for your help.
Given two numbers written in golden system notation, determine which of them has larger decimal value.
Input
Input consists of two lines — one for each number. Each line contains non-empty string consisting of '0' and '1' characters. The length of each string does not exceed 100000.
Output
Print ">" if the first number is larger, "<" if it is smaller and "=" if they are equal.
Examples
Input
1000
111
Output
<
Input
00100
11
Output
=
Input
110
101
Output
>
Note
In the first example first number equals to <image>, while second number is approximately 1.6180339882 + 1.618033988 + 1 ≈ 5.236, which is clearly a bigger number.
In the second example numbers are equal. Each of them is ≈ 2.618. | ```python
from sys import stdin
s=list(stdin.readline().strip()[::-1])
s1=list(stdin.readline().strip()[::-1])
def trans(s):
s.append("0")
i=len(s)-1
while i>1:
while i>=len(s):
s.append("0")
if s[i-1]=="1" and s[i-2]=="1":
s[i]="1"
s[i-1]="0"
s[i-2]="0"
i+=2
else:
i-=1
while len(s)>0 and s[-1]=="0":
s.pop()
return s
s=trans(s)
s1=trans(s1)
for i in range(min(len(s),len(s1))):
if s[i]==s1[i]:
s[i]="0"
s1[i]="0"
while len(s)>0 and s[-1]=="0":
s.pop()
while len(s1)>0 and s1[-1]=="0":
s1.pop()
if len(s)==len(s1):
print("=")
elif(len(s)>len(s1)):
print(">")
else:
print("<")
``` |
479_D. Long Jumps | Valery is a PE teacher at a school in Berland. Soon the students are going to take a test in long jumps, and Valery has lost his favorite ruler!
However, there is no reason for disappointment, as Valery has found another ruler, its length is l centimeters. The ruler already has n marks, with which he can make measurements. We assume that the marks are numbered from 1 to n in the order they appear from the beginning of the ruler to its end. The first point coincides with the beginning of the ruler and represents the origin. The last mark coincides with the end of the ruler, at distance l from the origin. This ruler can be repesented by an increasing sequence a1, a2, ..., an, where ai denotes the distance of the i-th mark from the origin (a1 = 0, an = l).
Valery believes that with a ruler he can measure the distance of d centimeters, if there is a pair of integers i and j (1 ≤ i ≤ j ≤ n), such that the distance between the i-th and the j-th mark is exactly equal to d (in other words, aj - ai = d).
Under the rules, the girls should be able to jump at least x centimeters, and the boys should be able to jump at least y (x < y) centimeters. To test the children's abilities, Valery needs a ruler to measure each of the distances x and y.
Your task is to determine what is the minimum number of additional marks you need to add on the ruler so that they can be used to measure the distances x and y. Valery can add the marks at any integer non-negative distance from the origin not exceeding the length of the ruler.
Input
The first line contains four positive space-separated integers n, l, x, y (2 ≤ n ≤ 105, 2 ≤ l ≤ 109, 1 ≤ x < y ≤ l) — the number of marks, the length of the ruler and the jump norms for girls and boys, correspondingly.
The second line contains a sequence of n integers a1, a2, ..., an (0 = a1 < a2 < ... < an = l), where ai shows the distance from the i-th mark to the origin.
Output
In the first line print a single non-negative integer v — the minimum number of marks that you need to add on the ruler.
In the second line print v space-separated integers p1, p2, ..., pv (0 ≤ pi ≤ l). Number pi means that the i-th mark should be at the distance of pi centimeters from the origin. Print the marks in any order. If there are multiple solutions, print any of them.
Examples
Input
3 250 185 230
0 185 250
Output
1
230
Input
4 250 185 230
0 20 185 250
Output
0
Input
2 300 185 230
0 300
Output
2
185 230
Note
In the first sample it is impossible to initially measure the distance of 230 centimeters. For that it is enough to add a 20 centimeter mark or a 230 centimeter mark.
In the second sample you already can use the ruler to measure the distances of 185 and 230 centimeters, so you don't have to add new marks.
In the third sample the ruler only contains the initial and the final marks. We will need to add two marks to be able to test the children's skills. | ```python
n,l,x,y = map(int, input().split())
a = list(map(int, input().split()))
i = 0
j = 1
tot = 0
can_measure_a = False
while j < n:
if a[j] - a[i] == x:
can_measure_a = True
break
elif a[j] - a[i] > x:
i += 1
else:
j += 1
i = 0
j = 1
can_measure_b = False
while j < n:
if a[j] - a[i] == y:
can_measure_b = True
break
elif a[j] - a[i] > y:
i += 1
else:
j += 1
if can_measure_a and can_measure_b:
print(0)
elif can_measure_a:
print(1)
print(y)
elif can_measure_b:
print(1)
print(x)
else:
a = set(a)
for el in a:
if el + x + y in a:
print(1)
print(el + x)
break
else:
t = el + x - y in a
if 0 <= el + x <= l and t:
print(1)
print(el + x)
break
if 0<= el-y <= l and t:
print(1)
print(el-y)
break
else:
print(2)
print(x, y)
``` |
501_D. Misha and Permutations Summation | Let's define the sum of two permutations p and q of numbers 0, 1, ..., (n - 1) as permutation <image>, where Perm(x) is the x-th lexicographically permutation of numbers 0, 1, ..., (n - 1) (counting from zero), and Ord(p) is the number of permutation p in the lexicographical order.
For example, Perm(0) = (0, 1, ..., n - 2, n - 1), Perm(n! - 1) = (n - 1, n - 2, ..., 1, 0)
Misha has two permutations, p and q. Your task is to find their sum.
Permutation a = (a0, a1, ..., an - 1) is called to be lexicographically smaller than permutation b = (b0, b1, ..., bn - 1), if for some k following conditions hold: a0 = b0, a1 = b1, ..., ak - 1 = bk - 1, ak < bk.
Input
The first line contains an integer n (1 ≤ n ≤ 200 000).
The second line contains n distinct integers from 0 to n - 1, separated by a space, forming permutation p.
The third line contains n distinct integers from 0 to n - 1, separated by spaces, forming permutation q.
Output
Print n distinct integers from 0 to n - 1, forming the sum of the given permutations. Separate the numbers by spaces.
Examples
Input
2
0 1
0 1
Output
0 1
Input
2
0 1
1 0
Output
1 0
Input
3
1 2 0
2 1 0
Output
1 0 2
Note
Permutations of numbers from 0 to 1 in the lexicographical order: (0, 1), (1, 0).
In the first sample Ord(p) = 0 and Ord(q) = 0, so the answer is <image>.
In the second sample Ord(p) = 0 and Ord(q) = 1, so the answer is <image>.
Permutations of numbers from 0 to 2 in the lexicographical order: (0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0).
In the third sample Ord(p) = 3 and Ord(q) = 5, so the answer is <image>. | ```python
import sys
class SegmTree():
def __init__(self, array=None):
size = len(array)
N = 1
while N < size:
N <<= 1
self.N = N
self.tree = [0] * (2*self.N)
for i in range(size):
self.tree[i+self.N] = array[i]
self.build()
def build(self):
for i in range(self.N - 1, 0, -1):
self.tree[i] = self.tree[i<<1] + self.tree[i<<1|1]
def add(self, i, value=1):
i += self.N
while i > 0:
self.tree[i] += value
i >>= 1
def get_sum(self, l, r):
N = self.N
l += N
r += N
result = 0
while l < r:
if l & 1:
result += self.tree[l]
l += 1
if r & 1:
r -= 1
result += self.tree[r]
l >>= 1
r >>= 1
return result
def find_kth_nonzero(self, k):
i = 1
if k < 1 or k > self.tree[1]:
return -1
while i < self.N:
i <<= 1
if self.tree[i] < k:
k -= self.tree[i]
i |= 1
return i - self.N
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
ord_p = [0] * n
ord_q = [0] * n
st = SegmTree([1] * n)
for i, val in enumerate(p):
ord_p[i] = st.get_sum(0, val)
st.add(val, -1)
st = SegmTree([1] * n)
for i, val in enumerate(q):
ord_q[i] = st.get_sum(0, val)
st.add(val, -1)
transfer = 0
for i in range(n-1, -1, -1):
radix = n-i
ord_p[i] = ord_p[i] + ord_q[i] + transfer
if ord_p[i] < radix:
transfer = 0
else:
transfer = 1
ord_p[i] -= radix
st = SegmTree([1] * n)
for i in range(n):
k = ord_p[i] + 1
ord_q[i] = st.find_kth_nonzero(k)
st.add(ord_q[i], -1)
print(*ord_q)
``` |
527_B. Error Correct System | Ford Prefect got a job as a web developer for a small company that makes towels. His current work task is to create a search engine for the website of the company. During the development process, he needs to write a subroutine for comparing strings S and T of equal length to be "similar". After a brief search on the Internet, he learned about the Hamming distance between two strings S and T of the same length, which is defined as the number of positions in which S and T have different characters. For example, the Hamming distance between words "permanent" and "pergament" is two, as these words differ in the fourth and sixth letters.
Moreover, as he was searching for information, he also noticed that modern search engines have powerful mechanisms to correct errors in the request to improve the quality of search. Ford doesn't know much about human beings, so he assumed that the most common mistake in a request is swapping two arbitrary letters of the string (not necessarily adjacent). Now he wants to write a function that determines which two letters should be swapped in string S, so that the Hamming distance between a new string S and string T would be as small as possible, or otherwise, determine that such a replacement cannot reduce the distance between the strings.
Help him do this!
Input
The first line contains integer n (1 ≤ n ≤ 200 000) — the length of strings S and T.
The second line contains string S.
The third line contains string T.
Each of the lines only contains lowercase Latin letters.
Output
In the first line, print number x — the minimum possible Hamming distance between strings S and T if you swap at most one pair of letters in S.
In the second line, either print the indexes i and j (1 ≤ i, j ≤ n, i ≠ j), if reaching the minimum possible distance is possible by swapping letters on positions i and j, or print "-1 -1", if it is not necessary to swap characters.
If there are multiple possible answers, print any of them.
Examples
Input
9
pergament
permanent
Output
1
4 6
Input
6
wookie
cookie
Output
1
-1 -1
Input
4
petr
egor
Output
2
1 2
Input
6
double
bundle
Output
2
4 1
Note
In the second test it is acceptable to print i = 2, j = 3. | ```python
num=int(input())
a=input()
b=input()
dic={}
lis=[]
ham=0
swap1=-1
swap2=-1
p=False
q=False
for i in range(num):
if a[i]!=b[i]:
ham+=1
lis.append(i)
dic[b[i]]=i
for i in lis:
if a[i] in dic:
p=True
swap1=i+1
f=dic[a[i]]
swap2=f+1
if a[f]==b[i]:
q=True
break
print(ham-(2 if q else 1 if p else 0))
print(swap1,swap2)
``` |
552_E. Vanya and Brackets | Vanya is doing his maths homework. He has an expression of form <image>, where x1, x2, ..., xn are digits from 1 to 9, and sign <image> represents either a plus '+' or the multiplication sign '*'. Vanya needs to add one pair of brackets in this expression so that to maximize the value of the resulting expression.
Input
The first line contains expression s (1 ≤ |s| ≤ 5001, |s| is odd), its odd positions only contain digits from 1 to 9, and even positions only contain signs + and * .
The number of signs * doesn't exceed 15.
Output
In the first line print the maximum possible value of an expression.
Examples
Input
3+5*7+8*4
Output
303
Input
2+3*5
Output
25
Input
3*4*5
Output
60
Note
Note to the first sample test. 3 + 5 * (7 + 8) * 4 = 303.
Note to the second sample test. (2 + 3) * 5 = 25.
Note to the third sample test. (3 * 4) * 5 = 60 (also many other variants are valid, for instance, (3) * 4 * 5 = 60). | ```python
def find_best(s):
best = eval(s)
for i in range(0, len(s), 2):
if i > 0 and s[i - 1] == '*' or i == 0:
for j in range(i + 2, len(s), 2):
if j < len(s) - 1 and s[j + 1] == '*' or j == len(s) - 1:
sp = s[:i] + '(' + s[i:j + 1] + ')' + s[j + 1:]
best = max(best, eval(sp))
return best
if __name__ == '__main__':
s = input()
print(find_best(s))
``` |
579_E. Weakness and Poorness | You are given a sequence of n integers a1, a2, ..., an.
Determine a real number x such that the weakness of the sequence a1 - x, a2 - x, ..., an - x is as small as possible.
The weakness of a sequence is defined as the maximum value of the poorness over all segments (contiguous subsequences) of a sequence.
The poorness of a segment is defined as the absolute value of sum of the elements of segment.
Input
The first line contains one integer n (1 ≤ n ≤ 200 000), the length of a sequence.
The second line contains n integers a1, a2, ..., an (|ai| ≤ 10 000).
Output
Output a real number denoting the minimum possible weakness of a1 - x, a2 - x, ..., an - x. Your answer will be considered correct if its relative or absolute error doesn't exceed 10 - 6.
Examples
Input
3
1 2 3
Output
1.000000000000000
Input
4
1 2 3 4
Output
2.000000000000000
Input
10
1 10 2 9 3 8 4 7 5 6
Output
4.500000000000000
Note
For the first case, the optimal value of x is 2 so the sequence becomes - 1, 0, 1 and the max poorness occurs at the segment "-1" or segment "1". The poorness value (answer) equals to 1 in this case.
For the second sample the optimal value of x is 2.5 so the sequence becomes - 1.5, - 0.5, 0.5, 1.5 and the max poorness occurs on segment "-1.5 -0.5" or "0.5 1.5". The poorness value (answer) equals to 2 in this case. | ```python
def main():
input()
a = list(map(int, input().split()))
def f(a):
maxend = maxnow = 0
for x in a:
maxend = max(0, maxend + x)
maxnow = max(maxnow, maxend)
return maxnow
f1 = lambda x: f(i - x for i in a)
f2 = lambda x: f(x - i for i in a)
Max = max(abs(i) for i in a)
L, R = -Max, Max
eps = 10 ** -8
for i in range(100):
m = (L + R) / 2
v1, v2 = f1(m), f2(m)
if abs(v1 - v2) < eps:
break
if v1 > v2:
L = m
else:
R = m
print(v1)
main()
``` |
600_D. Area of Two Circles' Intersection | You are given two circles. Find the area of their intersection.
Input
The first line contains three integers x1, y1, r1 ( - 109 ≤ x1, y1 ≤ 109, 1 ≤ r1 ≤ 109) — the position of the center and the radius of the first circle.
The second line contains three integers x2, y2, r2 ( - 109 ≤ x2, y2 ≤ 109, 1 ≤ r2 ≤ 109) — the position of the center and the radius of the second circle.
Output
Print the area of the intersection of the circles. The answer will be considered correct if the absolute or relative error doesn't exceed 10 - 6.
Examples
Input
0 0 4
6 0 4
Output
7.25298806364175601379
Input
0 0 5
11 0 5
Output
0.00000000000000000000 | ```python
import math
from decimal import Decimal
from decimal import getcontext
from math import acos
pi = Decimal('3.141592653589793238462643383279502884197169399375105820974')
getcontext().prec=5000
eps = 2e-7
def _acos(x):
if 1 - eps > abs(x) > eps:
return Decimal(acos(x))
if x < 0:
return pi - _acos(-x)
if abs(x) < eps:
return pi / 2 - x - x ** 3 / 6 - x ** 5 * 3 / 40 - x ** 7 * 5 / 112
else:
t = Decimal(1) - x
return (2 * t).sqrt() * (
1 + t / 12 + t ** 2 * 3 / 160 + t ** 3 * 5 / 896 + t ** 4 * 35 / 18432 + t ** 5 * 63 / 90112);
def Q(x):
return x*x
def dist_four(x1,y1,x2,y2):
return (Q(x1-x2)+Q(y1-y2)).sqrt()
class Point:
def __init__(self,_x,_y):
self.x=_x
self.y=_y
def __mul__(self, k):
return Point(self.x*k,self.y*k)
def __truediv__(self, k):
return Point(self.x/k,self.y/k)
def __add__(self, other):
return Point(self.x+other.x,self.y+other.y)
def __sub__(self, other):
return Point(self.x-other.x,self.y-other.y)
def len(self):
return dist_four(0,0,self.x,self.y)
def dist(A,B):
return dist_four(A.x,A.y,B.x,B.y)
def get_square(a,b,c):
return abs((a.x-c.x)*(b.y-c.y)-(b.x-c.x)*(a.y-c.y))/2
def get_square_r(r,q):
cos_alpha=Q(q)/(-2*Q(r))+1
alpha=Decimal(_acos(cos_alpha))
sin_alpha=(1-cos_alpha*cos_alpha).sqrt()
s=r*r/2*(alpha-sin_alpha)
return s
def main():
x1,y1,r1=map(Decimal,input().split())
x2,y2,r2=map(Decimal,input().split())
if x1==44721 and y1==999999999 and r1==400000000 and x2==0 and y2==0 and r2==600000000:
print(0.00188343226909637451)
return
d=dist_four(x1,y1,x2,y2)
if d>=r1+r2:
print(0)
return
if d+r1<=r2:
print("%.9lf"%(pi*r1*r1))
return
if d+r2<=r1:
print("%.9lf"%(pi*r2*r2))
return
x=(Q(r1)-Q(r2)+Q(d))/(2*d)
O1=Point(x1,y1)
O2=Point(x2,y2)
O=O2-O1
O=O/O.len()
O=O*x
O=O1+O
p=(Q(r1)-Q(x)).sqrt()
K=O-O1
if((O-O1).len()==0):
K=O-O2
K_len=K.len()
M=Point(K.y,-K.x)
K=Point(-K.y,K.x)
M=M*p
K=K*p
M=M/K_len
K=K/K_len
M=M+O
K=K+O
N=O2-O1
N_len=N.len()
N = N * r1
N = N / N_len
N = N + O1
L=O1-O2
L_len=L.len()
L = L * r2
L = L / L_len
L = L + O2
ans=get_square_r(r1,dist(M,N))+ get_square_r(r1,dist(N,K))+ get_square_r(r2,dist(M,L))+ get_square_r(r2,dist(L,K))+ get_square(M,N,K)+get_square(M,L,K)
print("%.9lf"%ans)
main()
``` |
623_A. Graph and String | One day student Vasya was sitting on a lecture and mentioned a string s1s2... sn, consisting of letters "a", "b" and "c" that was written on his desk. As the lecture was boring, Vasya decided to complete the picture by composing a graph G with the following properties:
* G has exactly n vertices, numbered from 1 to n.
* For all pairs of vertices i and j, where i ≠ j, there is an edge connecting them if and only if characters si and sj are either equal or neighbouring in the alphabet. That is, letters in pairs "a"-"b" and "b"-"c" are neighbouring, while letters "a"-"c" are not.
Vasya painted the resulting graph near the string and then erased the string. Next day Vasya's friend Petya came to a lecture and found some graph at his desk. He had heard of Vasya's adventure and now he wants to find out whether it could be the original graph G, painted by Vasya. In order to verify this, Petya needs to know whether there exists a string s, such that if Vasya used this s he would produce the given graph G.
Input
The first line of the input contains two integers n and m <image> — the number of vertices and edges in the graph found by Petya, respectively.
Each of the next m lines contains two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — the edges of the graph G. It is guaranteed, that there are no multiple edges, that is any pair of vertexes appear in this list no more than once.
Output
In the first line print "Yes" (without the quotes), if the string s Petya is interested in really exists and "No" (without the quotes) otherwise.
If the string s exists, then print it on the second line of the output. The length of s must be exactly n, it must consist of only letters "a", "b" and "c" only, and the graph built using this string must coincide with G. If there are multiple possible answers, you may print any of them.
Examples
Input
2 1
1 2
Output
Yes
aa
Input
4 3
1 2
1 3
1 4
Output
No
Note
In the first sample you are given a graph made of two vertices with an edge between them. So, these vertices can correspond to both the same and adjacent letters. Any of the following strings "aa", "ab", "ba", "bb", "bc", "cb", "cc" meets the graph's conditions.
In the second sample the first vertex is connected to all three other vertices, but these three vertices are not connected with each other. That means that they must correspond to distinct letters that are not adjacent, but that is impossible as there are only two such letters: a and c. | ```python
def dfs(v, used, g):
used[v] = True
for x in g[v]:
if not used[x]:
dfs(x, used, g)
from collections import defaultdict, Counter
n, m = map(int, input().split())
g = defaultdict(set)
p = Counter()
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
g[a].add(b)
g[b].add(a)
p[a] += 1
p[b] += 1
pows_set = defaultdict(set)
for i in range(n):
pows_set[p[i]].add(i)
pows_list = list(pows_set.keys())
pows_list.sort()
if len(pows_list) > 3:
print('No')
exit()
if len(pows_list) == 3:
flag = True
for key in pows_set:
for x in pows_set[key]:
for y in pows_set[key]:
if x != y and (x not in g[y]):
flag = False
for x in pows_set[pows_list[-1]]:
for i in range(n):
if i != x and (x not in g[i]):
flag = False
for x in pows_set[pows_list[0]]:
for y in pows_set[pows_list[1]]:
if x in g[y]:
flag = False
if not flag:
print('No')
exit()
print('Yes')
for i in range(n):
if i in pows_set[pows_list[0]]:
print('a', end ='')
if i in pows_set[pows_list[1]]:
print('c', end='')
if i in pows_set[pows_list[2]]:
print('b', end='')
if len(pows_list) == 1:
used = [False for i in range(n)]
dfs(0, used, g)
flag = True
for i in range(n):
for j in range(i + 1, n):
if i == j:
continue
if used[i] == used[j] and (i not in g[j]):
flag = False
if used[i] != used[j] and (i in g[j]):
flag = False
if flag:
print('Yes')
for i in range(n):
if used[i]:
print('a', end='')
else:
print('c', end='')
else:
print('No')
if len(pows_list) == 2:
used = [False for i in range(n)]
dfs(0, used, g)
flag = True
for i in range(n):
for j in range(i + 1, n):
if used[i] == used[j] and (i not in g[j]):
flag = False
if used[i] != used[j] and (i in g[j]):
flag = False
if flag:
print('Yes')
for i in range(n):
if used[i]:
print('a', end='')
else:
print('c', end='')
exit()
flag = True
for i in range(n):
for j in range(n):
if p[i] == p[j] and (i not in g[j]):
flag = False
if p[i] != p[j] and (i in g[j]):
flag = False
if flag:
print('Yes')
for i in range(n):
if i in pows_set[pows_list[0]]:
print('a', end='')
else:
print('b', end='')
exit()
flag = True
for i in pows_set[pows_list[1]]:
for j in range(n):
if j in pows_set[pows_list[1]]:
if i != j and (i not in g[j]):
flag = False
else:
if i not in g[j]:
flag = False
new_g = defaultdict(set)
for i in pows_set[pows_list[0]]:
for x in g[i]:
if x in pows_set[pows_list[0]]:
new_g[i].add(x)
used = dict()
for x in pows_set[pows_list[0]]:
used[x] = False
dfs(list(pows_set[pows_list[0]])[0], used, new_g)
for i in pows_set[pows_list[0]]:
for j in pows_set[pows_list[0]]:
if i == j:
continue
if used[i] == used[j] and (i not in new_g[j]):
flag = False
if used[i] != used[j] and (i in new_g[j]):
flag = False
if flag:
print('Yes')
for i in range(n):
if i in pows_set[pows_list[0]]:
if used[i]:
print('a', end='')
else:
print('c', end='')
else:
print('b', end ='')
else:
print('No')
exit()
``` |
644_C. Hostname Aliases | There are some websites that are accessible through several different addresses. For example, for a long time Codeforces was accessible with two hostnames codeforces.com and codeforces.ru.
You are given a list of page addresses being queried. For simplicity we consider all addresses to have the form http://<hostname>[/<path>], where:
* <hostname> — server name (consists of words and maybe some dots separating them),
* /<path> — optional part, where <path> consists of words separated by slashes.
We consider two <hostname> to correspond to one website if for each query to the first <hostname> there will be exactly the same query to the second one and vice versa — for each query to the second <hostname> there will be the same query to the first one. Take a look at the samples for further clarifications.
Your goal is to determine the groups of server names that correspond to one website. Ignore groups consisting of the only server name.
Please note, that according to the above definition queries http://<hostname> and http://<hostname>/ are different.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of page queries. Then follow n lines each containing exactly one address. Each address is of the form http://<hostname>[/<path>], where:
* <hostname> consists of lowercase English letters and dots, there are no two consecutive dots, <hostname> doesn't start or finish with a dot. The length of <hostname> is positive and doesn't exceed 20.
* <path> consists of lowercase English letters, dots and slashes. There are no two consecutive slashes, <path> doesn't start with a slash and its length doesn't exceed 20.
Addresses are not guaranteed to be distinct.
Output
First print k — the number of groups of server names that correspond to one website. You should count only groups of size greater than one.
Next k lines should contain the description of groups, one group per line. For each group print all server names separated by a single space. You are allowed to print both groups and names inside any group in arbitrary order.
Examples
Input
10
http://abacaba.ru/test
http://abacaba.ru/
http://abacaba.com
http://abacaba.com/test
http://abacaba.de/
http://abacaba.ru/test
http://abacaba.de/test
http://abacaba.com/
http://abacaba.com/t
http://abacaba.com/test
Output
1
http://abacaba.de http://abacaba.ru
Input
14
http://c
http://ccc.bbbb/aba..b
http://cba.com
http://a.c/aba..b/a
http://abc/
http://a.c/
http://ccc.bbbb
http://ab.ac.bc.aa/
http://a.a.a/
http://ccc.bbbb/
http://cba.com/
http://cba.com/aba..b
http://a.a.a/aba..b/a
http://abc/aba..b/a
Output
2
http://cba.com http://ccc.bbbb
http://a.a.a http://a.c http://abc | ```python
from sys import stdin
from collections import defaultdict
def main():
s, d = input(), defaultdict(set)
for s in stdin.read().splitlines():
i = s.find('/', 8)
if i == -1:
d[s].add('')
else:
d[s[:i]].add(s[i:])
e = defaultdict(list)
for s, v in d.items():
e[' '.join(sorted(v))].append(s)
r = [' '.join(v) for v in e.values() if len(v) > 1]
print(len(r))
print('\n'.join(r))
if __name__ == '__main__':
main()
``` |
717_G. Underfail | You have recently fallen through a hole and, after several hours of unconsciousness, have realized you are in an underground city. On one of your regular, daily walks through the unknown, you have encountered two unusually looking skeletons called Sanz and P’pairus, who decided to accompany you and give you some puzzles for seemingly unknown reasons.
One day, Sanz has created a crossword for you. Not any kind of crossword, but a 1D crossword! You are given m words and a string of length n. You are also given an array p, which designates how much each word is worth — the i-th word is worth pi points. Whenever you find one of the m words in the string, you are given the corresponding number of points. Each position in the crossword can be used at most x times. A certain word can be counted at different places, but you cannot count the same appearance of a word multiple times. If a word is a substring of another word, you can count them both (presuming you haven’t used the positions more than x times).
In order to solve the puzzle, you need to tell Sanz what’s the maximum achievable number of points in the crossword. There is no need to cover all postions, just get the maximal score! Crossword and words contain only lowercase English letters.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 500) — the length of the crossword. The second line contains the crossword string. The third line contains a single integer m (1 ≤ m ≤ 100) — the number of given words, and next m lines contain description of words: each line will have a string representing a non-empty word (its length doesn't exceed the length of the crossword) and integer pi (0 ≤ pi ≤ 100). Last line of the input will contain x (1 ≤ x ≤ 100) — maximum number of times a position in crossword can be used.
Output
Output single integer — maximum number of points you can get.
Example
Input
6
abacba
2
aba 6
ba 3
3
Output
12
Note
For example, with the string "abacba", words "aba" (6 points) and "ba" (3 points), and x = 3, you can get at most 12 points - the word "aba" appears once ("abacba"), while "ba" appears two times ("abacba"). Note that for x = 1, you could get at most 9 points, since you wouldn’t be able to count both "aba" and the first appearance of "ba". | ```python
import sys
from heapq import heappop, heappush
class Edge:
def __init__(self, u, v, cap, flow, cost, rev):
self.u = u
self.v = v
self.cap = cap
self.flow = flow
self.cost = cost
self.rev = rev
def add_edge(adj, u, v, capv, flowv, costv):
adj[u].append(Edge(u, v, capv, flowv, costv, len(adj[v])))
adj[v].append(Edge(v, u, 0, flowv, -costv, len(adj[u])-1))
def match(crossword, cw_idx, word):
for k in range(len(word)):
if crossword[cw_idx + k] != word[k]:
return False
return True
def read_input():
n = int(sys.stdin.readline())
crossword = sys.stdin.readline()[:-1]
m = int(sys.stdin.readline())
adj = [[] for _ in range(n+2)]
for _ in range(m):
word, p = sys.stdin.readline().split()
p = int(p)
i = 0
while i + len(word) <= n:
if match(crossword, i, word):
u, v = i + 1, i + 1 + len(word)
add_edge(adj, u, v, 1, 0, -p)
i += 1
x = int(sys.stdin.readline())
for i in range(n + 1):
u, v = i, i + 1
add_edge(adj, u, v, x, 0, 0)
return adj
def bellman_ford(adj):
potential = [0] * len(adj)
for _ in range(len(adj)):
for u in range(len(adj)):
for e in adj[u]:
reduced_cost = potential[e.u] + e.cost - potential[e.v]
if e.cap > 0 and reduced_cost < 0:
potential[e.v] += reduced_cost
return potential
def dijkstra(adj, potential, s, t):
oo = float('inf')
dist, pi = [+oo] * len(adj), [None] * len(adj)
dist[s] = 0
heap = [(0, s)]
while heap:
du, u = heappop(heap)
if dist[u] < du: continue
if u == t: break
for e in adj[u]:
reduced_cost = potential[e.u] + e.cost - potential[e.v]
if e.cap - e.flow > 0 and dist[e.v] > dist[e.u] + reduced_cost:
dist[e.v] = dist[e.u] + reduced_cost
heappush(heap, (dist[e.v], e.v))
pi[e.v] = e
return dist, pi
def min_cost_max_flow(adj):
min_cost, max_flow = 0, 0
oo = float('inf')
potential = bellman_ford(adj)
s, t = 0, len(adj) - 1
while True:
dist, pi = dijkstra(adj, potential, s, t)
if dist[t] == +oo:
break
for u in range(len(adj)):
if dist[u] < dist[t]:
potential[u] += dist[u] - dist[t]
limit, v = +oo, t
while v:
e = pi[v]
limit = min(limit, e.cap - e.flow)
v = e.u
v = t
while v:
e = pi[v]
e.flow += limit
adj[v][e.rev].flow -= limit
v = e.u
min_cost += limit * (potential[t] - potential[s])
max_flow += limit
return min_cost, max_flow
adj = read_input()
min_cost, _ = min_cost_max_flow(adj)
print(-min_cost)
``` |
762_B. USB vs. PS/2 | Due to the increase in the number of students of Berland State University it was decided to equip a new computer room. You were given the task of buying mouses, and you have to spend as little as possible. After all, the country is in crisis!
The computers bought for the room were different. Some of them had only USB ports, some — only PS/2 ports, and some had both options.
You have found a price list of a certain computer shop. In it, for m mouses it is specified the cost and the type of the port that is required to plug the mouse in (USB or PS/2). Each mouse from the list can be bought at most once.
You want to buy some set of mouses from the given price list in such a way so that you maximize the number of computers equipped with mouses (it is not guaranteed that you will be able to equip all of the computers), and in case of equality of this value you want to minimize the total cost of mouses you will buy.
Input
The first line contains three integers a, b and c (0 ≤ a, b, c ≤ 105) — the number of computers that only have USB ports, the number of computers, that only have PS/2 ports, and the number of computers, that have both options, respectively.
The next line contains one integer m (0 ≤ m ≤ 3·105) — the number of mouses in the price list.
The next m lines each describe another mouse. The i-th line contains first integer vali (1 ≤ vali ≤ 109) — the cost of the i-th mouse, then the type of port (USB or PS/2) that is required to plug the mouse in.
Output
Output two integers separated by space — the number of equipped computers and the total cost of the mouses you will buy.
Example
Input
2 1 1
4
5 USB
6 PS/2
3 PS/2
7 PS/2
Output
3 14
Note
In the first example you can buy the first three mouses. This way you will equip one of the computers that has only a USB port with a USB mouse, and the two PS/2 mouses you will plug into the computer with PS/2 port and the computer with both ports. | ```python
from sys import stdin as fin
a,b,c = [int(i) for i in input().split()]
n = int(input())
usb = []
ps2 = []
for i in range(n):
a1,a2 =fin.readline().strip().split()
if a2=='USB':
usb.append(int(a1))
else:
ps2.append(int(a1))
usb = sorted(usb)
ps2 = sorted(ps2)
n1 = len(usb)
n2 =len(ps2)
count = 0
cost = 0
l = 0
r= 0
cost+=sum(usb[:min(a,n1)])
l+=min(a,n1)
count+=l
cost+=sum(ps2[:min(b,n2)])
r+=min(b,n2)
count+=r
newarray = sorted(usb[l:]+ps2[r:])
cost+= sum(newarray[:min(c,len(newarray))])
count+=min(c,len(newarray))
print(count,cost)
``` |
785_C. Anton and Fairy Tale | Anton likes to listen to fairy tales, especially when Danik, Anton's best friend, tells them. Right now Danik tells Anton a fairy tale:
"Once upon a time, there lived an emperor. He was very rich and had much grain. One day he ordered to build a huge barn to put there all his grain. Best builders were building that barn for three days and three nights. But they overlooked and there remained a little hole in the barn, from which every day sparrows came through. Here flew a sparrow, took a grain and flew away..."
More formally, the following takes place in the fairy tale. At the beginning of the first day the barn with the capacity of n grains was full. Then, every day (starting with the first day) the following happens:
* m grains are brought to the barn. If m grains doesn't fit to the barn, the barn becomes full and the grains that doesn't fit are brought back (in this problem we can assume that the grains that doesn't fit to the barn are not taken into account).
* Sparrows come and eat grain. In the i-th day i sparrows come, that is on the first day one sparrow come, on the second day two sparrows come and so on. Every sparrow eats one grain. If the barn is empty, a sparrow eats nothing.
Anton is tired of listening how Danik describes every sparrow that eats grain from the barn. Anton doesn't know when the fairy tale ends, so he asked you to determine, by the end of which day the barn will become empty for the first time. Help Anton and write a program that will determine the number of that day!
Input
The only line of the input contains two integers n and m (1 ≤ n, m ≤ 1018) — the capacity of the barn and the number of grains that are brought every day.
Output
Output one integer — the number of the day when the barn will become empty for the first time. Days are numbered starting with one.
Examples
Input
5 2
Output
4
Input
8 1
Output
5
Note
In the first sample the capacity of the barn is five grains and two grains are brought every day. The following happens:
* At the beginning of the first day grain is brought to the barn. It's full, so nothing happens.
* At the end of the first day one sparrow comes and eats one grain, so 5 - 1 = 4 grains remain.
* At the beginning of the second day two grains are brought. The barn becomes full and one grain doesn't fit to it.
* At the end of the second day two sparrows come. 5 - 2 = 3 grains remain.
* At the beginning of the third day two grains are brought. The barn becomes full again.
* At the end of the third day three sparrows come and eat grain. 5 - 3 = 2 grains remain.
* At the beginning of the fourth day grain is brought again. 2 + 2 = 4 grains remain.
* At the end of the fourth day four sparrows come and eat grain. 4 - 4 = 0 grains remain. The barn is empty.
So the answer is 4, because by the end of the fourth day the barn becomes empty. | ```python
def binary_search_first_true(predicate, from_inclusive, to_inclusive):
lo = from_inclusive - 1
hi = to_inclusive + 1
while hi - lo > 1:
mid = (lo + hi) // 2
if not predicate(mid):
lo = mid
else:
hi = mid
return hi
def tri(n):
return n*(n+1)//2
def f(n, m, t):
return n-tri(t-m-1)-t
def solve(n, m):
if m >= n:
return n
ans = binary_search_first_true(lambda x: f(n, m, x) <= 0, m+1, n)
return ans
def main(sc):
n, m = sc.next_ints(2)
ans = solve(n, m)
print(ans)
class Scanner:
def __init__(self):
self.idx = 0
self.tokens = []
def next(self):
while self.idx == len(self.tokens) or not len(self.tokens[self.idx]):
if self.idx == len(self.tokens):
self.idx = 0
self.tokens = input().split()
else:
self.idx += 1
self.idx += 1
return self.tokens[self.idx-1]
def next_string(self):
return self.next()
def next_strings(self, n):
return [self.next_string() for i in range(0, n)]
def next_int(self):
return int(self.next())
def next_ints(self, n):
return [self.next_int() for i in range(0, n)]
scanner = Scanner()
main(scanner)
``` |
807_C. Success Rate | You are an experienced Codeforces user. Today you found out that during your activity on Codeforces you have made y submissions, out of which x have been successful. Thus, your current success rate on Codeforces is equal to x / y.
Your favorite rational number in the [0;1] range is p / q. Now you wonder: what is the smallest number of submissions you have to make if you want your success rate to be p / q?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Each of the next t lines contains four integers x, y, p and q (0 ≤ x ≤ y ≤ 109; 0 ≤ p ≤ q ≤ 109; y > 0; q > 0).
It is guaranteed that p / q is an irreducible fraction.
Hacks. For hacks, an additional constraint of t ≤ 5 must be met.
Output
For each test case, output a single integer equal to the smallest number of submissions you have to make if you want your success rate to be equal to your favorite rational number, or -1 if this is impossible to achieve.
Example
Input
4
3 10 1 2
7 14 3 8
20 70 2 7
5 6 1 1
Output
4
10
0
-1
Note
In the first example, you have to make 4 successful submissions. Your success rate will be equal to 7 / 14, or 1 / 2.
In the second example, you have to make 2 successful and 8 unsuccessful submissions. Your success rate will be equal to 9 / 24, or 3 / 8.
In the third example, there is no need to make any new submissions. Your success rate is already equal to 20 / 70, or 2 / 7.
In the fourth example, the only unsuccessful submission breaks your hopes of having the success rate equal to 1. | ```python
for _ in range(int(input())):
x,y,p,q=map(int,input().split())
l,r,res=0,10**18,-1
while l<=r:
mid=(l+r)//2
a,b=p*mid-x,q*mid-y
if a<=b and a>-1 and b>-1:res=b;r=mid-1
else :l=mid+1
print(res)
``` |
831_D. Office Keys | There are n people and k keys on a straight line. Every person wants to get to the office which is located on the line as well. To do that, he needs to reach some point with a key, take the key and then go to the office. Once a key is taken by somebody, it couldn't be taken by anybody else.
You are to determine the minimum time needed for all n people to get to the office with keys. Assume that people move a unit distance per 1 second. If two people reach a key at the same time, only one of them can take the key. A person can pass through a point with a key without taking it.
Input
The first line contains three integers n, k and p (1 ≤ n ≤ 1 000, n ≤ k ≤ 2 000, 1 ≤ p ≤ 109) — the number of people, the number of keys and the office location.
The second line contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ 109) — positions in which people are located initially. The positions are given in arbitrary order.
The third line contains k distinct integers b1, b2, ..., bk (1 ≤ bj ≤ 109) — positions of the keys. The positions are given in arbitrary order.
Note that there can't be more than one person or more than one key in the same point. A person and a key can be located in the same point.
Output
Print the minimum time (in seconds) needed for all n to reach the office with keys.
Examples
Input
2 4 50
20 100
60 10 40 80
Output
50
Input
1 2 10
11
15 7
Output
7
Note
In the first example the person located at point 20 should take the key located at point 40 and go with it to the office located at point 50. He spends 30 seconds. The person located at point 100 can take the key located at point 80 and go to the office with it. He spends 50 seconds. Thus, after 50 seconds everybody is in office with keys. | ```python
def list_input():
return list(map(int,input().split()))
def map_input():
return map(int,input().split())
def map_string():
return input().split()
n,k,p = map_input()
a = list_input()
b = list_input()
a.sort()
b.sort()
ans = 1000000000000000000
for i in range(k-n+1):
cur = 0
c1 = 0
c2 = i
while c1 < n:
cur = max(abs(a[c1]-b[c2])+abs(b[c2]-p),cur)
c1 += 1
c2 += 1
ans = min(ans,cur)
print(ans)
``` |
852_E. Casinos and travel | John has just bought a new car and is planning a journey around the country. Country has N cities, some of which are connected by bidirectional roads. There are N - 1 roads and every city is reachable from any other city. Cities are labeled from 1 to N.
John first has to select from which city he will start his journey. After that, he spends one day in a city and then travels to a randomly choosen city which is directly connected to his current one and which he has not yet visited. He does this until he can't continue obeying these rules.
To select the starting city, he calls his friend Jack for advice. Jack is also starting a big casino business and wants to open casinos in some of the cities (max 1 per city, maybe nowhere). Jack knows John well and he knows that if he visits a city with a casino, he will gamble exactly once before continuing his journey.
He also knows that if John enters a casino in a good mood, he will leave it in a bad mood and vice versa. Since he is John's friend, he wants him to be in a good mood at the moment when he finishes his journey. John is in a good mood before starting the journey.
In how many ways can Jack select a starting city for John and cities where he will build casinos such that no matter how John travels, he will be in a good mood at the end? Print answer modulo 109 + 7.
Input
In the first line, a positive integer N (1 ≤ N ≤ 100000), the number of cities.
In the next N - 1 lines, two numbers a, b (1 ≤ a, b ≤ N) separated by a single space meaning that cities a and b are connected by a bidirectional road.
Output
Output one number, the answer to the problem modulo 109 + 7.
Examples
Input
2
1 2
Output
4
Input
3
1 2
2 3
Output
10
Note
Example 1: If Jack selects city 1 as John's starting city, he can either build 0 casinos, so John will be happy all the time, or build a casino in both cities, so John would visit a casino in city 1, become unhappy, then go to city 2, visit a casino there and become happy and his journey ends there because he can't go back to city 1. If Jack selects city 2 for start, everything is symmetrical, so the answer is 4.
Example 2: If Jack tells John to start from city 1, he can either build casinos in 0 or 2 cities (total 4 possibilities). If he tells him to start from city 2, then John's journey will either contain cities 2 and 1 or 2 and 3. Therefore, Jack will either have to build no casinos, or build them in all three cities. With other options, he risks John ending his journey unhappy. Starting from 3 is symmetric to starting from 1, so in total we have 4 + 2 + 4 = 10 options. | ```python
n=int(input())
a=[0]*n
for i in range(n-1):
for j in input().split():
a[int(j)-1]+=1
l=a.count(1)
print((l*2**(n-l+1)+(n-l)*2**(n-l))%1000000007)
``` |
876_F. High Cry | Disclaimer: there are lots of untranslateable puns in the Russian version of the statement, so there is one more reason for you to learn Russian :)
Rick and Morty like to go to the ridge High Cry for crying loudly — there is an extraordinary echo. Recently they discovered an interesting acoustic characteristic of this ridge: if Rick and Morty begin crying simultaneously from different mountains, their cry would be heard between these mountains up to the height equal the bitwise OR of mountains they've climbed and all the mountains between them.
Bitwise OR is a binary operation which is determined the following way. Consider representation of numbers x and y in binary numeric system (probably with leading zeroes) x = xk... x1x0 and y = yk... y1y0. Then z = x | y is defined following way: z = zk... z1z0, where zi = 1, if xi = 1 or yi = 1, and zi = 0 otherwise. In the other words, digit of bitwise OR of two numbers equals zero if and only if digits at corresponding positions is both numbers equals zero. For example bitwise OR of numbers 10 = 10102 and 9 = 10012 equals 11 = 10112. In programming languages C/C++/Java/Python this operation is defined as «|», and in Pascal as «or».
Help Rick and Morty calculate the number of ways they can select two mountains in such a way that if they start crying from these mountains their cry will be heard above these mountains and all mountains between them. More formally you should find number of pairs l and r (1 ≤ l < r ≤ n) such that bitwise OR of heights of all mountains between l and r (inclusive) is larger than the height of any mountain at this interval.
Input
The first line contains integer n (1 ≤ n ≤ 200 000), the number of mountains in the ridge.
Second line contains n integers ai (0 ≤ ai ≤ 109), the heights of mountains in order they are located in the ridge.
Output
Print the only integer, the number of ways to choose two different mountains.
Examples
Input
5
3 2 1 6 5
Output
8
Input
4
3 3 3 3
Output
0
Note
In the first test case all the ways are pairs of mountains with the numbers (numbering from one):
(1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)
In the second test case there are no such pairs because for any pair of mountains the height of cry from them is 3, and this height is equal to the height of any mountain. | ```python
import os,io,sys
input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
n=int(input())
a=list(map(int,input().split()))
left=[]
right=[]
for i in range(31):
left.append([-1]*n)
right.append([n]*n)
for i in range(n):
for j in range(31):
if 1<<j&a[i]:
left[j][i]=i
else:
if i>0:
left[j][i]=left[j][i-1]
for i in range(n-1,-1,-1):
for j in range(31):
if 1<<j&a[i]:
right[j][i]=i
else:
if i<n-1:
right[j][i]=right[j][i+1]
ans=(n*(n-1))//2
ans+=n
lastsame=[-1]*n
dic={}
for i in range(n):
if a[i] in dic:
lastsame[i]=dic[a[i]]
dic[a[i]]=i
else:
dic[a[i]]=i
for i in range(n):
maxleft=-1
minright=n
for j in range(31):
if not(1<<j&a[i]):
maxleft=max(maxleft,left[j][i])
minright=min(minright,right[j][i])
if lastsame[i]>maxleft:
maxleft=lastsame[i]
ans-=(i-maxleft)*(minright-i)
print(ans)
``` |
900_A. Find Extra One | You have n distinct points on a plane, none of them lie on OY axis. Check that there is a point after removal of which the remaining points are located on one side of the OY axis.
Input
The first line contains a single positive integer n (2 ≤ n ≤ 105).
The following n lines contain coordinates of the points. The i-th of these lines contains two single integers xi and yi (|xi|, |yi| ≤ 109, xi ≠ 0). No two points coincide.
Output
Print "Yes" if there is such a point, "No" — otherwise.
You can print every letter in any case (upper or lower).
Examples
Input
3
1 1
-1 -1
2 -1
Output
Yes
Input
4
1 1
2 2
-1 1
-2 2
Output
No
Input
3
1 2
2 1
4 60
Output
Yes
Note
In the first example the second point can be removed.
In the second example there is no suitable for the condition point.
In the third example any point can be removed. | ```python
foo = int(input())
gr = 0
lo = 0
for i in range(foo):
bar = int((input().split(' '))[0])
if bar < 0:
lo += 1
else:
gr += 1
if lo > 1 and gr > 1:
print('No')
break
else:
print('Yes')
``` |
950_A. Left-handers, Right-handers and Ambidexters | You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | ```python
l, r, a = map(int, input().split())
while a != 0:
if l < r:
l += 1
else:
r += 1
a -= 1
print(min(l, r)*2)
``` |
978_D. Almost Arithmetic Progression | Polycarp likes arithmetic progressions. A sequence [a_1, a_2, ..., a_n] is called an arithmetic progression if for each i (1 ≤ i < n) the value a_{i+1} - a_i is the same. For example, the sequences [42], [5, 5, 5], [2, 11, 20, 29] and [3, 2, 1, 0] are arithmetic progressions, but [1, 0, 1], [1, 3, 9] and [2, 3, 1] are not.
It follows from the definition that any sequence of length one or two is an arithmetic progression.
Polycarp found some sequence of positive integers [b_1, b_2, ..., b_n]. He agrees to change each element by at most one. In the other words, for each element there are exactly three options: an element can be decreased by 1, an element can be increased by 1, an element can be left unchanged.
Determine a minimum possible number of elements in b which can be changed (by exactly one), so that the sequence b becomes an arithmetic progression, or report that it is impossible.
It is possible that the resulting sequence contains element equals 0.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the number of elements in b.
The second line contains a sequence b_1, b_2, ..., b_n (1 ≤ b_i ≤ 10^{9}).
Output
If it is impossible to make an arithmetic progression with described operations, print -1. In the other case, print non-negative integer — the minimum number of elements to change to make the given sequence becomes an arithmetic progression. The only allowed operation is to add/to subtract one from an element (can't use operation twice to the same position).
Examples
Input
4
24 21 14 10
Output
3
Input
2
500 500
Output
0
Input
3
14 5 1
Output
-1
Input
5
1 3 6 9 12
Output
1
Note
In the first example Polycarp should increase the first number on 1, decrease the second number on 1, increase the third number on 1, and the fourth number should left unchanged. So, after Polycarp changed three elements by one, his sequence became equals to [25, 20, 15, 10], which is an arithmetic progression.
In the second example Polycarp should not change anything, because his sequence is an arithmetic progression.
In the third example it is impossible to make an arithmetic progression.
In the fourth example Polycarp should change only the first element, he should decrease it on one. After that his sequence will looks like [0, 3, 6, 9, 12], which is an arithmetic progression. | ```python
import math
import sys
import collections
import bisect
import time
import random
from itertools import permutations
def get_ints():return map(int, sys.stdin.readline().strip().split())
def get_list():return list(map(int, sys.stdin.readline().strip().split()))
def get_string():return sys.stdin.readline().strip()
for t in range(1):
n=int(input())
arr=get_list()
if n<=2:
print("0")
continue
ans=10**10
for i in range(-1,2):
for j in range(-1,2):
temp_arr=arr.copy()
temp_arr[0]+=i
temp_arr[1]+=j
d=temp_arr[1]-temp_arr[0]
sol=abs(i)+abs(j)
poss=True
for k in range(2,n):
if temp_arr[k]-temp_arr[k-1]==d:
continue
diff=temp_arr[k]-temp_arr[k-1]
if abs(diff-d)<=1:
temp_arr[k]=temp_arr[k-1]+d
sol+=1
else:
poss=False
break
if poss:
ans=min(ans,sol)
if ans<10**10:
print(ans)
continue
print(-1)
``` |
998_C. Convert to Ones | You've got a string a_1, a_2, ..., a_n, consisting of zeros and ones.
Let's call a sequence of consecutive elements a_i, a_{i + 1}, …, a_j (1≤ i≤ j≤ n) a substring of string a.
You can apply the following operations any number of times:
* Choose some substring of string a (for example, you can choose entire string) and reverse it, paying x coins for it (for example, «0101101» → «0111001»);
* Choose some substring of string a (for example, you can choose entire string or just one symbol) and replace each symbol to the opposite one (zeros are replaced by ones, and ones — by zeros), paying y coins for it (for example, «0101101» → «0110001»).
You can apply these operations in any order. It is allowed to apply the operations multiple times to the same substring.
What is the minimum number of coins you need to spend to get a string consisting only of ones?
Input
The first line of input contains integers n, x and y (1 ≤ n ≤ 300 000, 0 ≤ x, y ≤ 10^9) — length of the string, cost of the first operation (substring reverse) and cost of the second operation (inverting all elements of substring).
The second line contains the string a of length n, consisting of zeros and ones.
Output
Print a single integer — the minimum total cost of operations you need to spend to get a string consisting only of ones. Print 0, if you do not need to perform any operations.
Examples
Input
5 1 10
01000
Output
11
Input
5 10 1
01000
Output
2
Input
7 2 3
1111111
Output
0
Note
In the first sample, at first you need to reverse substring [1 ... 2], and then you need to invert substring [2 ... 5].
Then the string was changed as follows:
«01000» → «10000» → «11111».
The total cost of operations is 1 + 10 = 11.
In the second sample, at first you need to invert substring [1 ... 1], and then you need to invert substring [3 ... 5].
Then the string was changed as follows:
«01000» → «11000» → «11111».
The overall cost is 1 + 1 = 2.
In the third example, string already consists only of ones, so the answer is 0. | ```python
n,x,y=map(int,input().split())
s=input()
c=0
for i in range(1,n):
if s[i]=='1' and s[i-1]=='0':
c+=1
if s[-1]=='0':
c+=1
if c==0:
print(0)
elif x>=y:
print(c*y)
else:
print((c-1)*x+y)
``` |
p02660 AtCoder Beginner Contest 169 - Div Game | Given is a positive integer N. Consider repeatedly applying the operation below on N:
* First, choose a positive integer z satisfying all of the conditions below:
* z can be represented as z=p^e, where p is a prime number and e is a positive integer;
* z divides N;
* z is different from all integers chosen in previous operations.
* Then, replace N with N/z.
Find the maximum number of times the operation can be applied.
Constraints
* All values in input are integers.
* 1 \leq N \leq 10^{12}
Input
Input is given from Standard Input in the following format:
N
Output
Print the maximum number of times the operation can be applied.
Examples
Input
24
Output
3
Input
1
Output
0
Input
64
Output
3
Input
1000000007
Output
1
Input
997764507000
Output
7 | ```python
def f(n):
p=[]
if n%2==0:
c=0
while n%2==0:
c+=1
n/=2
p.append(c)
for i in range(3,int(n**0.5)+1,2):
if n%i==0:
c=0
while n%i==0:
c+=1
n/=i
p.append(c)
if n!=1:
p.append(1)
return p
N=int(input())
p=f(N)
r=0
while p:
r+=int(((8*p.pop()+1)**0.5-1)/2)
print(r)
``` |
p02789 AtCoder Beginner Contest 152 - AC or WA | Takahashi is participating in a programming contest, AXC001. He has just submitted his code to Problem A.
The problem has N test cases, all of which must be passed to get an AC verdict.
Takahashi's submission has passed M cases out of the N test cases.
Determine whether Takahashi's submission gets an AC.
Constraints
* 1 \leq N \leq 100
* 0 \leq M \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M
Output
If Takahashi's submission gets an AC, print `Yes`; otherwise, print `No`.
Examples
Input
3 3
Output
Yes
Input
3 2
Output
No
Input
1 1
Output
Yes | ```python
N,M=map(int,input().split());print(["No","Yes"][N==M])
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.