name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
505_B. Mr. Kitayuta's Colorful Graph | Mr. Kitayuta has just bought an undirected graph consisting of n vertices and m edges. The vertices of the graph are numbered from 1 to n. Each edge, namely edge i, has a color ci, connecting vertex ai and bi.
Mr. Kitayuta wants you to process the following q queries.
In the i-th query, he gives you two integers — ui and vi.
Find the number of the colors that satisfy the following condition: the edges of that color connect vertex ui and vertex vi directly or indirectly.
Input
The first line of the input contains space-separated two integers — n and m (2 ≤ n ≤ 100, 1 ≤ m ≤ 100), denoting the number of the vertices and the number of the edges, respectively.
The next m lines contain space-separated three integers — ai, bi (1 ≤ ai < bi ≤ n) and ci (1 ≤ ci ≤ m). Note that there can be multiple edges between two vertices. However, there are no multiple edges of the same color between two vertices, that is, if i ≠ j, (ai, bi, ci) ≠ (aj, bj, cj).
The next line contains a integer — q (1 ≤ q ≤ 100), denoting the number of the queries.
Then follows q lines, containing space-separated two integers — ui and vi (1 ≤ ui, vi ≤ n). It is guaranteed that ui ≠ vi.
Output
For each query, print the answer in a separate line.
Examples
Input
4 5
1 2 1
1 2 2
2 3 1
2 3 3
2 4 3
3
1 2
3 4
1 4
Output
2
1
0
Input
5 7
1 5 1
2 5 1
3 5 1
4 5 1
1 2 2
2 3 2
3 4 2
5
1 5
5 1
2 5
1 5
1 4
Output
1
1
1
1
2
Note
Let's consider the first sample.
<image> The figure above shows the first sample.
* Vertex 1 and vertex 2 are connected by color 1 and 2.
* Vertex 3 and vertex 4 are connected by color 3.
* Vertex 1 and vertex 4 are not connected by any single color. | ```python
def build_graph():
line1 = input().strip().split()
n = int(line1[0])
m = int(line1[1])
graph = {}
for _ in range(m):
line = input().strip().split()
u = int(line[0])
v = int(line[1])
c = int(line[2])
if c not in graph:
graph[c] = {j: [] for j in range(1, n+1)}
graph[c][u].append(v)
graph[c][v].append(u)
return graph
def no_of_paths(u, v, graph):
x = 0
for c in graph:
parent = {}
parent = dfs_visit(v, graph[c], parent)
if u in parent:
x += 1
return x
def dfs_visit(i, adj_list, parent):
for j in adj_list[i]:
if j not in parent:
parent[j] = i
dfs_visit(j, adj_list, parent)
return parent
if __name__ == "__main__":
graph = build_graph()
for _ in range(int(input())):
line = input().strip().split()
print(no_of_paths(int(line[0]), int(line[1]), graph))
``` |
554_C. Kyoya and Colored Balls | Kyoya Ootori has a bag with n colored balls that are colored with k different colors. The colors are labeled from 1 to k. Balls of the same color are indistinguishable. He draws balls from the bag one by one until the bag is empty. He noticed that he drew the last ball of color i before drawing the last ball of color i + 1 for all i from 1 to k - 1. Now he wonders how many different ways this can happen.
Input
The first line of input will have one integer k (1 ≤ k ≤ 1000) the number of colors.
Then, k lines will follow. The i-th line will contain ci, the number of balls of the i-th color (1 ≤ ci ≤ 1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from the bag as described in the statement, modulo 1 000 000 007.
Examples
Input
3
2
2
1
Output
3
Input
4
1
2
3
4
Output
1680
Note
In the first sample, we have 2 balls of color 1, 2 balls of color 2, and 1 ball of color 3. The three ways for Kyoya are:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
| ```python
from sys import stdin
c = [[0]*1002 for _ in range(0,1002)]
MOD = int(1e9+7)
for i in range(0,1002):
c[i][0] = c[i][i] = 1
for j in range(0,i):
c[i][j] = (c[i-1][j-1] + c[i-1][j])%MOD
r = map(int,stdin.read().split())
n = next(r)
ans = 1
sum = 0
for _ in range(0,n):
x = next(r)
ans = (ans * c[sum+x-1][sum])%MOD
sum += x
print(ans)
``` |
580_B. Kefa and Company | Kefa wants to celebrate his first big salary by going to restaurant. However, he needs company.
Kefa has n friends, each friend will agree to go to the restaurant if Kefa asks. Each friend is characterized by the amount of money he has and the friendship factor in respect to Kefa. The parrot doesn't want any friend to feel poor compared to somebody else in the company (Kefa doesn't count). A friend feels poor if in the company there is someone who has at least d units of money more than he does. Also, Kefa wants the total friendship factor of the members of the company to be maximum. Help him invite an optimal company!
Input
The first line of the input contains two space-separated integers, n and d (1 ≤ n ≤ 105, <image>) — the number of Kefa's friends and the minimum difference between the amount of money in order to feel poor, respectively.
Next n lines contain the descriptions of Kefa's friends, the (i + 1)-th line contains the description of the i-th friend of type mi, si (0 ≤ mi, si ≤ 109) — the amount of money and the friendship factor, respectively.
Output
Print the maximum total friendship factir that can be reached.
Examples
Input
4 5
75 5
0 100
150 20
75 1
Output
100
Input
5 100
0 7
11 32
99 10
46 8
87 54
Output
111
Note
In the first sample test the most profitable strategy is to form a company from only the second friend. At all other variants the total degree of friendship will be worse.
In the second sample test we can take all the friends. | ```python
n, d = map(int, input().split())
v = []
for i in range(0, n):
a, b = map(int, input().split())
v.append((a, b))
v = sorted(v)
lo = 0
totalFriendship = v[0][1]
bestFriendship = totalFriendship
for i in range(1, n):
while v[i][0] - v[lo][0] >= d:
totalFriendship -= v[lo][1]
lo += 1
totalFriendship += v[i][1]
bestFriendship = max(bestFriendship, totalFriendship)
print(bestFriendship)
``` |
602_A. Two Bases | After seeing the "ALL YOUR BASE ARE BELONG TO US" meme for the first time, numbers X and Y realised that they have different bases, which complicated their relations.
You're given a number X represented in base bx and a number Y represented in base by. Compare those two numbers.
Input
The first line of the input contains two space-separated integers n and bx (1 ≤ n ≤ 10, 2 ≤ bx ≤ 40), where n is the number of digits in the bx-based representation of X.
The second line contains n space-separated integers x1, x2, ..., xn (0 ≤ xi < bx) — the digits of X. They are given in the order from the most significant digit to the least significant one.
The following two lines describe Y in the same way: the third line contains two space-separated integers m and by (1 ≤ m ≤ 10, 2 ≤ by ≤ 40, bx ≠ by), where m is the number of digits in the by-based representation of Y, and the fourth line contains m space-separated integers y1, y2, ..., ym (0 ≤ yi < by) — the digits of Y.
There will be no leading zeroes. Both X and Y will be positive. All digits of both numbers are given in the standard decimal numeral system.
Output
Output a single character (quotes for clarity):
* '<' if X < Y
* '>' if X > Y
* '=' if X = Y
Examples
Input
6 2
1 0 1 1 1 1
2 10
4 7
Output
=
Input
3 3
1 0 2
2 5
2 4
Output
<
Input
7 16
15 15 4 0 0 7 10
7 9
4 8 0 3 1 5 0
Output
>
Note
In the first sample, X = 1011112 = 4710 = Y.
In the second sample, X = 1023 = 215 and Y = 245 = 1123, thus X < Y.
In the third sample, <image> and Y = 48031509. We may notice that X starts with much larger digits and bx is much larger than by, so X is clearly larger than Y. | ```python
# print ("Input digits and base for number one")
n1, b1 = (int(x) for x in input().split())
# print ("Input all the digits")
d1 = list(int(x) for x in input().split())
d1.reverse()
# print ("Input digits and base for number two")
n2, b2 = (int(x) for x in input().split())
# print ("Input all the digits")
d2 = list(int(x) for x in input().split())
d2.reverse()
# Compute base ten representation of number one
answer1 = 0
power1 = 1
for digit in d1:
answer1 += digit*power1
power1 *= b1
# print(answer1)
# Compute base ten representation of number two
answer2 = 0
power2 = 1
for digit in d2:
answer2 += digit*power2
power2 *= b2
# print(answer2)
if answer1 < answer2:
print("<")
elif answer2 < answer1:
print(">")
else:
print("=")
``` |
673_A. Bear and Game | Bear Limak likes watching sports on TV. He is going to watch a game today. The game lasts 90 minutes and there are no breaks.
Each minute can be either interesting or boring. If 15 consecutive minutes are boring then Limak immediately turns TV off.
You know that there will be n interesting minutes t1, t2, ..., tn. Your task is to calculate for how many minutes Limak will watch the game.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 90) — the number of interesting minutes.
The second line contains n integers t1, t2, ..., tn (1 ≤ t1 < t2 < ... tn ≤ 90), given in the increasing order.
Output
Print the number of minutes Limak will watch the game.
Examples
Input
3
7 20 88
Output
35
Input
9
16 20 30 40 50 60 70 80 90
Output
15
Input
9
15 20 30 40 50 60 70 80 90
Output
90
Note
In the first sample, minutes 21, 22, ..., 35 are all boring and thus Limak will turn TV off immediately after the 35-th minute. So, he would watch the game for 35 minutes.
In the second sample, the first 15 minutes are boring.
In the third sample, there are no consecutive 15 boring minutes. So, Limak will watch the whole game. | ```python
n=int(input())
tl = list(map(int, input().split()))
time=cnt=0
while cnt <15 and time<90:
time+=1
if tl.count(time)>0:
cnt=0
else:
cnt+=1
print(time)
``` |
698_B. Fix a Tree | A tree is an undirected connected graph without cycles.
Let's consider a rooted undirected tree with n vertices, numbered 1 through n. There are many ways to represent such a tree. One way is to create an array with n integers p1, p2, ..., pn, where pi denotes a parent of vertex i (here, for convenience a root is considered its own parent).
<image> For this rooted tree the array p is [2, 3, 3, 2].
Given a sequence p1, p2, ..., pn, one is able to restore a tree:
1. There must be exactly one index r that pr = r. A vertex r is a root of the tree.
2. For all other n - 1 vertices i, there is an edge between vertex i and vertex pi.
A sequence p1, p2, ..., pn is called valid if the described procedure generates some (any) rooted tree. For example, for n = 3 sequences (1,2,2), (2,3,1) and (2,1,3) are not valid.
You are given a sequence a1, a2, ..., an, not necessarily valid. Your task is to change the minimum number of elements, in order to get a valid sequence. Print the minimum number of changes and an example of a valid sequence after that number of changes. If there are many valid sequences achievable in the minimum number of changes, print any of them.
Input
The first line of the input contains an integer n (2 ≤ n ≤ 200 000) — the number of vertices in the tree.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ n).
Output
In the first line print the minimum number of elements to change, in order to get a valid sequence.
In the second line, print any valid sequence possible to get from (a1, a2, ..., an) in the minimum number of changes. If there are many such sequences, any of them will be accepted.
Examples
Input
4
2 3 3 4
Output
1
2 3 4 4
Input
5
3 2 2 5 3
Output
0
3 2 2 5 3
Input
8
2 3 5 4 1 6 6 7
Output
2
2 3 7 8 1 6 6 7
Note
In the first sample, it's enough to change one element. In the provided output, a sequence represents a tree rooted in a vertex 4 (because p4 = 4), which you can see on the left drawing below. One of other correct solutions would be a sequence 2 3 3 2, representing a tree rooted in vertex 3 (right drawing below). On both drawings, roots are painted red.
<image>
In the second sample, the given sequence is already valid. | ```python
from collections import defaultdict
from sys import stdin,setrecursionlimit
setrecursionlimit(10**6)
import threading
def f(a):
n=len(a)
a=list(map(lambda s:s-1,a))
root=None
for i in range(len(a)):
if a[i]==i:
root=i
vis=[0]*(n)
traitors=[]
for i in range(0,n):
cycle=-1
cur=i
move=set()
while vis[cur]==0:
vis[cur]=1
move.add(cur)
if a[cur] in move:
cycle=cur
cur=a[cur]
if cycle!=-1:
traitors.append(cycle)
ans=len(traitors)-1
if root==None:
a[traitors[0]]=traitors[0]
root=traitors[0]
ans+=1
for i in traitors:
if i!=root:
a[i]=root
print(ans)
a=list(map(lambda s:s+1,a))
return a
n=input()
a=list(map(int,input().strip().split()))
print(*f(a))
``` |
719_B. Anatoly and Cockroaches | Anatoly lives in the university dorm as many other students do. As you know, cockroaches are also living there together with students. Cockroaches might be of two colors: black and red. There are n cockroaches living in Anatoly's room.
Anatoly just made all his cockroaches to form a single line. As he is a perfectionist, he would like the colors of cockroaches in the line to alternate. He has a can of black paint and a can of red paint. In one turn he can either swap any two cockroaches, or take any single cockroach and change it's color.
Help Anatoly find out the minimum number of turns he needs to make the colors of cockroaches in the line alternate.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100 000) — the number of cockroaches.
The second line contains a string of length n, consisting of characters 'b' and 'r' that denote black cockroach and red cockroach respectively.
Output
Print one integer — the minimum number of moves Anatoly has to perform in order to make the colors of cockroaches in the line to alternate.
Examples
Input
5
rbbrr
Output
1
Input
5
bbbbb
Output
2
Input
3
rbr
Output
0
Note
In the first sample, Anatoly has to swap third and fourth cockroaches. He needs 1 turn to do this.
In the second sample, the optimum answer is to paint the second and the fourth cockroaches red. This requires 2 turns.
In the third sample, the colors of cockroaches in the line are alternating already, thus the answer is 0. | ```python
#http://codeforces.com/problemset/problem/719/B
#solved
n = int(input())
s = input()
red_black = True
swap_red = {"b": 0, "r": 0}
swap_black = {"b": 0, "r": 0}
for c in s:
if red_black is True and c != "b":
swap_black["r"] += 1
elif red_black is False and c != "r":
swap_black["b"] += 1
if red_black is True and c != "r":
swap_red["b"] += 1
elif red_black is False and c != "b":
swap_red["r"] += 1
red_black = True if red_black is False else False
black = (swap_black[max(swap_black, key=swap_black.get)] - swap_black[min(swap_black, key=swap_black.get)]) + swap_black[min(swap_black, key=swap_black.get)]
red = (swap_red[max(swap_red, key=swap_red.get)] - swap_red[min(swap_red, key=swap_red.get)]) + swap_red[min(swap_red, key=swap_red.get)]
print(int(min(red, black)))
``` |
787_A. The Monster | A monster is chasing after Rick and Morty on another planet. They're so frightened that sometimes they scream. More accurately, Rick screams at times b, b + a, b + 2a, b + 3a, ... and Morty screams at times d, d + c, d + 2c, d + 3c, ....
<image>
The Monster will catch them if at any point they scream at the same time, so it wants to know when it will catch them (the first time they scream at the same time) or that they will never scream at the same time.
Input
The first line of input contains two integers a and b (1 ≤ a, b ≤ 100).
The second line contains two integers c and d (1 ≤ c, d ≤ 100).
Output
Print the first time Rick and Morty will scream at the same time, or - 1 if they will never scream at the same time.
Examples
Input
20 2
9 19
Output
82
Input
2 1
16 12
Output
-1
Note
In the first sample testcase, Rick's 5th scream and Morty's 8th time are at time 82.
In the second sample testcase, all Rick's screams will be at odd times and Morty's will be at even times, so they will never scream at the same time. | ```python
import math
R=lambda:list(map(int,input().split()))
a,b=R()
c,d=R()
if abs(b-d)%math.gcd(a,c)!=0:
print(-1)
exit(0)
while b != d:
if b<d: b+=a
else: d+=c
print(b)
``` |
808_E. Selling Souvenirs | After several latest reforms many tourists are planning to visit Berland, and Berland people understood that it's an opportunity to earn money and changed their jobs to attract tourists. Petya, for example, left the IT corporation he had been working for and started to sell souvenirs at the market.
This morning, as usual, Petya will come to the market. Petya has n different souvenirs to sell; ith souvenir is characterised by its weight wi and cost ci. Petya knows that he might not be able to carry all the souvenirs to the market. So Petya wants to choose a subset of souvenirs such that its total weight is not greater than m, and total cost is maximum possible.
Help Petya to determine maximum possible total cost.
Input
The first line contains two integers n and m (1 ≤ n ≤ 100000, 1 ≤ m ≤ 300000) — the number of Petya's souvenirs and total weight that he can carry to the market.
Then n lines follow. ith line contains two integers wi and ci (1 ≤ wi ≤ 3, 1 ≤ ci ≤ 109) — the weight and the cost of ith souvenir.
Output
Print one number — maximum possible total cost of souvenirs that Petya can carry to the market.
Examples
Input
1 1
2 1
Output
0
Input
2 2
1 3
2 2
Output
3
Input
4 3
3 10
2 7
2 8
1 1
Output
10 | ```python
def f():
n, m = map(int, input().split())
l = list(tuple(map(int, input().split())) for _ in range(n))
l.sort(key=lambda e: (0, 6, 3, 2)[e[0]] * e[1], reverse=True)
last, r = [0] * 4, 0
for i, (w, c) in enumerate(l):
if m < w:
break
m -= w
r += c
last[w] = c
else:
return r
if not m:
return r
res, tail = [r], (None, [], [], [])
for w, c in l[i:]:
tail[w].append(c)
for w in 1, 2, 3:
tail[w].append(0)
_, t1, t2, t3 = tail
if m == 1:
res.append(r + t1[0])
if last[1]:
res.append(r - last[1] + t2[0])
if last[2]:
res.append(r - last[2] + t3[0])
if last[3]:
r -= last[3]
res += (r + sum(t1[:4]), r + sum(t1[:2]) + t2[0], r + sum(t2[:2]))
else: # m == 2
res += (r + sum(t1[:2]), r + t2[0])
if last[1]:
res.append(r - last[1] + t3[0])
if last[2]:
res.append(r - last[2] + t3[0] + t1[0])
return max(res)
def main():
print(f())
if __name__ == '__main__':
main()
``` |
833_A. The Meaningless Game | <image>
Slastyona and her loyal dog Pushok are playing a meaningless game that is indeed very interesting.
The game consists of multiple rounds. Its rules are very simple: in each round, a natural number k is chosen. Then, the one who says (or barks) it faster than the other wins the round. After that, the winner's score is multiplied by k2, and the loser's score is multiplied by k. In the beginning of the game, both Slastyona and Pushok have scores equal to one.
Unfortunately, Slastyona had lost her notepad where the history of all n games was recorded. She managed to recall the final results for each games, though, but all of her memories of them are vague. Help Slastyona verify their correctness, or, to put it another way, for each given pair of scores determine whether it was possible for a game to finish with such result or not.
Input
In the first string, the number of games n (1 ≤ n ≤ 350000) is given.
Each game is represented by a pair of scores a, b (1 ≤ a, b ≤ 109) – the results of Slastyona and Pushok, correspondingly.
Output
For each pair of scores, answer "Yes" if it's possible for a game to finish with given score, and "No" otherwise.
You can output each letter in arbitrary case (upper or lower).
Example
Input
6
2 4
75 45
8 8
16 16
247 994
1000000000 1000000
Output
Yes
Yes
Yes
No
No
Yes
Note
First game might have been consisted of one round, in which the number 2 would have been chosen and Pushok would have won.
The second game needs exactly two rounds to finish with such result: in the first one, Slastyona would have said the number 5, and in the second one, Pushok would have barked the number 3. | ```python
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left , bisect_right
import math
def ii():
return int(input())
def li():
return list(map(int,input().split()))
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
no = "No"
yes = "Yes"
def solve():
a,b = li()
x = (pow(a*b,1/3))
x=round(x)
if x*x*x==a*b and a%x==b%x==0:
print(yes)
else:
print(no)
t = 1
t = int(input())
for _ in range(t):
solve()
``` |
878_B. Teams Formation | This time the Berland Team Olympiad in Informatics is held in a remote city that can only be reached by one small bus. Bus has n passenger seats, seat i can be occupied only by a participant from the city ai.
Today the bus has completed m trips, each time bringing n participants. The participants were then aligned in one line in the order they arrived, with people from the same bus standing in the order of their seats (i. e. if we write down the cities where the participants came from, we get the sequence a1, a2, ..., an repeated m times).
After that some teams were formed, each consisting of k participants form the same city standing next to each other in the line. Once formed, teams left the line. The teams were formed until there were no k neighboring participants from the same city.
Help the organizers determine how many participants have left in the line after that process ended. We can prove that answer doesn't depend on the order in which teams were selected.
Input
The first line contains three integers n, k and m (1 ≤ n ≤ 105, 2 ≤ k ≤ 109, 1 ≤ m ≤ 109).
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number of city, person from which must take seat i in the bus.
Output
Output the number of remaining participants in the line.
Examples
Input
4 2 5
1 2 3 1
Output
12
Input
1 9 10
1
Output
1
Input
3 2 10
1 2 1
Output
0
Note
In the second example, the line consists of ten participants from the same city. Nine of them will form a team. At the end, only one participant will stay in the line. | ```python
import sys
from collections import deque
input=sys.stdin.readline
n,k,m=map(int,input().split())
a=list(map(int,input().split()))
r=a[0]
flag=0
for i in range(n):
if r!=a[i]:
flag=1
break
if flag==0:
print((m*n)%k)
sys.exit()
if k>n:
print(m*n)
sys.exit()
curr=a[0]
tmp=1
que=deque([(a[0],1)])
for i in range(1,n):
if a[i]==curr:
tmp+=1
que.append((a[i],tmp))
if tmp==k:
for j in range(k):
que.pop()
if que:
tmp=que[-1][1]
curr=que[-1][0]
else:
curr=-1
else:
tmp=1
curr=a[i]
que.append((a[i],tmp))
quecop=[]
for i in que:
quecop.append(i[0])
leftrem=0
rightrem=0
if not que:
print(0)
sys.exit()
while que[0][0]==que[-1][0]:
r=que[0][0]
count1=0
p=len(que)
count2=p-1
while count1<p and que[count1][0]==r:
count1+=1
if count1==p:
break
while count2>=0 and que[count2][0]==r:
count2-=1
if count1+p-1-count2<k:
break
leftrem+=count1
rightrem+=k-count1
for i in range(count1):
que.popleft()
for i in range(k-count1):
que.pop()
if que:
t=que[0][0]
flag=0
for i in que:
if i[0]!=t:
flag=1
break
if flag:
print(leftrem+rightrem+len(que)*m)
else:
r=[]
for i in range(leftrem):
if r and r[-1][0]==quecop[i]:
r[-1][1]+=1
else:
r.append([quecop[i],1])
if r and r[-1][0]==que[0][0]:
r[-1][0]=(r[-1][0]+(len(que)*m))%k
if r[-1][1]==0:
r.pop()
else:
if (len(que)*m)%k:
r.append([que[0][0],(len(que)*m)%k])
for i in range(len(quecop)-rightrem,len(quecop)):
if r and r[-1][0]==quecop[i]:
r[-1][1]+=1
if r[-1][1]==k:
r.pop()
else:
r.append([quecop[i],1])
finans=0
for i in r:
finans+=i[1]
print(finans)
``` |
901_D. Weighting a Tree | You are given a connected undirected graph with n vertices and m edges. The vertices are enumerated from 1 to n.
You are given n integers c1, c2, ..., cn, each of them is between - n and n, inclusive. It is also guaranteed that the parity of cv equals the parity of degree of vertex v. The degree of a vertex is the number of edges connected to it.
You are to write a weight between - 2·n2 and 2·n2 (inclusive) on each edge in such a way, that for each vertex v the sum of weights on edges connected to this vertex is equal to cv, or determine that this is impossible.
Input
The first line contains two integers n and m (2 ≤ n ≤ 105, n - 1 ≤ m ≤ 105) — the number of vertices and the number of edges.
The next line contains n integers c1, c2, ..., cn ( - n ≤ ci ≤ n), where ci is the required sum of weights of edges connected to vertex i. It is guaranteed that the parity of ci equals the parity of degree of vertex i.
The next m lines describe edges of the graph. The i-th of these lines contains two integers ai and bi (1 ≤ ai, bi ≤ n; ai ≠ bi), meaning that the i-th edge connects vertices ai and bi.
It is guaranteed that the given graph is connected and does not contain loops and multiple edges.
Output
If there is no solution, print "NO".
Otherwise print "YES" and then m lines, the i-th of them is the weight of the i-th edge wi ( - 2·n2 ≤ wi ≤ 2·n2).
Examples
Input
3 3
2 2 2
1 2
2 3
1 3
Output
YES
1
1
1
Input
4 3
-1 0 2 1
1 2
2 3
3 4
Output
YES
-1
1
1
Input
6 6
3 5 5 5 1 5
1 4
3 2
4 3
4 5
3 5
5 6
Output
YES
3
5
3
-1
-3
5
Input
4 4
4 4 2 4
1 2
2 3
3 4
4 1
Output
NO | ```python
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n,mod=0):
self.BIT = [0]*(n+1)
self.num = n
self.mod = mod
def query(self,idx):
res_sum = 0
mod = self.mod
while idx > 0:
res_sum += self.BIT[idx]
if mod:
res_sum %= mod
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
mod = self.mod
while idx <= self.num:
self.BIT[idx] += x
if mod:
self.BIT[idx] %= mod
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
self.size = n
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
if r==self.size:
r = self.num
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
n,m = mi()
c = li()
edge = [[] for i in range(n)]
for i in range(m):
u,v = mi()
edge[u-1].append((v-1,i))
edge[v-1].append((u-1,i))
parent = [(-1,-1) for v in range(n)]
tree_edge = [[] for v in range(n)]
depth = [0 for v in range(n)]
special = None
stack = [0]
cnt = [0 for v in range(n)]
while stack:
v = stack[-1]
if cnt[v]==len(edge[v]):
stack.pop()
else:
nv,idx = edge[v][cnt[v]]
cnt[v] += 1
if nv==0 or parent[nv]!=(-1,-1):
if depth[nv] < depth[v] and (depth[v]-depth[nv])%2==0 and not special:
special = (v,nv,idx)
else:
parent[nv] = (v,idx)
depth[nv] = depth[v] + 1
tree_edge[v].append((nv,idx))
stack.append(nv)
if not special:
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
if odd!=even:
print("NO")
else:
print("YES")
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
ans = [0 for i in range(m)]
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
else:
print("YES")
even = 0
odd = 0
for v in range(n):
if depth[v]&1:
odd += c[v]
else:
even += c[v]
ans = [0 for i in range(m)]
v,nv,idx = special
if depth[v]&1:
ans[idx] -= (even-odd)//2
c[v] += (even-odd)//2
c[nv] += (even-odd)//2
else:
ans[idx] -= (odd-even)//2
c[v] += (odd-even)//2
c[nv] += (odd-even)//2
#print(ans)
deq = deque([0])
topo = []
while deq:
v = deq.popleft()
topo.append(v)
for nv,idx in tree_edge[v]:
deq.append(nv)
for v in topo[::-1]:
if v==0:
continue
_,i = parent[v]
ans[i] = c[v]
for nv,idx in tree_edge[v] :
ans[i] -= ans[idx]
print(*ans,sep="\n")
``` |
924_A. Mystical Mosaic | There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 ≤ n, m ≤ 50) — the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column. | ```python
def read_data():
n, m = map(int, input().strip().split())
a = []
for i in range(n):
line = list(input().strip())
for j in range(len(line)):
if line[j] == ".":
line[j] = 0
else:
line[j] = 1
a.append(line)
return n, m, a
def get_step(i,j):
rows = []
cols = []
for k in range(m):
if a[i][k] == 1:
cols.append(k)
if k in usedc:
return "No"
else:
usedc.append(k)
for k in range(n):
if a[k][j] == 1:
rows.append(k)
if k in usedr:
return "No"
else:
usedr.append(k)
for row in rows:
for col in cols:
if a[row][col] == 0:
return "No"
else:
a[row][col] = 0
return "Ok"
def solve():
for i in range(n):
for j in range(m):
if a[i][j] == 1:
step = get_step(i,j)
if step == "No":
return "No"
return "Yes"
n, m, a = read_data()
usedr = []
usedc = []
print(solve())
``` |
952_C. Ravioli Sort | Everybody knows of [spaghetti sort](https://en.wikipedia.org/wiki/Spaghetti_sort). You decided to implement an analog sorting algorithm yourself, but as you survey your pantry you realize you're out of spaghetti! The only type of pasta you have is ravioli, but you are not going to let this stop you...
You come up with the following algorithm. For each number in the array ai, build a stack of ai ravioli. The image shows the stack for ai = 4.
<image>
Arrange the stacks in one row in the order in which the corresponding numbers appear in the input array. Find the tallest one (if there are several stacks of maximal height, use the leftmost one). Remove it and add its height to the end of the output array. Shift the stacks in the row so that there is no gap between them. Repeat the procedure until all stacks have been removed.
At first you are very happy with your algorithm, but as you try it on more inputs you realize that it doesn't always produce the right sorted array. Turns out when two stacks of ravioli are next to each other (at any step of the process) and differ in height by two or more, the top ravioli of the taller stack slides down on top of the lower stack.
Given an input array, figure out whether the described algorithm will sort it correctly.
Input
The first line of input contains a single number n (1 ≤ n ≤ 10) — the size of the array.
The second line of input contains n space-separated integers ai (1 ≤ ai ≤ 100) — the elements of the array.
Output
Output "YES" if the array can be sorted using the described procedure and "NO" if it can not.
Examples
Input
3
1 2 3
Output
YES
Input
3
3 1 2
Output
NO
Note
In the second example the array will change even before the tallest stack is chosen for the first time: ravioli from stack of height 3 will slide on the stack of height 1, and the algorithm will output an array {2, 2, 2}. | ```python
n = int(input())
l = [int(x) for x in input().split()]
while len(l) > 1:
if len([i for i in range(len(l)-1) if abs(l[i] - l[i+1]) > 1 ])>0:
print ('NO')
exit(0)
l.remove(max(l))
print('YES')
``` |
979_E. Kuro and Topological Parity | Kuro has recently won the "Most intelligent cat ever" contest. The three friends then decided to go to Katie's home to celebrate Kuro's winning. After a big meal, they took a small break then started playing games.
Kuro challenged Katie to create a game with only a white paper, a pencil, a pair of scissors and a lot of arrows (you can assume that the number of arrows is infinite). Immediately, Katie came up with the game called Topological Parity.
The paper is divided into n pieces enumerated from 1 to n. Shiro has painted some pieces with some color. Specifically, the i-th piece has color c_{i} where c_{i} = 0 defines black color, c_{i} = 1 defines white color and c_{i} = -1 means that the piece hasn't been colored yet.
The rules of the game is simple. Players must put some arrows between some pairs of different pieces in such a way that for each arrow, the number in the piece it starts from is less than the number of the piece it ends at. Also, two different pieces can only be connected by at most one arrow. After that the players must choose the color (0 or 1) for each of the unpainted pieces. The score of a valid way of putting the arrows and coloring pieces is defined as the number of paths of pieces of alternating colors. For example, [1 → 0 → 1 → 0], [0 → 1 → 0 → 1], [1], [0] are valid paths and will be counted. You can only travel from piece x to piece y if and only if there is an arrow from x to y.
But Kuro is not fun yet. He loves parity. Let's call his favorite parity p where p = 0 stands for "even" and p = 1 stands for "odd". He wants to put the arrows and choose colors in such a way that the score has the parity of p.
It seems like there will be so many ways which satisfy Kuro. He wants to count the number of them but this could be a very large number. Let's help him with his problem, but print it modulo 10^{9} + 7.
Input
The first line contains two integers n and p (1 ≤ n ≤ 50, 0 ≤ p ≤ 1) — the number of pieces and Kuro's wanted parity.
The second line contains n integers c_{1}, c_{2}, ..., c_{n} (-1 ≤ c_{i} ≤ 1) — the colors of the pieces.
Output
Print a single integer — the number of ways to put the arrows and choose colors so the number of valid paths of alternating colors has the parity of p.
Examples
Input
3 1
-1 0 1
Output
6
Input
2 1
1 0
Output
1
Input
1 1
-1
Output
2
Note
In the first example, there are 6 ways to color the pieces and add the arrows, as are shown in the figure below. The scores are 3, 3, 5 for the first row and 5, 3, 3 for the second row, both from left to right.
<image> | ```python
n,p=map(int,input().split())
nums=[0]+list(map(int,input().split()))
mod=10**9+7
f=[[[[0]*2 for _ in range(2)] for _ in range(2)] for _ in range(n+1)]
_2=[0]*(n+1)
_2[0]=1
for i in range(1,n+1):
_2[i]=(_2[i-1]<<1)%mod
f[0][0][0][0]=1
if nums[1]!=0:
f[1][1][0][1]+=1
if nums[1]!=1:
f[1][1][1][0]+=1
for i in range(2,n+1):
for j in range(2):
for ob in range(2):
for ow in range(2):
qwq=f[i-1][j][ob][ow]
if nums[i]!=0:
if ob:
f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod
f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-2])%mod
else:
f[i][j^1][ob][ow|1]=(f[i][j^1][ob][ow|1]+qwq*_2[i-1])%mod
if nums[i]!=1:
if ow:
f[i][j][ob][ow]=(f[i][j][ob][ow]+qwq*_2[i-2])%mod
f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-2])%mod
else:
f[i][j^1][ob|1][ow]=(f[i][j^1][ob|1][ow]+qwq*_2[i-1])%mod
ans=0
for i in range(2):
for j in range(2):
ans=(ans+f[n][p][i][j])%mod
print(ans)
``` |
999_F. Cards and Joy | There are n players sitting at the card table. Each player has a favorite number. The favorite number of the j-th player is f_j.
There are k ⋅ n cards on the table. Each card contains a single integer: the i-th card contains number c_i. Also, you are given a sequence h_1, h_2, ..., h_k. Its meaning will be explained below.
The players have to distribute all the cards in such a way that each of them will hold exactly k cards. After all the cards are distributed, each player counts the number of cards he has that contains his favorite number. The joy level of a player equals h_t if the player holds t cards containing his favorite number. If a player gets no cards with his favorite number (i.e., t=0), his joy level is 0.
Print the maximum possible total joy levels of the players after the cards are distributed. Note that the sequence h_1, ..., h_k is the same for all the players.
Input
The first line of input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ 10) — the number of players and the number of cards each player will get.
The second line contains k ⋅ n integers c_1, c_2, ..., c_{k ⋅ n} (1 ≤ c_i ≤ 10^5) — the numbers written on the cards.
The third line contains n integers f_1, f_2, ..., f_n (1 ≤ f_j ≤ 10^5) — the favorite numbers of the players.
The fourth line contains k integers h_1, h_2, ..., h_k (1 ≤ h_t ≤ 10^5), where h_t is the joy level of a player if he gets exactly t cards with his favorite number written on them. It is guaranteed that the condition h_{t - 1} < h_t holds for each t ∈ [2..k].
Output
Print one integer — the maximum possible total joy levels of the players among all possible card distributions.
Examples
Input
4 3
1 3 2 8 5 5 8 2 2 8 5 2
1 2 2 5
2 6 7
Output
21
Input
3 3
9 9 9 9 9 9 9 9 9
1 2 3
1 2 3
Output
0
Note
In the first example, one possible optimal card distribution is the following:
* Player 1 gets cards with numbers [1, 3, 8];
* Player 2 gets cards with numbers [2, 2, 8];
* Player 3 gets cards with numbers [2, 2, 8];
* Player 4 gets cards with numbers [5, 5, 5].
Thus, the answer is 2 + 6 + 6 + 7 = 21.
In the second example, no player can get a card with his favorite number. Thus, the answer is 0. | ```python
def solve():
n, k = map(int, input().split())
c = list(map(int, input().split()))
f = list(map(int, input().split()))
h = list(map(int, input().split()))
cnt = {}
for i in c:
cnt[i] = cnt.get(i, 0) + 1
likecolor = {}
for i in range(n):
likecolor.setdefault(f[i], []).append(i)
cnt[f[i]] = cnt.get(f[i], 0)
ans = 0
for key, v in likecolor.items():
n1 = len(v)
if cnt[key] >= n1 * k:
ans += n1 * h[k - 1]
continue
dp = [[-float("INF")] * (cnt[key]+1) for _ in range(n1 + 1)]
dp[0][0] = 0
for i in range(n1):
j = i + 1
for e in range(cnt[key] + 1):
dp[j][e] = max(dp[j][e], dp[i][e])
for w in range(e + 1, min(cnt[key] + 1, e + k + 1)):
dp[j][w] = max(dp[i][e] + h[w - e - 1], dp[j][w])
ans += dp[n1][cnt[key]]
print(ans)
solve()
``` |
p02537 ACL Beginner Contest - Flat Subsequence | You are given a sequence A_1, A_2, ..., A_N and an integer K.
Print the maximum possible length of a sequence B that satisfies the following conditions:
* B is a (not necessarily continuous) subsequence of A.
* For each pair of adjacents elements of B, the absolute difference of the elements is at most K.
Constraints
* 1 \leq N \leq 300,000
* 0 \leq A_i \leq 300,000
* 0 \leq K \leq 300,000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
A_1
A_2
:
A_N
Output
Print the answer.
Example
Input
10 3
1
5
4
3
8
6
9
7
2
4
Output
7 | ```python
import typing
class SegTree:
def __init__(self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]):
self._op = op
self._e = e
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
sml = self._e
smr = self._e
left += self._size
right += self._size
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _ceil_pow2(self, n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
N, K = map(int, input().split())
A = list(int(input()) for _ in range(N))
max_A = max(A)
seg = SegTree(max, -1, [0]*(max_A+1))
for v in A:
l = max(0, v-K)
r = min(max_A, v+K)
seg.set(v, seg.prod(l, r+1)+1)
print(seg.all_prod())
``` |
p02797 Keyence Programming Contest 2020 - Subarray Sum | Given are three integers N, K, and S.
Find a sequence A_1, A_2, ..., A_N of N integers between 1 and 10^9 (inclusive) that satisfies the condition below. We can prove that, under the conditions in Constraints, such a sequence always exists.
* There are exactly K pairs (l, r) of integers such that 1 \leq l \leq r \leq N and A_l + A_{l + 1} + \cdots + A_r = S.
Constraints
* 1 \leq N \leq 10^5
* 0 \leq K \leq N
* 1 \leq S \leq 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K S
Output
Print a sequence satisfying the condition, in the following format:
A_1 A_2 ... A_N
Output
Print a sequence satisfying the condition, in the following format:
A_1 A_2 ... A_N
Examples
Input
4 2 3
Output
1 2 3 4
Input
5 3 100
Output
50 50 50 30 70 | ```python
n, k, s = map(int, input().split())
if s == 10**9:
ans = [10**9]*k+[1]*(n-k)
else:
ans = [s]*k+[s+1]*(n-k)
print(*ans)
``` |
p02933 AtCoder Beginner Contest 138 - Red or Not | You will be given an integer a and a string s consisting of lowercase English letters as input.
Write a program that prints s if a is not less than 3200 and prints `red` if a is less than 3200.
Constraints
* 2800 \leq a < 5000
* s is a string of length between 1 and 10 (inclusive).
* Each character of s is a lowercase English letter.
Input
Input is given from Standard Input in the following format:
a
s
Output
If a is not less than 3200, print s; if a is less than 3200, print `red`.
Examples
Input
3200
pink
Output
pink
Input
3199
pink
Output
red
Input
4049
red
Output
red | ```python
a,s = int(input()),input()
print(s if a>=3200 else "red")
``` |
p03069 Tenka1 Programmer Beginner Contest 2019 - Stones | There are N stones arranged in a row. Every stone is painted white or black. A string S represents the color of the stones. The i-th stone from the left is white if the i-th character of S is `.`, and the stone is black if the character is `#`.
Takahashi wants to change the colors of some stones to black or white so that there will be no white stone immediately to the right of a black stone. Find the minimum number of stones that needs to be recolored.
Constraints
* 1 \leq N \leq 2\times 10^5
* S is a string of length N consisting of `.` and `#`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the minimum number of stones that needs to be recolored.
Examples
Input
3
#.#
Output
1
Input
3
.#
Output
1
Input
5
.##.
Output
2
Input
9
.........
Output
0 | ```python
n = int(input())
s = input()
black = 0
ans = white = s.count('.')
for i in range(n):
if s[i] == "#":
black += 1
else:
white -= 1
ans = min(ans, black+white)
print(ans)
``` |
p03212 AtCoder Beginner Contest 114 - 755 | You are given an integer N. Among the integers between 1 and N (inclusive), how many Shichi-Go-San numbers (literally "Seven-Five-Three numbers") are there?
Here, a Shichi-Go-San number is a positive integer that satisfies the following condition:
* When the number is written in base ten, each of the digits `7`, `5` and `3` appears at least once, and the other digits never appear.
Constraints
* 1 \leq N < 10^9
* N is an integer.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of the Shichi-Go-San numbers between 1 and N (inclusive).
Examples
Input
575
Output
4
Input
3600
Output
13
Input
999999999
Output
26484 | ```python
n = int(input())
def bfs(s):
if int(s) > n:
return 0
return ('3' in s and '5' in s and '7' in s) + bfs(s+'3') + bfs(s+'5') + bfs(s+'7')
print(bfs('0'))
``` |
p03361 AtCoder Beginner Contest 096 - Grid Repainting 2 | We have a canvas divided into a grid with H rows and W columns. The square at the i-th row from the top and the j-th column from the left is represented as (i, j).
Initially, all the squares are white. square1001 wants to draw a picture with black paint. His specific objective is to make Square (i, j) black when s_{i, j}= `#`, and to make Square (i, j) white when s_{i, j}= `.`.
However, since he is not a good painter, he can only choose two squares that are horizontally or vertically adjacent and paint those squares black, for some number of times (possibly zero). He may choose squares that are already painted black, in which case the color of those squares remain black.
Determine if square1001 can achieve his objective.
Constraints
* H is an integer between 1 and 50 (inclusive).
* W is an integer between 1 and 50 (inclusive).
* For every (i, j) (1 \leq i \leq H, 1 \leq j \leq W), s_{i, j} is `#` or `.`.
Input
Input is given from Standard Input in the following format:
H W
s_{1, 1} s_{1, 2} s_{1, 3} ... s_{1, W}
s_{2, 1} s_{2, 2} s_{2, 3} ... s_{2, W}
: :
s_{H, 1} s_{H, 2} s_{H, 3} ... s_{H, W}
Output
If square1001 can achieve his objective, print `Yes`; if he cannot, print `No`.
Examples
Input
3 3
.#.
###
.#.
Output
Yes
Input
3 3
.#.
.#.
Output
Yes
Input
5 5
.#.#
.#.#.
.#.#
.#.#.
.#.#
Output
No
Input
11 11
...#####...
.##.....##.
..##.##..#
..##.##..#
.........#
...###...#
.#########.
.#.#.#.#.#.
.#.#.#.##
..##.#.##..
.##..#..##.
Output
Yes | ```python
import sys
h, w = map(int, input().split())
s = [list(input()) for i in range(h)]
for i in range(h):
for j in range(w):
if s[i][j] == "#" and (i == 0 or s[i-1][j] == ".") and (i == h-1 or s[i+1][j] == ".") and (j == 0 or s[i][j-1] == ".") and (j == w-1 or s[i][j+1] == "."):
print("No")
sys.exit()
print("Yes")
``` |
p03519 CODE FESTIVAL 2017 Elimination Tournament Round 1 (Parallel) - Paired Parentheses | You are given two sequences a and b, both of length 2N. The i-th elements in a and b are a_i and b_i, respectively. Using these sequences, Snuke is doing the job of calculating the beauty of pairs of balanced sequences of parentheses (defined below) of length 2N. The beauty of a pair (s,t) is calculated as follows:
* Let X=0.
* For each i between 1 and 2N (inclusive), increment X by a_i if s_i = t_i, and increment X by b_i otherwise.
* The beauty of (s,t) is the final value of X.
You will be given Q queries. Process them in order. In the i-th query, update the value of a_{p_i} to x_i, and the value of b_{p_i} to y_i. Then, find the maximum possible beauty of a pair of balanced sequences of parentheses.
In this problem, only the sequences below are defined to be balanced sequences of parentheses.
* An empty string
* The concatenation of `(`, s, `)` in this order, where s is a balanced sequence of parentheses
* The concatenation of s, t in this order, where s and t are balanced sequences of parentheses
Constraints
* 1 \leq N,Q \leq 10^{5}
* -10^{9} \leq a_i,b_i,x_i,y_i \leq 10^{9}
* 1 \leq p_i \leq 2N
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N Q
a_1 a_2 ... a_{2N}
b_1 b_2 ... b_{2N}
p_1 x_1 y_1
:
p_Q x_Q y_Q
Output
Print Q lines. The i-th line should contain the response to the i-th query.
Examples
Input
2 2
1 1 7 3
4 2 3 3
2 4 6
3 2 5
Output
15
15
Input
7 7
34 -20 -27 42 44 29 9 11 20 44 27 19 -31 -29
46 -50 -11 20 28 46 12 13 33 -22 -48 -27 35 -17
7 27 34
12 -2 22
4 -50 -12
3 -32 15
8 -7 23
3 -30 11
4 -2 23
Output
311
312
260
286
296
292
327 | ```python
import sys
from heapq import heappop, heappush, heapify
def main():
input = sys.stdin.readline
N, Q = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ls = [b-a for a, b in zip(A, B)]
q_m = [-v for v in ls[1:-1] if v < 0]
q_p = [v for v in ls[1:-1] if v >= 0]
heapify(q_m)
heapify(q_p)
sum_A = sum(A)
sum_q_p = sum(q_p)
to_remove = set()
odd = len(q_p) % 2
Ans = []
ans = sum_A + sum_q_p - (min(q_p[0], q_m[0]) if odd else 0)
for _ in range(Q):
p, x, y = map(int, input().split())
p -= 1
v = y-x
sum_A += x - A[p]
if p==0 or p==2*N-1:
ans += x - A[p]
Ans.append(ans)
A[p] = x
continue
A[p] = x
odd ^= (ls[p] >= 0) ^ (v >= 0)
if v >= 0:
sum_q_p += v
if ls[p] >= 0:
sum_q_p -= ls[p]
to_remove.add(ls[p])
ls[p] = v
if v >= 0:
heappush(q_p, v)
else:
heappush(q_m, -v)
ans = sum_q_p + sum_A
if odd:
while q_p[0] in to_remove:
to_remove.remove(heappop(q_p))
while -q_m[0] in to_remove:
to_remove.remove(-heappop(q_m))
ans -= min(q_p[0], q_m[0])
Ans.append(ans)
print("\n".join(map(str, Ans)))
main()
``` |
p03684 AtCoder Regular Contest 076 - Built? | There are N towns on a plane. The i-th town is located at the coordinates (x_i,y_i). There may be more than one town at the same coordinates.
You can build a road between two towns at coordinates (a,b) and (c,d) for a cost of min(|a-c|,|b-d|) yen (the currency of Japan). It is not possible to build other types of roads.
Your objective is to build roads so that it will be possible to travel between every pair of towns by traversing roads. At least how much money is necessary to achieve this?
Constraints
* 2 ≤ N ≤ 10^5
* 0 ≤ x_i,y_i ≤ 10^9
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
x_1 y_1
x_2 y_2
:
x_N y_N
Output
Print the minimum necessary amount of money in order to build roads so that it will be possible to travel between every pair of towns by traversing roads.
Examples
Input
3
1 5
3 9
7 8
Output
3
Input
6
8 3
4 9
12 19
18 1
13 5
7 6
Output
8 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
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()
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():
N = I()
a = []
b = []
for i in range(N):
x,y = LI()
a.append((x,i))
b.append((y,i))
a.sort()
b.sort()
t = []
for i in range(1,N):
t.append((a[i][0]-a[i-1][0], a[i][1], a[i-1][1]))
t.append((b[i][0]-b[i-1][0], b[i][1], b[i-1][1]))
t.sort()
r = 0
uf = UnionFind(N)
for c,d,e in t:
if uf.union(d,e):
r += c
return r
print(main())
``` |
p03837 AtCoder Beginner Contest 051 - Candidates of No Shortest Paths | You are given an undirected connected weighted graph with N vertices and M edges that contains neither self-loops nor double edges.
The i-th (1≤i≤M) edge connects vertex a_i and vertex b_i with a distance of c_i.
Here, a self-loop is an edge where a_i = b_i (1≤i≤M), and double edges are two edges where (a_i,b_i)=(a_j,b_j) or (a_i,b_i)=(b_j,a_j) (1≤i<j≤M).
A connected graph is a graph where there is a path between every pair of different vertices.
Find the number of the edges that are not contained in any shortest path between any pair of different vertices.
Constraints
* 2≤N≤100
* N-1≤M≤min(N(N-1)/2,1000)
* 1≤a_i,b_i≤N
* 1≤c_i≤1000
* c_i is an integer.
* The given graph contains neither self-loops nor double edges.
* The given graph is connected.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1 c_1
a_2 b_2 c_2
:
a_M b_M c_M
Output
Print the number of the edges in the graph that are not contained in any shortest path between any pair of different vertices.
Examples
Input
3 3
1 2 1
1 3 1
2 3 3
Output
1
Input
3 2
1 2 1
2 3 1
Output
0 | ```python
N, M = map(int, input().split())
inf = 10**6
abc = []
d = [[inf]*N for i in range(N)]
for i in range(M):
a, b, c = map(int, input().split())
d[a-1][b-1] = c
d[b-1][a-1] = c
abc.append((a-1,b-1,c))
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][k]+d[k][j], d[i][j])
ans = 0
for i in range(M):
a, b, c = abc[i]
if d[a][b] < inf and d[a][b] < c:
ans += 1
print(ans)
``` |
p00090 Overlaps of Seals | Stick n circular stickers with a radius of 1 on a square origami paper with a side length of 10. The stickers can be stacked. Create a program that reads the coordinates of the position where the stickers are to be attached and outputs the number of stickers at the place where the stickers overlap most on the origami paper (assuming that even one sticker "overlaps"). ..
Gives the x and y coordinates with the lower left corner of the origami as the origin. Let's put the sticker with these x and y as the center of the circle. The center of the circle never goes out of the origami. Also, multiple stickers will not be attached at the same coordinates.
Hint
It is a figure with a sticker attached as shown in the input example. The circle represents the sticker, and the number represents the number of lines in the input example. At point (2.3, 4.6), the four stickers on the second, third, sixth, and tenth lines of the input example overlap.
<image>
The distance between the centers of 6 and 9 is 2.01293, so the seals do not overlap. The distance between the centers of 1 and 12 is 1.98231, so the seals overlap.
When two circles are in contact (when the distance between the centers is 2), they are assumed to overlap.
Input
Given multiple datasets. Each dataset is given in the following format:
n
x1, y1
x2, y2
::
xn, yn
The first line gives the number of stickers n (0 ≤ 100). The next n lines give the center coordinates of each seal. xi and yi represent the x and y coordinates of the center of the i-th sticker. Each value is given as a real number, including up to 6 digits after the decimal point.
When n is 0, it is the end of the input. The number of datasets does not exceed 50.
Output
For each data set, output the number of stickers (integer) at the place where the stickers overlap most on the origami paper.
Example
Input
15
3.14979,8.51743
2.39506,3.84915
2.68432,5.39095
5.61904,9.16332
7.85653,4.75593
2.84021,5.41511
1.79500,8.59211
7.55389,8.17604
4.70665,4.66125
1.63470,4.42538
7.34959,4.61981
5.09003,8.11122
5.24373,1.30066
0.13517,1.83659
7.57313,1.58150
0
Output
4 | ```python
import itertools
x=[0.]*100;y=[0.]*100
for e in iter(input,'0'):
a=0
n=int(e)
for i in range(n):x[i],y[i]=map(float,input().split(','))
for i,j in itertools.product(range(100),range(100)):
c=0
for k in range(n):
if pow(x[k]-(i/10),2)+pow(y[k]-(j/10),2)<=1.01:c+=1
if c>a:a=c
print(a)
``` |
p00222 Prime Quadruplet | A set of four prime numbers arranged like (a, a + 2, a + 6, a + 8) is called a quadruplet prime number. Of the four prime numbers that make up a quadruplet prime, the largest number is called the size of the quadruplet prime. For example, the smallest prime quadruplet is a set of (5, 7, 11, 13), which is 13 in size. The next largest prime quadruplet is the set of (11, 13, 17, 19), which is 19 in size.
Create a program that takes the integer n (13 ≤ n ≤ 10,000,000) as input and outputs the maximum size of the quadruplet prime numbers whose size is n or less.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. One integer n is given on one row for each dataset.
The number of datasets does not exceed 2000.
Output
Outputs the maximum prime quadruplet size on one line for each input dataset.
Example
Input
13
14
15
16
17
18
19
20
10000
0
Output
13
13
13
13
13
13
19
19
9439 | ```python
# AOJ 0222 Prime Quadruplet
# Python3 2018.6.23 bal4u
# From Wekipedia (https://en.wikipedia.org/wiki/Prime_quadruplet)
# All prime quadruplets except {5, 7, 11, 13} are of the form
# {30n + 11, 30n + 13, 30n + 17, 30n + 19} for some integer n.
MAX = 899
diff = (0,3,3,21,22,13,7,39,7,73, \
126,119,88,3,11,66,29,17,53,42, \
101,214,104,298,252,133,255,141,76,91, \
168,81,45,56,203,301,43,66,291,223, \
92,97,442,290,437,281,38,144,549,241, \
29,192,11,518,266,490,122,130,13,329, \
85,209,71,241,290,18,301,52,120,34, \
50,805,276,217,182,53,209,155,77,468, \
448,29,90,85,91,7,146,21,309,234, \
60,213,511,59,273,364,57,77,87,231, \
452,168,154,346,273,588,11,91,322,335, \
140,221,87,442,297,95,321,498,146,182, \
8,38,11,679,111,120,83,36,59,462, \
32,349,448,333,644,63,101,960,161,759, \
255,354,270,52,200,133,112,297,298,27, \
74,577,25,182,280,584,756,266,287,277, \
119,31,561,59,179,630,34,98,1,84, \
217,234,4,48,127,528,679,35,108,15, \
752,60,31,228,559,7,35,56,43,10, \
151,374,297,294,14,60,196,133,18,63, \
63,17,35,290,953,584,66,102,427,4, \
357,507,441,420,802,14,66,171,252,88, \
14,364,32,220,66,256,427,651,52,287, \
987,214,161,319,241,1333,190,325,63,500, \
1026,60,13,112,238,144,137,349,417,32, \
164,196,115,735,200,382,273,104,119,214, \
665,235,297,665,25,34,211,280,542,375, \
188,42,134,573,350,106,17,112,676,1095, \
403,62,193,60,13,116,60,255,609,350, \
7,165,661,25,748,176,10,283,144,987, \
389,59,60,342,112,144,31,98,676,297, \
652,189,56,34,441,50,314,266,29,546, \
297,39,657,46,703,70,270,221,122,767, \
13,134,318,1222,84,650,371,92,164,760, \
318,175,158,679,496,389,273,38,676,270, \
902,228,143,196,18,287,102,409,612,1, \
56,269,311,714,1092,176,34,165,143,438, \
266,249,97,442,105,7,913,81,80,871, \
497,585,574,11,220,94,855,132,473,836, \
301,7,833,63,1145,60,1886,382,111,43, \
111,319,431,108,297,60,878,799,133,472, \
529,420,241,46,231,304,616,1145,595,447, \
589,76,399,865,154,101,119,739,528,673, \
49,994,412,1072,6,25,3,49,126,1079, \
1141,66,220,932,1049,561,692,764,476,248, \
200,1897,658,644,24,399,143,1331,839,1, \
1077,760,11,34,658,36,647,21,528,242, \
98,529,24,1117,192,396,930,224,365,66, \
557,377,757,322,203,335,770,155,97,21, \
665,484,553,321,207,116,574,272,287,253, \
637,259,38,263,62,1268,451,693,756,630, \
357,105,32,581,455,153,540,350,91,210, \
409,270,377,442,490,615,424,52,890,199, \
102,1746,462,749,24,644,540,220,840,1656, \
223,74,434,179,665,923,428,307,875,50, \
2387,276,109,363,529,550,139,798,176,150, \
297,123,66,266,414,17,130,1344,300,1799, \
8,1176,279,351,461,396,112,626,498,931, \
2782,123,1253,780,781,1119,46,39,847,468, \
1037,1144,63,332,294,1082,525,459,220,70, \
231,31,1029,256,290,662,242,98,252,13, \
1008,64,346,1211,119,802,189,272,298,122, \
697,319,195,273,410,1221,365,885,322,52, \
847,165,112,67,812,630,801,87,60,424, \
630,867,231,123,308,396,76,119,60,203, \
17,63,553,931,147,588,127,437,164,43, \
14,371,115,150,354,315,473,3,1221,245, \
36,272,214,24,385,249,182,445,171,35, \
921,300,1558,1250,129,539,476,94,11,227, \
427,151,102,126,2176,71,297,60,413,195, \
190,944,49,554,1102,676,279,78,143,364, \
357,462,1144,1050,218,423,623,364,416,239, \
143,280,248,365,77,77,1529,157,361,514, \
536,31,330,87,193,514,935,227,18,91, \
104,49,133,1149,104,518,396,1015,143,445, \
360,385,680,49,1053,669,647,931,140,231, \
31,1075,483,627,101,1012,714,346,504,60, \
917,1140,1180,98,297,1029,225,1918,406,188, \
368,466,1305,1117,1028,50,150,273,333,101, \
151,146,1100,119,1532,497,487,235,658,322, \
538,210,701,574,136,220,168,105,603,332, \
409,84,81,39,860,309,384,259,266,207, \
872,377,403,248,819,882,931,148,42,371, \
805,325,668,529,409,3151,2016,14,38,1487, \
350,295,266,343,1833,1887,123,370,260,696, \
137,962,410,132,847,1051,426,39,214,546, \
539,493,325,137,112,889,130,237,43,1183, \
118,371,1,580,316,434,2698,53,98,262, \
203,119,31,189,813,119,195,294,1435,1345, \
531,624,210,231,321,553,11,756,1358)
def bsch(x):
l, r = 0, MAX
while l < r:
m = (l + r) >> 1
if tbl[m] == x: return m
if tbl[m] < x: l = m+1
else: r = m
return l-1;
tbl = [0]*MAX
for i in range(1, MAX): tbl[i] = tbl[i-1] + diff[i]
for i in range(MAX): tbl[i] = tbl[i]*30+19
while 1:
n = int(input())
if n == 0: break
if n < 19: print("13")
else: print(tbl[bsch(n)])
``` |
p00600 Computation of Minimum Length of Pipeline | The Aizu Wakamatsu city office decided to lay a hot water pipeline covering the whole area of the city to heat houses. The pipeline starts from some hot springs and connects every district in the city. The pipeline can fork at a hot spring or a district, but no cycle is allowed. The city office wants to minimize the length of pipeline in order to build it at the least possible expense.
Write a program to compute the minimal length of the pipeline. The program reads an input that consists of the following three parts:
Hint
The first line correspondings to the first part: there are three hot springs and five districts. The following three lines are the second part: the distances between a hot spring and a district. For instance, the distance between the first hot spring and the third district is 25. The last four lines are the third part: the distances between two districts. For instance, the distance between the second and the third districts is 9. The second hot spring and the fourth district are not connectable The second and the fifth districts are not connectable, either.
Input
* The first part consists of two positive integers in one line, which represent the number s of hot springs and the number d of districts in the city, respectively.
* The second part consists of s lines: each line contains d non-negative integers. The i-th integer in the j-th line represents the distance between the j-th hot spring and the i-th district if it is non-zero. If zero it means they are not connectable due to an obstacle between them.
* The third part consists of d-1 lines. The i-th line has d - i non-negative integers. The i-th integer in the j-th line represents the distance between the j-th and the (i + j)-th districts if it is non-zero. The meaning of zero is the same as mentioned above.
For the sake of simplicity, you can assume the following:
* The number of hot springs and that of districts do not exceed 50.
* Each distance is no more than 100.
* Each line in the input file contains at most 256 characters.
* Each number is delimited by either whitespace or tab.
The input has several test cases. The input terminate with a line which has two 0. The number of test cases is less than 20.
Output
Output the minimum length of pipeline for each test case.
Example
Input
3 5
12 8 25 19 23
9 13 16 0 17
20 14 16 10 22
17 27 18 16
9 7 0
19 5
21
0 0
Output
38 | ```python
while(1):
s,d=[int(x) for x in input().split()]
A=[999 for x in range(d)]
if s==0: break
for j in range(s):
l=[int(x) for x in input().split()]
for i in range(d):
if l[i]!=0:
A[i]=min(A[i], l[i])
B=[[999 for x in range(d)] for y in range(d)]
for j in range(d-1):
l=[int(x) for x in input().split()]
for i in range(d-1-j):
if l[i]!=0:
B[j][i+j+1]=l[i]
B[i+j+1][j]=l[i]
notevaled=[1 for x in range(d)]
ans=0
for i in range(d):
mini=A.index(min(A))
ans+=A[mini]
notevaled[mini]=0
A[mini]=999
for x in range(d):
if notevaled[x]:
A[x]=min( A[x], B[mini][x] )
print(ans)
``` |
p00736 How can I satisfy thee? Let me count the ways... | Three-valued logic is a logic system that has, in addition to "true" and "false", "unknown" as a valid value. In the following, logical values "false", "unknown" and "true" are represented by 0, 1 and 2 respectively.
Let "-" be a unary operator (i.e. a symbol representing one argument function) and let both "*" and "+" be binary operators (i.e. symbols representing two argument functions). These operators represent negation (NOT), conjunction (AND) and disjunction (OR) respectively. These operators in three-valued logic can be defined in Table C-1.
Table C-1: Truth tables of three-valued logic operators
-X| | (X*Y)| | (X+Y) | <image>| | <image>| | <image> |
---|---|---|---|---|---
Let P, Q and R be variables ranging over three-valued logic values. For a given formula, you are asked to answer the number of triples (P,Q,R) that satisfy the formula, that is, those which make the value of the given formula 2. A formula is one of the following form (X and Y represent formulas).
* Constants: 0, 1 or 2
* Variables: P, Q or R
* Negations: -X
* Conjunctions: (X*Y)
* Disjunctions: (X+Y)
Note that conjunctions and disjunctions of two formulas are always parenthesized.
For example, when formula (P*Q) is given as an input, the value of this formula is 2 when and only when (P,Q,R) is (2,2,0), (2,2,1) or (2,2,2). Therefore, you should output 3.
Input
The input consists of one or more lines. Each line contains a formula. A formula is a string which consists of 0, 1, 2, P, Q, R, -, *, +, (, ). Other characters such as spaces are not contained. The grammar of formulas is given by the following BNF.
<formula> ::= 0 | 1 | 2 | P | Q | R |
-<formula> | (<formula>*<formula>) | (<formula>+<formula>)
All the formulas obey this syntax and thus you do not have to care about grammatical errors. Input lines never exceed 80 characters.
Finally, a line which contains only a "." (period) comes, indicating the end of the input.
Output
You should answer the number (in decimal) of triples (P,Q,R) that make the value of the given formula 2. One line containing the number should be output for each of the formulas, and no other characters should be output.
Sample Input
(P*Q)
(--R+(P*Q))
(P*-P)
2
1
(-1+(((---P+Q)*(--Q+---R))*(-R+-P)))
.
Output for the Sample Input
3
11
0
27
0
7
Example
Input
(P*Q)
(--R+(P*Q))
(P*-P)
2
1
(-1+(((---P+Q)*(--Q+---R))*(-R+-P)))
.
Output
3
11
0
27
0
7 | ```python
class N:
def __init__(self, a):
self.a = a
def __mul__(self, b):
if self.a == 0:
return N(0)
elif self.a == 1:
return N((b.a >= 1) * 1)
else:
return b
def __add__(self, b):
if self.a == 0:
return b
elif self.a == 1:
return N((b.a > 1) + 1)
else:
return N(2)
def __neg__(self):
if self.a == 2:
return N(0)
elif self.a == 1:
return N(1)
else:
return N(2)
while True:
s = input().replace("-", "-").replace("0", "N(0)").replace("1", "N(1)").replace("2", "N(2)")
N(1) + N(2)
if s == ".": break
result = []
for P in map(N, range(3)):
for Q in map(N, range(3)):
for R in map(N, range(3)):
result.append(eval(s).a)
print(result.count(2))
``` |
p00876 Swimming Jam | Despite urging requests of the townspeople, the municipal office cannot afford to improve many of the apparently deficient city amenities under this recession. The city swimming pool is one of the typical examples. It has only two swimming lanes. The Municipal Fitness Agency, under this circumstances, settled usage rules so that the limited facilities can be utilized fully.
Two lanes are to be used for one-way swimming of different directions. Swimmers are requested to start swimming in one of the lanes, from its one end to the other, and then change the lane to swim his/her way back. When he or she reaches the original starting end, he/she should return to his/her initial lane and starts swimming again.
Each swimmer has his/her own natural constant pace. Swimmers, however, are not permitted to pass other swimmers except at the ends of the pool; as the lanes are not wide enough, that might cause accidents. If a swimmer is blocked by a slower swimmer, he/she has to follow the slower swimmer at the slower pace until the end of the lane is reached. Note that the blocking swimmer’s natural pace may be faster than the blocked swimmer; the blocking swimmer might also be blocked by another swimmer ahead, whose natural pace is slower than the blocked swimmer. Blocking would have taken place whether or not a faster swimmer was between them.
Swimmers can change their order if they reach the end of the lane simultaneously. They change their order so that ones with faster natural pace swim in front. When a group of two or more swimmers formed by a congestion reaches the end of the lane, they are considered to reach there simultaneously, and thus change their order there.
The number of swimmers, their natural paces in times to swim from one end to the other, and the numbers of laps they plan to swim are given. Note that here one "lap" means swimming from one end to the other and then swimming back to the original end. Your task is to calculate the time required for all the swimmers to finish their plans. All the swimmers start from the same end of the pool at the same time, the faster swimmers in front.
In solving this problem, you can ignore the sizes of swimmers' bodies, and also ignore the time required to change the lanes and the order in a group of swimmers at an end of the lanes.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
n
t1 c1
...
tn cn
n is an integer (1 ≤ n ≤ 50) that represents the number of swimmers. ti and ci are integers (1 ≤ ti ≤ 300, 1 ≤ ci ≤ 250) that represent the natural pace in times to swim from one end to the other and the number of planned laps for the i-th swimmer, respectively. ti and ci are separated by a space.
The end of the input is indicated by a line containing one zero.
Output
For each dataset, output the time required for all the swimmers to finish their plans in a line. No extra characters should occur in the output.
Example
Input
2
10 30
15 20
2
10 240
15 160
3
2 6
7 2
8 2
4
2 4
7 2
8 2
18 1
0
Output
600
4800
36
40 | ```python
from collections import deque
while 1:
N = int(input())
if N == 0:
break
T = [0]*N; C = [0]*N
que0 = deque()
que1 = deque()
P = [list(map(int, input().split())) for i in range(N)]
P.sort()
for i in range(N):
t, c = P[i]
que0.append((i, t))
T[i] = t
C[i] = c
INF = 10**18
ans = 0
rest = N
while rest:
t = min(que0[0][1] if que0 else INF, que1[0][1] if que1 else INF)
st0 = []; st1 = []
while que0 and que0[0][1] <= t:
st0.append(que0.popleft()[0])
st0.sort()
for i in st0:
que1.append((i, t+T[i]))
while que1 and que1[0][1] <= t:
st1.append(que1.popleft()[0])
st1.sort()
for i in st1:
if C[i] == 1:
rest -= 1
else:
que0.append((i, t+T[i]))
C[i] -= 1
ans = max(ans, t)
print(ans)
``` |
p01139 Surrounding Area | Surrounding Area
Land fence
English text is not available in this practice contest.
Two real estate agents were boarding a passenger ship to the southern island. Blue sky, refreshing breeze ... The two enjoyed a voyage with other passengers. However, one day a tornado suddenly sank a passenger ship. The other passengers were rescued by the rescue team, but somehow only these two were overlooked. After a few days of drifting, they landed on an uninhabited island. This uninhabited island was rectangular and was divided into grids as shown in the figure below.
Shape of uninhabited island
Figure C-1: Shape of uninhabited island
They were so greedy that they were thinking of selling the land on this uninhabited island rather than calling for help. And they did not split the land in half, but began to scramble for the land. They each began to enclose what they wanted to land on one with black stakes and the other with white stakes. All stakes were struck in the center of the grid, and no stakes were struck in one grid. After a while, both were exhausted and stopped hitting the stakes.
Your job is to write a program to find the area of land surrounded by black and white stakes. However, it is intuitive that the grid (i, j) is surrounded by black stakes. It means that. To be exact, it is defined as follows.
> Define a grid "extended adjacent" to the black stake as follows: The same applies to white stakes.
>
> * If there are no stakes in grid (i, j) and there are black stakes in any of the grids adjacent to grid (i, j), then grid (i, j) extends adjacent to the black stakes. doing.
>
> * If there are no stakes in grid (i, j) and any of the grids adjacent to grid (i, j) are extended adjacent to black stakes, then grid (i, j) is a black stake. It is adjacent to the stake. This rule is applied recursively.
>
>
>
> At this time, when the grid (i, j) is extended adjacent to the black stake and not adjacent to the white stake, and only then, the grid (i, j) is surrounded by the black stake. It is said that there is. Conversely, when the grid (i, j) is extended adjacent to the white stake and not adjacent to the black stake, and only then, the grid (i, j) is surrounded by the white stake. It is said that there is.
Input
The input consists of multiple datasets. Each data set has the following structure.
> w h
> a1,1 a2,1 a3,1 ... aw,1
> a1,2 a2,2 a3,2 ... aw, 2
> ...
> a1, h a2, h a3, h ... aw, h
w is the width of the land and h is the height of the land. These satisfy 1 ≤ w and h ≤ 50. Each ai, j is one half-width character representing the state of the grid (i, j), "` B` "is struck with a black stake, and" `W`" is struck with a white stake. "`.` "(Period) indicates that none of the stakes have been struck.
w = h = 0 represents the end of the input and is not included in the dataset.
Output
For each dataset, print the size of the land surrounded by the black stakes and the size of the land surrounded by the white stakes on one line, separated by a single space.
Sample Input
10 10
..... W ....
.... W.W ...
... W ... W ..
.... W ... W.
..... W ... W
...... W.W.
BBB .... W ..
..B..BBBBB
..B .... B ....
..B..B..W.
5 3
... B.
... BB
.....
1 1
..
0 0
Output for the Sample Input
6 21
12 0
0 0
Example
Input
10 10
.....W....
....W.W...
...W...W..
....W...W.
.....W...W
......W.W.
BBB....W..
..B..BBBBB
..B..B....
..B..B..W.
5 3
...B.
...BB
.....
1 1
.
0 0
Output
6 21
12 0
0 0 | ```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**6)
def dfs(x, y, symbol,land):
if land[y][x] != '.':
return ([land[y][x]] if not str(land[y][x]).isnumeric() else False), 0
land[y][x] = symbol
count = 1
dxdy = [(1,0),(-1,0),(0,1),(0,-1)]
owner_list = []
for dx,dy in dxdy:
if 0 <= x + dx < len(land[0]) and 0 <= y + dy < len(land):
ret,c = dfs(x + dx, y + dy, symbol,land)
count += c
if ret is not False:
owner_list += ret
return (list(set(owner_list)), count)
while True:
w,h = map(int,input().split())
if w == 0 and h == 0:
break
land = [list(input()) for i in range(0,h)]
symbol = 0
count_dict = {'W' :0, 'B' :0}
for y in range(h):
for x in range(w):
if land[y][x] == '.':
ret, count = dfs(x,y,symbol,land)
if len(ret) == 1:
count_dict[ret[0]] += count
symbol += 1
print(count_dict['B'],count_dict['W'])
``` |
p01278 Voronoi Island | Some of you know an old story of Voronoi Island. There were N liege lords and they are always involved in territorial disputes. The residents of the island were despaired of the disputes.
One day, a clever lord proposed to stop the disputes and divide the island fairly. His idea was to divide the island such that any piece of area belongs to the load of the nearest castle. The method is called Voronoi Division today.
Actually, there are many aspects of whether the method is fair. According to one historian, the clever lord suggested the method because he could gain broader area than other lords.
Your task is to write a program to calculate the size of the area each lord can gain. You may assume that Voronoi Island has a convex shape.
Input
The input consists of multiple datasets. Each dataset has the following format:
N M
Ix1 Iy1
Ix2 Iy2
...
IxN IyN
Cx1 Cy1
Cx2 Cy2
...
CxM CyM
N is the number of the vertices of Voronoi Island; M is the number of the liege lords; (Ixi, Iyi) denotes the coordinate of the i-th vertex; (Cxi, Cyi ) denotes the coordinate of the castle of the i-the lord.
The input meets the following constraints: 3 ≤ N ≤ 10, 2 ≤ M ≤ 10, -100 ≤ Ixi, Iyi, Cxi, Cyi ≤ 100. The vertices are given counterclockwise. All the coordinates are integers.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, print the area gained by each liege lord with an absolute error of at most 10-4 . You may output any number of digits after the decimal point. The order of the output areas must match that of the lords in the input.
Example
Input
3 3
0 0
8 0
0 8
2 2
4 2
2 4
0 0
Output
9.0
11.5
11.5 | ```python
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def cross3(O, A, B):
ox, oy = O; ax, ay = A; bx, by = B
return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def cross_point(p0, p1, q0, q1):
x0, y0 = p0; x1, y1 = p1
x2, y2 = q0; x3, y3 = q1
dx0 = x1 - x0; dy0 = y1 - y0
dx1 = x3 - x2; dy1 = y3 - y2
s = (y0-y2)*dx1 - (x0-x2)*dy1
sm = dx0*dy1 - dy0*dx1
if -EPS < sm < EPS:
return None
return x0 + s*dx0/sm, y0 + s*dy0/sm
EPS = 1e-9
def convex_cut(P, line):
q0, q1 = line
N = len(P)
Q = []
for i in range(N):
p0 = P[i-1]; p1 = P[i]
cv0 = cross3(q0, q1, p0)
cv1 = cross3(q0, q1, p1)
if cv0 * cv1 < EPS:
v = cross_point(q0, q1, p0, p1)
if v is not None:
Q.append(v)
if cv1 > -EPS:
Q.append(p1)
return Q
def polygon_area(P):
s = 0
N = len(P)
for i in range(N):
p0 = P[i-1]; p1 = P[i]
s += p0[0]*p1[1] - p0[1]*p1[0]
return abs(s) / 2
def solve():
N, M = map(int, input().split())
if N == M == 0:
return False
P = [list(map(int, readline().split())) for i in range(N)]
Q = [list(map(int, readline().split())) for i in range(M)]
for i in range(M):
x0, y0 = Q[i]
P0 = P
for j in range(M):
if i == j:
continue
x1, y1 = Q[j]
ax = (x0 + x1) / 2; ay = (y0 + y1) / 2
q0 = (ax, ay)
q1 = (ax - (y1 - y0), ay + (x1 - x0))
P0 = convex_cut(P0, (q0, q1))
write("%.16f\n" % polygon_area(P0))
return True
while solve():
...
``` |
p01448 A Way to Invite Friends | From tomorrow, the long-awaited summer vacation will begin. So I decided to invite my friends to go out to the sea.
However, many of my friends are shy. They would hate it if they knew that too many people would come with them.
Besides, many of my friends want to stand out. They will probably hate it if they know that not many people come with them.
Also, some of my friends are always shy, though they always want to stand out. They will surely hate if too many or too few people come with them.
This kind of thing should be more fun to do in large numbers. That's why I want to invite as many friends as possible. However, it is not good to force a friend you dislike.
How many friends can I invite up to?
I'm not very good at this kind of problem that seems to use my head. So I have a request for you. If you don't mind, could you solve this problem for me? No, I'm not overdoing it. But if I'm slacking off, I'm very happy.
Input
N
a1 b1
a2 b2
..
..
..
aN bN
The integer N (1 ≤ N ≤ 100,000) is written on the first line of the input. This represents the number of friends.
On the following N lines, the integer ai and the integer bi (2 ≤ ai ≤ bi ≤ 100,001) are written separated by blanks. The integers ai and bi written on the 1 + i line indicate that the i-th friend does not want to go to the sea unless the number of people going to the sea is ai or more and bi or less. Note that the number of people going to the sea includes "I".
Output
Output the maximum number of friends you can invite to the sea so that no friends dislike it.
Examples
Input
4
2 5
4 7
2 4
3 6
Output
3
Input
5
8 100001
7 100001
12 100001
8 100001
3 100001
Output
0
Input
6
2 9
4 8
6 7
6 6
5 7
2 100001
Output
5 | ```python
n = int(input())
l = [0 for i in range(n+2)]
for i in range(n):
[a,b] = list(map(int,input().split()))
if a <= n+1:
l[a] += 1
if b+1 <= n+1:
l[b+1] -= 1
ans = 0
for i in range(n+2):
if i != 0:
l[i] = l[i-1] + l[i]
if l[i] >= i-1:
ans = i-1
print(ans)
``` |
p01754 Dinner | In the spring of 2014, a student successfully passed the university and started living alone. The problem here is what to do with the supper. He decided to plan a supper for the next N days.
He wants to maximize the total happiness he gets in N days. Of course, the more delicious or favorite you eat, the higher your happiness.
His dinner options are two, either head to a nearby dining room or cook for himself.
The happiness you get in the cafeteria depends on the menu of the day. The menu changes daily, but there is only one type every day, and all the menus for N days have already been released. So he knows all the information that if you go to the cafeteria on day i (1 ≤ i ≤ N) you will get the happiness of Ci.
The happiness obtained by self-catering is the self-catering power at the start of self-catering multiplied by a constant P. The initial value of self-catering power is Q, which is -1 if you go to the restaurant every day, +1 if you cook yourself, and fluctuates at the end of the meal of the day.
Find the maximum sum of happiness for him.
Constraints
* 1 ≤ N ≤ 500,000
* 0 ≤ P ≤ 500,000
* | Q | ≤ 500,000
* | Ci | ≤ 500,000
Input
The input is given in the following format as N + 1 line.
N P Q
C1
C2
::
CN
* The first line is given three integers N, P, and Q, which are the number of days, the constant for calculating the happiness of self-catering, and the initial value of self-catering power.
* From the 2nd line to the N + 1st line, one integer is given, and the i + 1st line gives the happiness obtained when going to the cafeteria on the i day.
Output
Output the maximum value of happiness that can be taken in one line.
Examples
Input
1 1 1
2
Output
2
Input
3 2 1
3
3
3
Output
12
Input
3 1 -1
2
-3
2
Output
2
Input
3 1 -10
-10
-10
-10
Output
-27 | ```python
tmp = list(map(int,input().split()))
n,p,q = tmp[0],tmp[1],tmp[2]
cs = []
for i in range(n):
cs.append(int(input()))
ans = [sum(cs)]
difs = [p * (q-i) - cs[i] for i in range(n)]
difs.sort(reverse = True)
for i in range(n):
ans.append(ans[-1] + 2 * i * p + difs[i])
print(max(ans))
``` |
p02031 Parentheses Number | B: Parentheses Number
problem
Define the correct parenthesis string as follows:
* The empty string is the correct parenthesis string
* For the correct parenthesis string S, `(` S `)` is the correct parenthesis string
* For correct parentheses S, T ST is the correct parentheses
Here, the permutations are associated with the correct parentheses according to the following rules.
* When the i-th closing brace corresponds to the j-th opening brace, the i-th value in the sequence is j.
Given a permutation of length n, P = (p_1, p_2, $ \ ldots $, p_n), restore the corresponding parenthesis string.
However, if the parenthesis string corresponding to the permutation does not exist, output `: (`.
Input format
n
p_1 p_2 $ \ ldots $ p_n
The number of permutations n is given in the first row.
Permutations p_1, p_2, $ \ ldots $, p_i, $ \ ldots $, p_n are given in the second row, separated by blanks.
Constraint
* 1 \ leq n \ leq 10 ^ 5
* 1 \ leq p_i \ leq n
* All inputs are integers.
* P = (p_1, p_2, $ \ ldots $, p_n) is a permutation.
Output format
Output the parenthesized string corresponding to the permutation.
Print `: (` if such a parenthesis string does not exist.
Input example 1
2
twenty one
Output example 1
(())
Input example 2
Ten
1 2 3 4 5 6 7 8 9 10
Output example 2
() () () () () () () () () ()
Input example 3
3
3 1 2
Output example 3
:(
Example
Input
2
2 1
Output
(()) | ```python
n = int(input())
a = list(map(int,input().split()))
cnt = 0
ans = ''
st = list()
for x in a:
while cnt < x:
ans += '('
cnt += 1
st.append(cnt)
if st[-1] == x:
st.pop()
ans += ')'
else:
ans = ':('
break
print(ans)
``` |
p02174 Power Subsequences | Problem
Define a function $ f $ that starts with $ 1 $ and takes a sequence of finite lengths as an argument as follows.
$ \ displaystyle f (\\ {a_1, a_2, \ ldots, a_n \\}) = \ sum_ {i = 1} ^ n {a_i} ^ i $
Given a sequence of length $ N $, $ X = \\ {x_1, x_2, \ ldots, x_N \\} $, $ f (X) for all subsequences $ X'$ except empty columns. ') Find $ and output the sum of them divided by $ 998244353 $. However, the subsequence subsequences shall be renumbered starting from $ 1 $ while maintaining the relative order in the original sequence. Also, even if two subsequences are the same as columns, if they are taken out at different positions, they shall be counted separately.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq N \ leq 10 ^ 6 $
* $ 1 \ leq x_i \ leq 10 ^ 6 $
* All inputs are integers
Input
The input is given in the following format.
$ N $
$ x_1 $ $ \ ldots $ $ x_N $
The first line is given the length $ N $. In the second row, the elements of the sequence $ X $ are given, separated by blanks.
Output
Find $ f (X') $ for all subsequences $ X'$ except empty columns, and divide the sum by $ 998244353 $ to output the remainder.
Examples
Input
3
1 2 3
Output
64
Input
5
100 200 300 400 500
Output
935740429 | ```python
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 998244353
def solve():
n = I()
x = LI()
ans = 0
for i in range(n):
xi = x[i]
ans += pow(2,n-i-1,mod)*xi*pow(xi+1,i,mod)
if ans >= mod:
ans %= mod
print(ans)
return
if __name__ == "__main__":
solve()
``` |
p02317 Longest Increasing Subsequence | For a given sequence A = {a0, a1, ... , an-1}, find the length of the longest increasing subsequnece (LIS) in A.
An increasing subsequence of A is defined by a subsequence {ai0, ai1, ... , aik} where 0 ≤ i0 < i1 < ... < ik < n and ai0 < ai1 < ... < aik.
Constraints
* 1 ≤ n ≤ 100000
* 0 ≤ ai ≤ 109
Input
n
a0
a1
:
an-1
In the first line, an integer n is given. In the next n lines, elements of A are given.
Output
The length of the longest increasing subsequence of A.
Examples
Input
5
5
1
3
2
4
Output
3
Input
3
1
1
1
Output
1 | ```python
N = int(input())
A = [int(input()) for _ in range(N)]
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
def solve(N,A):
lis = []
for i in range(N):
ind = bisect_left(lis,A[i])
if ind == len(lis):
lis.append(A[i])
else:
lis[ind] = A[i]
ans = len(lis)
return ans
print(solve(N,A))
``` |
p02462 Multi-Map | For a dictionary $M$ that stores elements formed by a pair of a string key and an integer value, perform a sequence of the following operations. Note that multiple elements can have equivalent keys.
* insert($key$, $x$): Insert an element formed by a pair of $key$ and $x$ to $M$.
* get($key$): Print all values with the specified $key$.
* delete($key$): Delete all elements with the specified $key$.
* dump($L$, $R$): Print all elements formed by a pair of the key and the value such that the key is greater than or equal to $L$ and less than or equal to $R$ in lexicographic order.
Constraints
* $1 \leq q \leq 200,000$
* $1 \leq x \leq 1,000,000,000$
* $1 \leq $ length of $key$ $ \leq 20$
* $key$ consists of lower-case letters
* $L \leq R$ in lexicographic order
* The total number of elements printed by get operations does not exceed $500,000$
* The total number of elements printed by dump operations does not exceed $500,000$
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $key$ $x$
or
1 $key$
or
2 $key$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, get, delete and dump operations.
Output
For each get operation, print the corresponding values in the order of insertions.
For each dump operation, print the corresponding elements formed by a pair of the key and the value. For the dump operation, print the elements in ascending order of the keys, in case of a tie, in the order of insertions.
Example
Input
10
0 blue 6
0 red 1
0 blue 4
0 white 5
1 red
1 blue
2 red
1 black
1 red
3 w z
Output
1
6
4
white 5 | ```python
# -*- coding: utf-8 -*-
"""
Dictionary - Multi-Map
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ITP2_8_D&lang=jp
"""
from bisect import insort, bisect_right, bisect_left
class Multi_map:
def __init__(self):
self.mm = dict()
self.lr = []
def insert(self, x, y):
if x in self.mm:
self.mm[x].append(y)
else:
self.mm[x] = [y]
insort(self.lr, x)
def get(self, x):
if x in self.mm and self.mm[x] != []:
print(*self.mm[x], sep='\n')
def delete(self, x):
if x in self.mm:
self.mm[x] = []
def dump(self, l, r):
lb = bisect_left(self.lr, l)
ub = bisect_right(self.lr, r)
for i in range(lb, ub):
k = self.lr[i]
for v in self.mm[k]:
print(f'{k} {v}')
mm = Multi_map()
for _ in range(int(input())):
op, x, y = (input() + ' 1').split()[:3]
if op == '0':
mm.insert(x, int(y))
elif op == '1':
mm.get(x)
elif op == '2':
mm.delete(x)
else:
mm.dump(x, y)
``` |
1003_E. Tree Constructing | You are given three integers n, d and k.
Your task is to construct an undirected tree on n vertices with diameter d and degree of each vertex at most k, or say that it is impossible.
An undirected tree is a connected undirected graph with n - 1 edges.
Diameter of a tree is the maximum length of a simple path (a path in which each vertex appears at most once) between all pairs of vertices of this tree.
Degree of a vertex is the number of edges incident to this vertex (i.e. for a vertex u it is the number of edges (u, v) that belong to the tree, where v is any other vertex of a tree).
Input
The first line of the input contains three integers n, d and k (1 ≤ n, d, k ≤ 4 ⋅ 10^5).
Output
If there is no tree satisfying the conditions above, print only one word "NO" (without quotes).
Otherwise in the first line print "YES" (without quotes), and then print n - 1 lines describing edges of a tree satisfying the conditions above. Vertices of the tree must be numbered from 1 to n. You can print edges and vertices connected by an edge in any order. If there are multiple answers, print any of them.1
Examples
Input
6 3 3
Output
YES
3 1
4 1
1 2
5 2
2 6
Input
6 2 3
Output
NO
Input
10 4 3
Output
YES
2 9
2 10
10 3
3 1
6 10
8 2
4 3
5 6
6 7
Input
8 5 3
Output
YES
2 5
7 2
3 7
3 1
1 6
8 7
4 3 | ```python
def main():
n, d, k = map(int, input().split())
r, odd = divmod(d, 2)
k -= 1
cap = d + 1 if k == 1 else 1
if k > 1:
cap = 2 * (k ** (r + 1) - 1) // (k - 1) if odd else 1 + (k + 1) * (k ** r - 1) // (k - 1)
if n == 1 or k < 1 < n - 1 or k == 1 and d != n - 1 or d >= n or k > 1 and not d < n <= cap:
print('NO')
return
def dfs(parent, depth):
stack = []
for _ in range(k - 1):
child = rest.pop()
res.append('%s %s' % (parent, child))
if depth:
stack.append((child, depth))
while stack:
parent, depth = stack.pop()
depth -= 1
for _ in range(k):
child = rest.pop()
res.append('%s %s' % (parent, child))
if depth:
stack.append((child, depth))
res = ['YES']
for pc in enumerate(range(2, d + 2), 1):
res.append('%d %d' % pc)
rest = list(range(n, d + 1, -1))
try:
for p in range(r + 1, r + odd + 2):
dfs(p, r - 1)
for de, p, q in zip(range(r - 2, -1, -1), range(r, 1, -1), range(r + odd + 2, d + 1)):
dfs(p, de)
dfs(q, de)
except IndexError:
pass
print('\n'.join(res))
if __name__ == '__main__':
main()
``` |
1070_D. Garbage Disposal | Enough is enough. Too many times it happened that Vasya forgot to dispose of garbage and his apartment stank afterwards. Now he wants to create a garbage disposal plan and stick to it.
For each of next n days Vasya knows a_i — number of units of garbage he will produce on the i-th day. Each unit of garbage must be disposed of either on the day it was produced or on the next day. Vasya disposes of garbage by putting it inside a bag and dropping the bag into a garbage container. Each bag can contain up to k units of garbage. It is allowed to compose and drop multiple bags into a garbage container in a single day.
Being economical, Vasya wants to use as few bags as possible. You are to compute the minimum number of bags Vasya needs to dispose of all of his garbage for the given n days. No garbage should be left after the n-th day.
Input
The first line of the input contains two integers n and k (1 ≤ n ≤ 2⋅10^5, 1 ≤ k ≤ 10^9) — number of days to consider and bag's capacity. The second line contains n space separated integers a_i (0 ≤ a_i ≤ 10^9) — the number of units of garbage produced on the i-th day.
Output
Output a single integer — the minimum number of bags Vasya needs to dispose of all garbage. Each unit of garbage should be disposed on the day it was produced or on the next day. No garbage can be left after the n-th day. In a day it is allowed to compose and drop multiple bags.
Examples
Input
3 2
3 2 1
Output
3
Input
5 1
1000000000 1000000000 1000000000 1000000000 1000000000
Output
5000000000
Input
3 2
1 0 1
Output
2
Input
4 4
2 8 4 1
Output
4 | ```python
import sys
n, k = tuple(int(i) for i in sys.stdin.readline().split())
a = tuple(int(i) for i in sys.stdin.readline().split())
assert len(a) == n
bags = 0
r = 0
for ai in a:
leftovers = (r > 0)
q, r = divmod(ai + r, k)
if q == 0:
if leftovers:
bags += 1
r = 0
else:
bags += q
if r > 0:
bags += 1
print(bags)
``` |
1140_C. Playlist | You have a playlist consisting of n songs. The i-th song is characterized by two numbers t_i and b_i — its length and beauty respectively. The pleasure of listening to set of songs is equal to the total length of the songs in the set multiplied by the minimum beauty among them. For example, the pleasure of listening to a set of 3 songs having lengths [5, 7, 4] and beauty values [11, 14, 6] is equal to (5 + 7 + 4) ⋅ 6 = 96.
You need to choose at most k songs from your playlist, so the pleasure of listening to the set of these songs them is maximum possible.
Input
The first line contains two integers n and k (1 ≤ k ≤ n ≤ 3 ⋅ 10^5) – the number of songs in the playlist and the maximum number of songs you can choose, respectively.
Each of the next n lines contains two integers t_i and b_i (1 ≤ t_i, b_i ≤ 10^6) — the length and beauty of i-th song.
Output
Print one integer — the maximum pleasure you can get.
Examples
Input
4 3
4 7
15 1
3 6
6 8
Output
78
Input
5 3
12 31
112 4
100 100
13 55
55 50
Output
10000
Note
In the first test case we can choose songs {1, 3, 4}, so the total pleasure is (4 + 3 + 6) ⋅ 6 = 78.
In the second test case we can choose song 3. The total pleasure will be equal to 100 ⋅ 100 = 10000. | ```python
import heapq
n,k=map(int,input().split())
b_l=[]
for _ in range(n):
t,b=map(int,input().split())
b_l.append([b,t])
b_l.sort(reverse=True)
ans=0
sum_fg=0
h=[]
heapq.heapify(h)
for i in range(n):
sum_fg+=b_l[i][1]
heapq.heappush(h,b_l[i][1])
while(len(h)>k):
g=heapq.heappop(h)
sum_fg-=g
beauty=b_l[i][0]
ans=max(ans,sum_fg*beauty)
print(ans)
``` |
1159_A. A pile of stones | Vasya has a pile, that consists of some number of stones. n times he either took one stone from the pile or added one stone to the pile. The pile was non-empty before each operation of taking one stone from the pile.
You are given n operations which Vasya has made. Find the minimal possible number of stones that can be in the pile after making these operations.
Input
The first line contains one positive integer n — the number of operations, that have been made by Vasya (1 ≤ n ≤ 100).
The next line contains the string s, consisting of n symbols, equal to "-" (without quotes) or "+" (without quotes). If Vasya took the stone on i-th operation, s_i is equal to "-" (without quotes), if added, s_i is equal to "+" (without quotes).
Output
Print one integer — the minimal possible number of stones that can be in the pile after these n operations.
Examples
Input
3
---
Output
0
Input
4
++++
Output
4
Input
2
-+
Output
1
Input
5
++-++
Output
3
Note
In the first test, if Vasya had 3 stones in the pile at the beginning, after making operations the number of stones will be equal to 0. It is impossible to have less number of piles, so the answer is 0. Please notice, that the number of stones at the beginning can't be less, than 3, because in this case, Vasya won't be able to take a stone on some operation (the pile will be empty).
In the second test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 4. It is impossible to have less number of piles because after making 4 operations the number of stones in the pile increases on 4 stones. So, the answer is 4.
In the third test, if Vasya had 1 stone in the pile at the beginning, after making operations the number of stones will be equal to 1. It can be proved, that it is impossible to have less number of stones after making the operations.
In the fourth test, if Vasya had 0 stones in the pile at the beginning, after making operations the number of stones will be equal to 3. | ```python
'''
t= input()
lng= len(t)
li1=[]; li2=[]
for i in range(lng):
if t[i]!='a':
li1.append(t[i])
elif t[i]=='a':
li2.append(i)
aa= ''.join(li1)
if len(aa)==0:
print(t); exit(0)
if len(aa)%2==1:
print(':('); exit(0)
if len(aa)%2==0:
#print(123)
l= int(len(aa)/2); lp= l#; print(l)
ll= aa[l:]; lll=aa[0:l] #; print(ll)
if ll!=lll:
print(':('); exit(0)
if ll not in t:
print(':('); exit(0)
tp= t[::-1]; tc= ll[::-1]#; print(tp,tc)
if tp.find(tc)!=0:
print(':('); exit(0)
if tp.find(tc)==0:
ul= len(tc)
lu= tp[ul:][::-1]
print(lu); exit(0)
'''
n= int(input()); s= input(); ln= len(s); sv=0
for i in s:
if i=='+':
sv+=1
if i=='-' and sv>0:
sv-=1
print(sv)
``` |
1181_A. Chunga-Changa | Soon after the Chunga-Changa island was discovered, it started to acquire some forms of civilization and even market economy. A new currency arose, colloquially called "chizhik". One has to pay in chizhiks to buy a coconut now.
Sasha and Masha are about to buy some coconuts which are sold at price z chizhiks per coconut. Sasha has x chizhiks, Masha has y chizhiks. Each girl will buy as many coconuts as she can using only her money. This way each girl will buy an integer non-negative number of coconuts.
The girls discussed their plans and found that the total number of coconuts they buy can increase (or decrease) if one of them gives several chizhiks to the other girl. The chizhiks can't be split in parts, so the girls can only exchange with integer number of chizhiks.
Consider the following example. Suppose Sasha has 5 chizhiks, Masha has 4 chizhiks, and the price for one coconut be 3 chizhiks. If the girls don't exchange with chizhiks, they will buy 1 + 1 = 2 coconuts. However, if, for example, Masha gives Sasha one chizhik, then Sasha will have 6 chizhiks, Masha will have 3 chizhiks, and the girls will buy 2 + 1 = 3 coconuts.
It is not that easy to live on the island now, so Sasha and Mash want to exchange with chizhiks in such a way that they will buy the maximum possible number of coconuts. Nobody wants to have a debt, so among all possible ways to buy the maximum possible number of coconuts find such a way that minimizes the number of chizhiks one girl gives to the other (it is not important who will be the person giving the chizhiks).
Input
The first line contains three integers x, y and z (0 ≤ x, y ≤ 10^{18}, 1 ≤ z ≤ 10^{18}) — the number of chizhics Sasha has, the number of chizhics Masha has and the price of a coconut.
Output
Print two integers: the maximum possible number of coconuts the girls can buy and the minimum number of chizhiks one girl has to give to the other.
Examples
Input
5 4 3
Output
3 1
Input
6 8 2
Output
7 0
Note
The first example is described in the statement. In the second example the optimal solution is to dot exchange any chizhiks. The girls will buy 3 + 4 = 7 coconuts. | ```python
x,y,z=map(int,input().split())
sum=(x+y)//z
i1=x//z
i2=y//z
x=x%z
y=y%z
current=i1+i2
nu=0
if current==sum:
print(sum,end=' ')
print(nu)
else:
if x>y:
h=x
else:
h=y
current=sum-current
current=current*z
nu=current-h
print(sum, end=' ')
print(nu)
``` |
1216_E1. Numerical Sequence (easy version) | The only difference between the easy and the hard versions is the maximum value of k.
You are given an infinite sequence of form "112123123412345..." which consist of blocks of all consecutive positive integers written one after another. The first block consists of all numbers from 1 to 1, the second one — from 1 to 2, the third one — from 1 to 3, ..., the i-th block consists of all numbers from 1 to i.
So the first 56 elements of the sequence are "11212312341234512345612345671234567812345678912345678910". Elements of the sequence are numbered from one. For example, the 1-st element of the sequence is 1, the 3-rd element of the sequence is 2, the 20-th element of the sequence is 5, the 38-th element is 2, the 56-th element of the sequence is 0.
Your task is to answer q independent queries. In the i-th query you are given one integer k_i. Calculate the digit at the position k_i of the sequence.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 500) — the number of queries.
The i-th of the following q lines contains one integer k_i (1 ≤ k_i ≤ 10^9) — the description of the corresponding query.
Output
Print q lines. In the i-th line print one digit x_i (0 ≤ x_i ≤ 9) — the answer to the query i, i.e. x_i should be equal to the element at the position k_i of the sequence.
Examples
Input
5
1
3
20
38
56
Output
1
2
5
2
0
Input
4
2132
506
999999999
1000000000
Output
8
2
9
8
Note
Answers on queries from the first example are described in the problem statement. | ```python
def isqrt(x):
if x < 0:
raise ValueError('square root not defined for negative numbers')
n = int(x)
if n == 0:
return 0
a, b = divmod(n.bit_length(), 2)
x = 2**(a+b)
while True:
y = (x + n//x)//2
if y >= x:
return x
x = y
p = [0, 45, 9045, 1395495, 189414495, 23939649495, 2893942449495, 339393974949495, 38939394344949495, 1000000000000000001];
nx = [0, 9, 189, 2889, 38889, 488889, 5888889, 68888889, 788888889, 8888888889]
q = int(input())
for ut in range(q):
lk = int(input())
k = lk
idx = 0;
for i in range(len(p)-1):
if (p[i] <= k) and (p[i + 1] > k):
idx = i;
idx = idx;
k-=1
k -= p[idx];
a = idx + 1
b = 2 * nx[idx] + idx + 1;
k = -2 * k;
d = isqrt(b*b-4 * a*k);
x1 = (-b + d) / (2. * a);
x2 = (-b - d) / (2. * a);
a1 = int(x1);
z = lk - p[idx] - nx[idx] * a1 - (a1 * (a1 + 1) // 2) * (idx + 1);
cnt = 0
ww = 1
pow = 0;
pow = 1;
while ((cnt + pow * ww) * 9 < z) :
cnt += pow * ww;
ww+=1
pow *= 10;
sym_cnt = (z - (cnt * 9)) - 1;
ok = (pow)+sym_cnt / ww;
s = str(ok);
if (z < 10):
print(z)
else:
print(s[sym_cnt % ww])
``` |
125_A. Measuring Lengths in Baden | Lengths are measures in Baden in inches and feet. To a length from centimeters it is enough to know that an inch equals three centimeters in Baden and one foot contains 12 inches.
You are given a length equal to n centimeters. Your task is to convert it to feet and inches so that the number of feet was maximum. The result should be an integer rounded to the closest value containing an integral number of inches.
Note that when you round up, 1 cm rounds up to 0 inches and 2 cm round up to 1 inch.
Input
The only line contains an integer n (1 ≤ n ≤ 10000).
Output
Print two non-negative space-separated integers a and b, where a is the numbers of feet and b is the number of inches.
Examples
Input
42
Output
1 2
Input
5
Output
0 2 | ```python
n=int(input())
e=(n+1)//36
n-=36*e
print(e,(n+1)//3)
``` |
1281_C. Cut and Paste | We start with a string s consisting only of the digits 1, 2, or 3. The length of s is denoted by |s|. For each i from 1 to |s|, the i-th character of s is denoted by s_i.
There is one cursor. The cursor's location ℓ is denoted by an integer in \{0, …, |s|\}, with the following meaning:
* If ℓ = 0, then the cursor is located before the first character of s.
* If ℓ = |s|, then the cursor is located right after the last character of s.
* If 0 < ℓ < |s|, then the cursor is located between s_ℓ and s_{ℓ+1}.
We denote by s_left the string to the left of the cursor and s_right the string to the right of the cursor.
We also have a string c, which we call our clipboard, which starts out as empty. There are three types of actions:
* The Move action. Move the cursor one step to the right. This increments ℓ once.
* The Cut action. Set c ← s_right, then set s ← s_left.
* The Paste action. Append the value of c to the end of the string s. Note that this doesn't modify c.
The cursor initially starts at ℓ = 0. Then, we perform the following procedure:
1. Perform the Move action once.
2. Perform the Cut action once.
3. Perform the Paste action s_ℓ times.
4. If ℓ = x, stop. Otherwise, return to step 1.
You're given the initial string s and the integer x. What is the length of s when the procedure stops? Since this value may be very large, only find it modulo 10^9 + 7.
It is guaranteed that ℓ ≤ |s| at any time.
Input
The first line of input contains a single integer t (1 ≤ t ≤ 1000) denoting the number of test cases. The next lines contain descriptions of the test cases.
The first line of each test case contains a single integer x (1 ≤ x ≤ 10^6). The second line of each test case consists of the initial string s (1 ≤ |s| ≤ 500). It is guaranteed, that s consists of the characters "1", "2", "3".
It is guaranteed that the sum of x in a single file is at most 10^6. It is guaranteed that in each test case before the procedure will stop it will be true that ℓ ≤ |s| at any time.
Output
For each test case, output a single line containing a single integer denoting the answer for that test case modulo 10^9 + 7.
Example
Input
4
5
231
7
2323
6
333
24
133321333
Output
25
1438
1101
686531475
Note
Let's illustrate what happens with the first test case. Initially, we have s = 231. Initially, ℓ = 0 and c = \varepsilon (the empty string). The following things happen if we follow the procedure above:
* Step 1, Move once: we get ℓ = 1.
* Step 2, Cut once: we get s = 2 and c = 31.
* Step 3, Paste s_ℓ = 2 times: we get s = 23131.
* Step 4: ℓ = 1 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 2.
* Step 2, Cut once: we get s = 23 and c = 131.
* Step 3, Paste s_ℓ = 3 times: we get s = 23131131131.
* Step 4: ℓ = 2 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 3.
* Step 2, Cut once: we get s = 231 and c = 31131131.
* Step 3, Paste s_ℓ = 1 time: we get s = 23131131131.
* Step 4: ℓ = 3 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 4.
* Step 2, Cut once: we get s = 2313 and c = 1131131.
* Step 3, Paste s_ℓ = 3 times: we get s = 2313113113111311311131131.
* Step 4: ℓ = 4 not= x = 5, so we return to step 1.
* Step 1, Move once: we get ℓ = 5.
* Step 2, Cut once: we get s = 23131 and c = 13113111311311131131.
* Step 3, Paste s_ℓ = 1 times: we get s = 2313113113111311311131131.
* Step 4: ℓ = 5 = x, so we stop.
At the end of the procedure, s has length 25. | ```python
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
MAX=10**9+7
def solve():
x = int(input())
s = [int(i) for i in input()]
ans=len(s)
c = ""
l = 0
while l < x:
l += 1
k=len(s)
if k < x:
#s += s[l:]*(s[l - 1]-1)
for i in range(s[l-1] - 1):
for j in range(l, k):
s.append(s[j])
ans+= (s[l - 1]-1) *(ans - l)
ans%=MAX
print(ans)
t=int(input())
for _ in range(t):
solve()
#
# mod = 10 ** 9 + 7
#
#
# def solve():
# x = int(input())
# s = [int(i) for i in input()]
# ans = len(s)
# cur = -1
# while cur != x - 1:
# cur += 1
# if len(s) < x:
# k = len(s)
# for _ in range(s[cur] - 1):
# for j in range(cur + 1, k):
# s.append(s[j])
# ans += (s[cur] - 1) * (ans - (cur + 1))
# ans %= mod
# print(ans)
#
#
# t = int(input())
# for i in range(t):
# solve()
``` |
1301_C. Ayoub's function | Ayoub thinks that he is a very smart person, so he created a function f(s), where s is a binary string (a string which contains only symbols "0" and "1"). The function f(s) is equal to the number of substrings in the string s that contains at least one symbol, that is equal to "1".
More formally, f(s) is equal to the number of pairs of integers (l, r), such that 1 ≤ l ≤ r ≤ |s| (where |s| is equal to the length of string s), such that at least one of the symbols s_l, s_{l+1}, …, s_r is equal to "1".
For example, if s = "01010" then f(s) = 12, because there are 12 such pairs (l, r): (1, 2), (1, 3), (1, 4), (1, 5), (2, 2), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 4), (4, 5).
Ayoub also thinks that he is smarter than Mahmoud so he gave him two integers n and m and asked him this problem. For all binary strings s of length n which contains exactly m symbols equal to "1", find the maximum value of f(s).
Mahmoud couldn't solve the problem so he asked you for help. Can you help him?
Input
The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^5) — the number of test cases. The description of the test cases follows.
The only line for each test case contains two integers n, m (1 ≤ n ≤ 10^{9}, 0 ≤ m ≤ n) — the length of the string and the number of symbols equal to "1" in it.
Output
For every test case print one integer number — the maximum value of f(s) over all strings s of length n, which has exactly m symbols, equal to "1".
Example
Input
5
3 1
3 2
3 3
4 0
5 2
Output
4
5
6
0
12
Note
In the first test case, there exists only 3 strings of length 3, which has exactly 1 symbol, equal to "1". These strings are: s_1 = "100", s_2 = "010", s_3 = "001". The values of f for them are: f(s_1) = 3, f(s_2) = 4, f(s_3) = 3, so the maximum value is 4 and the answer is 4.
In the second test case, the string s with the maximum value is "101".
In the third test case, the string s with the maximum value is "111".
In the fourth test case, the only string s of length 4, which has exactly 0 symbols, equal to "1" is "0000" and the value of f for that string is 0, so the answer is 0.
In the fifth test case, the string s with the maximum value is "01010" and it is described as an example in the problem statement. | ```python
'''input
5
3 1
3 2
3 3
4 0
5 2
'''
import sys
read = lambda: list(map(int,sys.stdin.readline().strip().split()))
# try:
sigma = lambda x:x*(x+1)//2
for _ in range(int(input())):
n,m = read()
k = n-m
total = sigma(n)
# if m==0 or m==n:
# print(total)
# continue
if k>m:
e,f = divmod(k,m+1)
total -= (m+1-f)*sigma(e)+f*sigma(e+1)
else:
total -= k
print(total)
``` |
1325_C. Ehab and Path-etic MEXs | You are given a tree consisting of n nodes. You want to write some labels on the tree's edges such that the following conditions hold:
* Every label is an integer between 0 and n-2 inclusive.
* All the written labels are distinct.
* The largest value among MEX(u,v) over all pairs of nodes (u,v) is as small as possible.
Here, MEX(u,v) denotes the smallest non-negative integer that isn't written on any edge on the unique simple path from node u to node v.
Input
The first line contains the integer n (2 ≤ n ≤ 10^5) — the number of nodes in the tree.
Each of the next n-1 lines contains two space-separated integers u and v (1 ≤ u,v ≤ n) that mean there's an edge between nodes u and v. It's guaranteed that the given graph is a tree.
Output
Output n-1 integers. The i^{th} of them will be the number written on the i^{th} edge (in the input order).
Examples
Input
3
1 2
1 3
Output
0
1
Input
6
1 2
1 3
2 4
2 5
5 6
Output
0
3
2
4
1
Note
The tree from the second sample:
<image> | ```python
n = int(input())
occ = [0 for i in range(n)]
graph = [[0,0] for i in range(n-1)]
for i in range(n-1):
x, y = map(int,input().split())
occ[x-1]+=1
occ[y-1]+=1
graph[i][0] = x-1
graph[i][1] = y-1
fin = [-1 for i in range(n-1)]
for i in range(n):
if occ[i] >= 3 :
var = 0
for j in range(n-1):
if graph[j][0] == i or graph[j][1] == i:
fin[j] = var
var += 1
break
else:
var = 0
for i in range(n):
if var > 1:
break
if occ[i] == 1:
for j in range(n-1):
if graph[j][0] == i or graph[j][1] == i:
fin[j] = var
var += 1
break
for i in fin:
if n == 2:
print(0)
break
if i == -1:
print(var)
var += 1
else:
print(i)
``` |
1344_B. Monopole Magnets | A monopole magnet is a magnet that only has one pole, either north or south. They don't actually exist since real magnets have two poles, but this is a programming contest problem, so we don't care.
There is an n× m grid. Initially, you may place some north magnets and some south magnets into the cells. You are allowed to place as many magnets as you like, even multiple in the same cell.
An operation is performed as follows. Choose a north magnet and a south magnet to activate. If they are in the same row or the same column and they occupy different cells, then the north magnet moves one unit closer to the south magnet. Otherwise, if they occupy the same cell or do not share a row or column, then nothing changes. Note that the south magnets are immovable.
Each cell of the grid is colored black or white. Let's consider ways to place magnets in the cells so that the following conditions are met.
1. There is at least one south magnet in every row and every column.
2. If a cell is colored black, then it is possible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
3. If a cell is colored white, then it is impossible for a north magnet to occupy this cell after some sequence of operations from the initial placement.
Determine if it is possible to place magnets such that these conditions are met. If it is possible, find the minimum number of north magnets required (there are no requirements on the number of south magnets).
Input
The first line contains two integers n and m (1≤ n,m≤ 1000) — the number of rows and the number of columns, respectively.
The next n lines describe the coloring. The i-th of these lines contains a string of length m, where the j-th character denotes the color of the cell in row i and column j. The characters "#" and "." represent black and white, respectively. It is guaranteed, that the string will not contain any other characters.
Output
Output a single integer, the minimum possible number of north magnets required.
If there is no placement of magnets that satisfies all conditions, print a single integer -1.
Examples
Input
3 3
.#.
###
##.
Output
1
Input
4 2
##
.#
.#
##
Output
-1
Input
4 5
....#
####.
.###.
.#...
Output
2
Input
2 1
.
#
Output
-1
Input
3 5
.....
.....
.....
Output
0
Note
In the first test, here is an example placement of magnets:
<image>
In the second test, we can show that no required placement of magnets exists. Here are three example placements that fail to meet the requirements. The first example violates rule 3 since we can move the north magnet down onto a white square. The second example violates rule 2 since we cannot move the north magnet to the bottom-left black square by any sequence of operations. The third example violates rule 1 since there is no south magnet in the first column.
<image>
In the third test, here is an example placement of magnets. We can show that there is no required placement of magnets with fewer north magnets.
<image>
In the fourth test, we can show that no required placement of magnets exists. Here are two example placements that fail to meet the requirements. The first example violates rule 1 since there is no south magnet in the first row. The second example violates rules 1 and 3 since there is no south magnet in the second row and we can move the north magnet up one unit onto a white square.
<image>
In the fifth test, we can put the south magnet in each cell and no north magnets. Because there are no black cells, it will be a correct placement. | ```python
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/6/16
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def check(row):
start, end = 0, len(row) - 1
while start < len(row) and row[start] == 0:
start += 1
if start >= len(row):
return True, True
while end >= start and row[end] == 0:
end -= 1
for i in range(start, end):
if row[i] == 0:
return False, False
return True, False
def solve(N, M, A):
blankrow = []
for r in range(N):
row = A[r]
a, b = check(row)
if not a:
return -1
if b:
blankrow.append(r)
blankcol = []
for c in range(M):
col = [A[r][c] for r in range(N)]
a, b = check(col)
if not a:
return -1
if b:
blankcol.append(c)
if (len(blankcol) > 0 and len(blankrow) == 0) or (len(blankrow) > 0 and len(blankcol) == 0):
return -1
if len(blankcol) * len(blankrow) == N * M:
return 0
for r in blankrow:
for c in blankcol:
A[r][c] = 2
idx = 2
for r in range(N):
for c in range(M):
if A[r][c] == 1:
idx += 1
A[r][c] = idx
q = [(r, c)]
while q:
nq = []
for x, y in q:
for nx, ny in [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]:
if 0 <= nx < N and 0 <= ny < M and A[nx][ny] == 1:
A[nx][ny] = idx
nq.append((nx, ny))
q = nq
# for row in A:
# print(' '.join(map(str, row)))
return idx - 2
if __name__ == '__main__':
N, M = map(int, input().split())
A = []
for i in range(N):
row = [1 if v == '#' else 0 for v in list(input())]
A.append(row)
print(solve(N, M, A))
``` |
1366_B. Shuffle | You are given an array consisting of n integers a_1, a_2, ..., a_n. Initially a_x = 1, all other elements are equal to 0.
You have to perform m operations. During the i-th operation, you choose two indices c and d such that l_i ≤ c, d ≤ r_i, and swap a_c and a_d.
Calculate the number of indices k such that it is possible to choose the operations so that a_k = 1 in the end.
Input
The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Then the description of t testcases follow.
The first line of each test case contains three integers n, x and m (1 ≤ n ≤ 10^9; 1 ≤ m ≤ 100; 1 ≤ x ≤ n).
Each of next m lines contains the descriptions of the operations; the i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ n).
Output
For each test case print one integer — the number of indices k such that it is possible to choose the operations so that a_k = 1 in the end.
Example
Input
3
6 4 3
1 6
2 3
5 5
4 1 2
2 4
1 2
3 3 2
2 3
1 2
Output
6
2
3
Note
In the first test case, it is possible to achieve a_k = 1 for every k. To do so, you may use the following operations:
1. swap a_k and a_4;
2. swap a_2 and a_2;
3. swap a_5 and a_5.
In the second test case, only k = 1 and k = 2 are possible answers. To achieve a_1 = 1, you have to swap a_1 and a_1 during the second operation. To achieve a_2 = 1, you have to swap a_1 and a_2 during the second operation. | ```python
from __future__ import division, print_function
# import threading
# threading.stack_size(2**27)
# import sys
# sys.setrecursionlimit(10**7)
# sys.stdin = open('inpy.txt', 'r')
# sys.stdout = open('outpy.txt', 'w')
from sys import stdin, stdout
import bisect #c++ upperbound
import math
import heapq
i_m=9223372036854775807
def inin():
return int(input())
def stin():
return input()
def spin():
return map(int,stin().split())
def lin(): #takes array as input
return list(map(int,stin().split()))
def matrix(n):
#matrix input
return [list(map(int,input().split()))for i in range(n)]
################################################
def count2Dmatrix(i,list):
return sum(c.count(i) for c in list)
def modinv(n,p):
return pow(n,p-2,p)
def GCD(x, y):
x=abs(x)
y=abs(y)
if(min(x,y)==0):
return max(x,y)
while(y):
x, y = y, x % y
return x
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
prime=[]
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return f
q=[]
def dfs(n,d,v,c):
global q
v[n]=1
x=d[n]
q.append(n)
j=c
for i in x:
if i not in v:
f=dfs(i,d,v,c+1)
j=max(j,f)
# print(f)
return j
# d = {}
"""*******************************************************"""
for _ in range(inin()):
n, x, m = spin()
l0, r0 = x, x
for i in range(m):
l, r = spin()
if max(l, l0) <= min(r, r0):
l0 = min(l, l0)
r0 = max(r, r0)
print(r0 - l0 + 1)
# arr = [0] * (n+1)
# arr[x] = 1
# c = 0
# l1 = 10**9; r1 = -10**9
# for i in range(1, m+1, 1):
# l, r = spin()
# # print(arr[l:r+1])
# if arr[l:r+1].count(1)>=1 or (l<=l1 or r>=r1) :
# if arr[l:r+1].count(1)>=1:
# l1 = min(l1, l)
# r1 = max(r1, r)
# elif l1<=l<=r1 or l1<=r<=r1:
# l1 = min(l1, l)
# r1 = max(r1, r)
# # print(l1, r1)
# # for j in range(l,r+1,1):
# # arr[j] = 1
# # print(arr[1:])
# print(abs(l1-r1)+1)
``` |
1408_B. Arrays Sum | You are given a non-decreasing array of non-negative integers a_1, a_2, …, a_n. Also you are given a positive integer k.
You want to find m non-decreasing arrays of non-negative integers b_1, b_2, …, b_m, such that:
* The size of b_i is equal to n for all 1 ≤ i ≤ m.
* For all 1 ≤ j ≤ n, a_j = b_{1, j} + b_{2, j} + … + b_{m, j}. In the other word, array a is the sum of arrays b_i.
* The number of different elements in the array b_i is at most k for all 1 ≤ i ≤ m.
Find the minimum possible value of m, or report that there is no possible m.
Input
The first line contains one integer t (1 ≤ t ≤ 100): the number of test cases.
The first line of each test case contains two integers n, k (1 ≤ n ≤ 100, 1 ≤ k ≤ n).
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_1 ≤ a_2 ≤ … ≤ a_n ≤ 100, a_n > 0).
Output
For each test case print a single integer: the minimum possible value of m. If there is no such m, print -1.
Example
Input
6
4 1
0 0 0 1
3 1
3 3 3
11 3
0 1 2 2 3 3 3 4 4 4 4
5 3
1 2 3 4 5
9 4
2 2 3 5 7 11 13 13 17
10 7
0 1 1 2 3 3 4 5 5 6
Output
-1
1
2
2
2
1
Note
In the first test case, there is no possible m, because all elements of all arrays should be equal to 0. But in this case, it is impossible to get a_4 = 1 as the sum of zeros.
In the second test case, we can take b_1 = [3, 3, 3]. 1 is the smallest possible value of m.
In the third test case, we can take b_1 = [0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2] and b_2 = [0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2]. It's easy to see, that a_i = b_{1, i} + b_{2, i} for all i and the number of different elements in b_1 and in b_2 is equal to 3 (so it is at most 3). It can be proven that 2 is the smallest possible value of m. | ```python
import sys as _sys
def main():
t = int(input())
for i_t in range(t):
n, k = _read_ints()
a = tuple(_read_ints())
try:
result = find_min_m(a, k)
except ValueError:
result = -1
print(result)
def _read_line():
result = _sys.stdin.readline()
assert result[-1] == "\n"
return result[:-1]
def _read_ints():
return map(int, _read_line().split(" "))
def find_min_m(a_seq, k):
assert k >= 1
a_seq = tuple(a_seq)
if a_seq.count(0) == len(a_seq):
return 0
steps_n = sum(x1 != x2 for x1, x2 in zip(a_seq, a_seq[1:]))
if k == 1:
if steps_n == 0:
return 1
else:
raise ValueError("can't find min m")
result = 0
steps_per_b_seq = k - 1
if a_seq[0] != 0:
steps_n += 1
if steps_n <= k:
return 1
steps_n -= k
result += 1
result += _ceil_div(steps_n, steps_per_b_seq)
return result
def _ceil_div(x, y):
assert y > 0
result = x // y
if x % y != 0:
result += 1
return result
if __name__ == '__main__':
main()
``` |
1428_E. Carrots for Rabbits | There are some rabbits in Singapore Zoo. To feed them, Zookeeper bought n carrots with lengths a_1, a_2, a_3, …, a_n. However, rabbits are very fertile and multiply very quickly. Zookeeper now has k rabbits and does not have enough carrots to feed all of them. To solve this problem, Zookeeper decided to cut the carrots into k pieces. For some reason, all resulting carrot lengths must be positive integers.
Big carrots are very difficult for rabbits to handle and eat, so the time needed to eat a carrot of size x is x^2.
Help Zookeeper split his carrots while minimizing the sum of time taken for rabbits to eat the carrots.
Input
The first line contains two integers n and k (1 ≤ n ≤ k ≤ 10^5): the initial number of carrots and the number of rabbits.
The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^6): lengths of carrots.
It is guaranteed that the sum of a_i is at least k.
Output
Output one integer: the minimum sum of time taken for rabbits to eat carrots.
Examples
Input
3 6
5 3 1
Output
15
Input
1 4
19
Output
91
Note
For the first test, the optimal sizes of carrots are \{1,1,1,2,2,2\}. The time taken is 1^2+1^2+1^2+2^2+2^2+2^2=15
For the second test, the optimal sizes of carrots are \{4,5,5,5\}. The time taken is 4^2+5^2+5^2+5^2=91. | ```python
import sys
from heapq import heapify, heappush, heappop
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10
N, K = MAP()
A = LIST()
def calc(a, cnt):
d, m = divmod(a, cnt)
return d**2 * (cnt-m) + (d+1)**2 * m
que = []
for a in A:
if a // 2 == 0:
que.append((0, 1, a))
else:
que.append((calc(a, 2) - calc(a, 1), 1, a))
heapify(que)
for _ in range(K-N):
val, cnt, a = heappop(que)
if a // (cnt+2) == 0:
heappush(que, (0, cnt+1, a))
else:
heappush(que, (calc(a, cnt+2) - calc(a, cnt+1), cnt+1, a))
ans = 0
for _, cnt, a in que:
ans += calc(a, cnt)
print(ans)
``` |
1451_F. Nullify The Matrix | Jeel and Ashish play a game on an n × m matrix. The rows are numbered 1 to n from top to bottom and the columns are numbered 1 to m from left to right. They play turn by turn. Ashish goes first.
Initially, each cell of the matrix contains a non-negative integer. Each turn, a player must perform all of the following actions in order.
* Choose a starting cell (r_1, c_1) with non-zero value.
* Choose a finishing cell (r_2, c_2) such that r_1 ≤ r_2 and c_1 ≤ c_2.
* Decrease the value of the starting cell by some positive non-zero integer.
* Pick any of the shortest paths between the two cells and either increase, decrease or leave the values of cells on this path unchanged. Note that:
* a shortest path is one that passes through the least number of cells;
* all cells on this path excluding the starting cell, but the finishing cell may be modified;
* the resulting value of each cell must be a non-negative integer;
* the cells are modified independently and not necessarily by the same value.
If the starting and ending cells are the same, then as per the rules, the value of the cell is decreased. No other operations are performed.
The game ends when all the values become zero. The player who is unable to make a move loses. It can be shown that the game will end in a finite number of moves if both players play optimally.
Given the initial matrix, if both players play optimally, can you predict who will win?
Input
The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases. The description of each test case is as follows.
The first line of each test case contains two integers n and m (1 ≤ n, m ≤ 100) — the dimensions of the matrix.
The next n lines contain m space separated integers a_{i,j} (0 ≤ a_{i,j} ≤ 10^6) — the values of each cell of the matrix.
Output
For each test case, if Ashish wins the game, print "Ashish", otherwise print "Jeel" (without the quotes).
Example
Input
4
1 1
0
1 3
0 0 5
2 2
0 1
1 0
3 3
1 2 3
4 5 6
7 8 9
Output
Jeel
Ashish
Jeel
Ashish
Note
In the first test case, the only cell of the matrix is 0. There are no moves Ashish can make. Jeel is the winner.
In the second test case, Ashish can choose (r_1, c_1) = (r_2, c_2) = (1,3) and reduce the cell to 0, leaving [0, 0, 0]. Jeel cannot perform any moves. Ashish wins. | ```python
def solve_case():
n, m = [int(x) for x in input().split()]
a = [[int(x) for x in input().split()] for x in range(n)]
xr = [0] * (n + m)
for i in range(n):
for j in range(m):
xr[i + j] ^= a[i][j]
return sum(xr) > 0
def main():
for _ in range(int(input())):
print(['Jeel', 'Ashish'][solve_case()])
main()
``` |
1475_E. Advertising Agency | Masha works in an advertising agency. In order to promote the new brand, she wants to conclude contracts with some bloggers. In total, Masha has connections of n different bloggers. Blogger numbered i has a_i followers.
Since Masha has a limited budget, she can only sign a contract with k different bloggers. Of course, Masha wants her ad to be seen by as many people as possible. Therefore, she must hire bloggers with the maximum total number of followers.
Help her, find the number of ways to select k bloggers so that the total number of their followers is maximum possible. Two ways are considered different if there is at least one blogger in the first way, which is not in the second way. Masha believes that all bloggers have different followers (that is, there is no follower who would follow two different bloggers).
For example, if n=4, k=3, a=[1, 3, 1, 2], then Masha has two ways to select 3 bloggers with the maximum total number of followers:
* conclude contracts with bloggers with numbers 1, 2 and 4. In this case, the number of followers will be equal to a_1 + a_2 + a_4 = 6.
* conclude contracts with bloggers with numbers 2, 3 and 4. In this case, the number of followers will be equal to a_2 + a_3 + a_4 = 6.
Since the answer can be quite large, output it modulo 10^9+7.
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then t test cases follow.
The first line of each test case contains two integers n and k (1 ≤ k ≤ n ≤ 1000) — the number of bloggers and how many of them you can sign a contract with.
The second line of each test case contains n integers a_1, a_2, … a_n (1 ≤ a_i ≤ n) — the number of followers of each blogger.
It is guaranteed that the sum of n over all test cases does not exceed 1000.
Output
For each test case, on a separate line output one integer — the number of ways to select k bloggers so that the total number of their followers is maximum possible.
Example
Input
3
4 3
1 3 1 2
4 2
1 1 1 1
2 1
1 2
Output
2
6
1
Note
The test case is explained in the statements.
In the second test case, the following ways are valid:
* conclude contracts with bloggers with numbers 1 and 2. In this case, the number of followers will be equal to a_1 + a_2 = 2;
* conclude contracts with bloggers with numbers 1 and 3. In this case, the number of followers will be equal to a_1 + a_3 = 2;
* conclude contracts with bloggers with numbers 1 and 4. In this case, the number of followers will be equal to a_1 + a_4 = 2;
* conclude contracts with bloggers with numbers 2 and 3. In this case, the number of followers will be equal to a_2 + a_3 = 2;
* conclude contracts with bloggers with numbers 2 and 4. In this case, the number of followers will be equal to a_2 + a_4 = 2;
* conclude contracts with bloggers with numbers 3 and 4. In this case, the number of followers will be equal to a_3 + a_4 = 2.
In the third test case, the following ways are valid:
* concludes a contract with a blogger with the number 2. In this case, the number of followers will be equal to a_2 = 2. | ```python
import math
def c (k, n):
return (math.factorial(n) // (math.factorial(k) * math.factorial(n - k))) % (10**9 + 7)
def solve():
n, k = map(int, input().split())
a = []
for i in input().split():
a.append(int(i))
a.sort()
m = dict()
for i in a:
if(m.get(i, 0) == 0): m[i] = 1
else: m[i] += 1
ind = n - k
while ind < n - 1 and a[ind + 1] == a[ind]: ind += 1
print(c(ind - (n - k) + 1, m[a[n - k]]))
t = int(input())
while t > 0:
t -= 1
solve()
``` |
1525_E. Assimilation IV | Monocarp is playing a game "Assimilation IV". In this game he manages a great empire: builds cities and conquers new lands.
Monocarp's empire has n cities. In order to conquer new lands he plans to build one Monument in each city. The game is turn-based and, since Monocarp is still amateur, he builds exactly one Monument per turn.
Monocarp has m points on the map he'd like to control using the constructed Monuments. For each point he knows the distance between it and each city. Monuments work in the following way: when built in some city, a Monument controls all points at distance at most 1 to this city. Next turn, the Monument controls all points at distance at most 2, the turn after — at distance at most 3, and so on. Monocarp will build n Monuments in n turns and his empire will conquer all points that are controlled by at least one Monument.
Monocarp can't figure out any strategy, so during each turn he will choose a city for a Monument randomly among all remaining cities (cities without Monuments). Monocarp wants to know how many points (among m of them) he will conquer at the end of turn number n. Help him to calculate the expected number of conquered points!
Input
The first line contains two integers n and m (1 ≤ n ≤ 20; 1 ≤ m ≤ 5 ⋅ 10^4) — the number of cities and the number of points.
Next n lines contains m integers each: the j-th integer of the i-th line d_{i, j} (1 ≤ d_{i, j} ≤ n + 1) is the distance between the i-th city and the j-th point.
Output
It can be shown that the expected number of points Monocarp conquers at the end of the n-th turn can be represented as an irreducible fraction x/y. Print this fraction modulo 998 244 353, i. e. value x ⋅ y^{-1} mod 998244353 where y^{-1} is such number that y ⋅ y^{-1} mod 998244353 = 1.
Example
Input
3 5
1 4 4 3 4
1 4 1 4 2
1 4 4 4 3
Output
166374062
Note
Let's look at all possible orders of cities Monuments will be build in:
* [1, 2, 3]:
* the first city controls all points at distance at most 3, in other words, points 1 and 4;
* the second city controls all points at distance at most 2, or points 1, 3 and 5;
* the third city controls all points at distance at most 1, or point 1.
In total, 4 points are controlled.
* [1, 3, 2]: the first city controls points 1 and 4; the second city — points 1 and 3; the third city — point 1. In total, 3 points.
* [2, 1, 3]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — point 1. In total, 3 points.
* [2, 3, 1]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — point 1. In total, 3 points.
* [3, 1, 2]: the first city controls point 1; the second city — points 1 and 3; the third city — points 1 and 5. In total, 3 points.
* [3, 2, 1]: the first city controls point 1; the second city — points 1, 3 and 5; the third city — points 1 and 5. In total, 3 points.
The expected number of controlled points is (4 + 3 + 3 + 3 + 3 + 3)/(6) = 19/6 or 19 ⋅ 6^{-1} ≡ 19 ⋅ 166374059 ≡ 166374062 \pmod{998244353} | ```python
ans = 0
n,m = map(int,input().split())
mod = 998244353
a = [list(map(int,input().split())) for i in range(n)]
fac = 1
for i in range(1,n+1): fac *= i
inv = pow(fac,mod-2,mod)
for j in range(m):
na = sorted([a[i][j] for i in range(n)])
now = 1
able = 0
for i in range(n):
while len(na) > 0 and na[-1] > n-i:
del na[-1]
able += 1
now *= able
able -= 1
ans += now * inv
ans %= mod
print ((m-ans) % mod)
``` |
157_B. Trace | One day, as Sherlock Holmes was tracking down one very important criminal, he found a wonderful painting on the wall. This wall could be represented as a plane. The painting had several concentric circles that divided the wall into several parts. Some parts were painted red and all the other were painted blue. Besides, any two neighboring parts were painted different colors, that is, the red and the blue color were alternating, i. e. followed one after the other. The outer area of the wall (the area that lied outside all circles) was painted blue. Help Sherlock Holmes determine the total area of red parts of the wall.
Let us remind you that two circles are called concentric if their centers coincide. Several circles are called concentric if any two of them are concentric.
Input
The first line contains the single integer n (1 ≤ n ≤ 100). The second line contains n space-separated integers ri (1 ≤ ri ≤ 1000) — the circles' radii. It is guaranteed that all circles are different.
Output
Print the single real number — total area of the part of the wall that is painted red. The answer is accepted if absolute or relative error doesn't exceed 10 - 4.
Examples
Input
1
1
Output
3.1415926536
Input
3
1 4 2
Output
40.8407044967
Note
In the first sample the picture is just one circle of radius 1. Inner part of the circle is painted red. The area of the red part equals π × 12 = π.
In the second sample there are three circles of radii 1, 4 and 2. Outside part of the second circle is painted blue. Part between the second and the third circles is painted red. Part between the first and the third is painted blue. And, finally, the inner part of the first circle is painted red. Overall there are two red parts: the ring between the second and the third circles and the inner part of the first circle. Total area of the red parts is equal (π × 42 - π × 22) + π × 12 = π × 12 + π = 13π | ```python
n=int(input())
s=0
X=[int(x) for x in input().split(" ")]
X.sort(reverse=True)
for i in range(n):
s=s+(-1)**(i)*X[i]*X[i]
print(3.1415926536*s)
``` |
178_A2. Educational Game | The Smart Beaver from ABBYY began to develop a new educational game for children. The rules of the game are fairly simple and are described below.
The playing field is a sequence of n non-negative integers ai numbered from 1 to n. The goal of the game is to make numbers a1, a2, ..., ak (i.e. some prefix of the sequence) equal to zero for some fixed k (k < n), and this should be done in the smallest possible number of moves.
One move is choosing an integer i (1 ≤ i ≤ n) such that ai > 0 and an integer t (t ≥ 0) such that i + 2t ≤ n. After the values of i and t have been selected, the value of ai is decreased by 1, and the value of ai + 2t is increased by 1. For example, let n = 4 and a = (1, 0, 1, 2), then it is possible to make move i = 3, t = 0 and get a = (1, 0, 0, 3) or to make move i = 1, t = 1 and get a = (0, 0, 2, 2) (the only possible other move is i = 1, t = 0).
You are given n and the initial sequence ai. The task is to calculate the minimum number of moves needed to make the first k elements of the original sequence equal to zero for each possible k (1 ≤ k < n).
Input
The first input line contains a single integer n. The second line contains n integers ai (0 ≤ ai ≤ 104), separated by single spaces.
The input limitations for getting 20 points are:
* 1 ≤ n ≤ 300
The input limitations for getting 50 points are:
* 1 ≤ n ≤ 2000
The input limitations for getting 100 points are:
* 1 ≤ n ≤ 105
Output
Print exactly n - 1 lines: the k-th output line must contain the minimum number of moves needed to make the first k elements of the original sequence ai equal to zero.
Please do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams, or the %I64d specifier.
Examples
Input
4
1 0 1 2
Output
1
1
3
Input
8
1 2 3 4 5 6 7 8
Output
1
3
6
10
16
24
40 | ```python
from math import log
n=int(input())
s=list(map(int,input().split( )))
p=[]
for i in range(0,n-1):
m=(log(n-1-i,2))//1
p.append(i+2**m)
for k in range(1,n):
g=0
f=s[:]
for i in range(0,k):
g+=f[i]
f[int(p[i])]+=f[i]
print(g)
``` |
19_C. Deletion of Repeats | Once Bob saw a string. It contained so many different letters, that the letters were marked by numbers, but at the same time each letter could be met in the string at most 10 times. Bob didn't like that string, because it contained repeats: a repeat of length x is such a substring of length 2x, that its first half coincides character by character with its second half. Bob started deleting all the repeats from the string. He does it as follows: while it's possible, Bob takes the shortest repeat, if it is not unique, he takes the leftmost one, and deletes its left half and everything that is to the left of this repeat.
You're given the string seen by Bob. Find out, what it will look like after Bob deletes all the repeats in the way described above.
Input
The first input line contains integer n (1 ≤ n ≤ 105) — length of the string. The following line contains n space-separated integer numbers from 0 to 109 inclusive — numbers that stand for the letters of the string. It's guaranteed that each letter can be met in the string at most 10 times.
Output
In the first line output the length of the string's part, left after Bob's deletions. In the second line output all the letters (separated by a space) of the string, left after Bob deleted all the repeats in the described way.
Examples
Input
6
1 2 3 1 2 3
Output
3
1 2 3
Input
7
4 5 6 5 6 7 7
Output
1
7 | ```python
def pow(x, exp, mod):
res = 1
while exp:
if exp & 1:
res = (res * x) % mod
x = (x * x) % mod
exp >>= 1
return res
MOD = 2 ** 121 - 1
M = int(1e9) + 1
n = int(input())
vals = list(map(int, input().split()))
groups = dict()
for i in range(n):
groups.setdefault(vals[i], []).append(i)
powsA = [1]
for i in range(n):
powsA.append((powsA[-1] * M) % MOD)
hashes = [0] * (n + 1)
for i in range(n):
hashes[i + 1] = (hashes[i] * M + vals[i]) % MOD
def get_hash(p, l):
res = hashes[p + l] - (hashes[p] * powsA[l]) % MOD
if res < 0:
res += MOD
elif res > MOD:
res -= MOD
return res
best = 0
i = 0
while i < n:
val = vals[i]
for j in groups[val]:
if j <= i:
continue
l = j - i
if j + l <= n and get_hash(i, l) == get_hash(j, l):
best = max(best, j)
i = j - 1
break
i += 1
res = vals[best:]
print(len(res))
print(" ".join(map(str, res)))
``` |
248_B. Chilly Willy | Chilly Willy loves playing with numbers. He only knows prime numbers that are digits yet. These numbers are 2, 3, 5 and 7. But Willy grew rather bored of such numbers, so he came up with a few games that were connected with them.
Chilly Willy wants to find the minimum number of length n, such that it is simultaneously divisible by all numbers Willy already knows (2, 3, 5 and 7). Help him with that.
A number's length is the number of digits in its decimal representation without leading zeros.
Input
A single input line contains a single integer n (1 ≤ n ≤ 105).
Output
Print a single integer — the answer to the problem without leading zeroes, or "-1" (without the quotes), if the number that meet the problem condition does not exist.
Examples
Input
1
Output
-1
Input
5
Output
10080 | ```python
n = int(input())
if n < 3:
print(-1)
else:
t = 10**(n-1)
print(t+210-t%210)
``` |
272_C. Dima and Staircase | Dima's got a staircase that consists of n stairs. The first stair is at height a1, the second one is at a2, the last one is at an (1 ≤ a1 ≤ a2 ≤ ... ≤ an).
Dima decided to play with the staircase, so he is throwing rectangular boxes at the staircase from above. The i-th box has width wi and height hi. Dima throws each box vertically down on the first wi stairs of the staircase, that is, the box covers stairs with numbers 1, 2, ..., wi. Each thrown box flies vertically down until at least one of the two following events happen:
* the bottom of the box touches the top of a stair;
* the bottom of the box touches the top of a box, thrown earlier.
We only consider touching of the horizontal sides of stairs and boxes, at that touching with the corners isn't taken into consideration. Specifically, that implies that a box with width wi cannot touch the stair number wi + 1.
You are given the description of the staircase and the sequence in which Dima threw the boxes at it. For each box, determine how high the bottom of the box after landing will be. Consider a box to fall after the previous one lands.
Input
The first line contains integer n (1 ≤ n ≤ 105) — the number of stairs in the staircase. The second line contains a non-decreasing sequence, consisting of n integers, a1, a2, ..., an (1 ≤ ai ≤ 109; ai ≤ ai + 1).
The next line contains integer m (1 ≤ m ≤ 105) — the number of boxes. Each of the following m lines contains a pair of integers wi, hi (1 ≤ wi ≤ n; 1 ≤ hi ≤ 109) — the size of the i-th thrown box.
The numbers in the lines are separated by spaces.
Output
Print m integers — for each box the height, where the bottom of the box will be after landing. Print the answers for the boxes in the order, in which the boxes are given in the input.
Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 6 6
4
1 1
3 1
1 1
4 3
Output
1
3
4
6
Input
3
1 2 3
2
1 1
3 1
Output
1
3
Input
1
1
5
1 2
1 10
1 10
1 10
1 10
Output
1
3
13
23
33
Note
The first sample are shown on the picture.
<image> | ```python
# https://codeforces.com/problemset/problem/272/C
# we just check if the box dropped falls above the previous box or on stair number(1...w)
# the box is dropped from the top and hence we need to check the heights from the top -
# which height is suitable and higher
m = int(input())
arr = list(map(int, input().split()))
t = int(input())
for i in range(t):
w, h = map(int, input().split())
p = max(arr[0], arr[w - 1]) # checking which height is higher
print(p)
# increase the height for the next box to drop - can only drop above the
arr[0] = p + h
# current box
``` |
319_C. Kalila and Dimna in the Logging Industry | Kalila and Dimna are two jackals living in a huge jungle. One day they decided to join a logging factory in order to make money.
The manager of logging factory wants them to go to the jungle and cut n trees with heights a1, a2, ..., an. They bought a chain saw from a shop. Each time they use the chain saw on the tree number i, they can decrease the height of this tree by one unit. Each time that Kalila and Dimna use the chain saw, they need to recharge it. Cost of charging depends on the id of the trees which have been cut completely (a tree is cut completely if its height equal to 0). If the maximum id of a tree which has been cut completely is i (the tree that have height ai in the beginning), then the cost of charging the chain saw would be bi. If no tree is cut completely, Kalila and Dimna cannot charge the chain saw. The chainsaw is charged in the beginning. We know that for each i < j, ai < aj and bi > bj and also bn = 0 and a1 = 1. Kalila and Dimna want to cut all the trees completely, with minimum cost.
They want you to help them! Will you?
Input
The first line of input contains an integer n (1 ≤ n ≤ 105). The second line of input contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109). The third line of input contains n integers b1, b2, ..., bn (0 ≤ bi ≤ 109).
It's guaranteed that a1 = 1, bn = 0, a1 < a2 < ... < an and b1 > b2 > ... > bn.
Output
The only line of output must contain the minimum cost of cutting all the trees completely.
Please, do not write the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Examples
Input
5
1 2 3 4 5
5 4 3 2 0
Output
25
Input
6
1 2 3 10 20 30
6 5 4 3 2 0
Output
138 | ```python
n = int(input())
a = [0] + [int(x) for x in input().split()]
b = [0] + [int(x) for x in input().split()]
q = [0 for i in range(n + 1)]
f = [0 for _ in range(n + 1)]
l, r, q[1] = 1, 1, 1
for i in range(2, n + 1):
while l < r and f[q[l + 1]] - f[q[l]] < a[i] * (b[q[l]] - b[q[l + 1]]):
l += 1
f[i] = f[q[l]] + b[q[l]] * a[i]
while l < r and (f[q[r]] - f[q[r - 1]]) * (b[q[r]] - b[i]) >= (f[i] - f[q[r]]) * (b[q[r - 1]] - b[q[r]]):
r -= 1
r += 1
q[r] = i
print(f[n])
``` |
343_C. Read Time | Mad scientist Mike does not use slow hard disks. His modification of a hard drive has not one, but n different heads that can read data in parallel.
When viewed from the side, Mike's hard drive is an endless array of tracks. The tracks of the array are numbered from left to right with integers, starting with 1. In the initial state the i-th reading head is above the track number hi. For each of the reading heads, the hard drive's firmware can move the head exactly one track to the right or to the left, or leave it on the current track. During the operation each head's movement does not affect the movement of the other heads: the heads can change their relative order; there can be multiple reading heads above any of the tracks. A track is considered read if at least one head has visited this track. In particular, all of the tracks numbered h1, h2, ..., hn have been read at the beginning of the operation.
<image>
Mike needs to read the data on m distinct tracks with numbers p1, p2, ..., pm. Determine the minimum time the hard drive firmware needs to move the heads and read all the given tracks. Note that an arbitrary number of other tracks can also be read.
Input
The first line of the input contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of disk heads and the number of tracks to read, accordingly. The second line contains n distinct integers hi in ascending order (1 ≤ hi ≤ 1010, hi < hi + 1) — the initial positions of the heads. The third line contains m distinct integers pi in ascending order (1 ≤ pi ≤ 1010, pi < pi + 1) - the numbers of tracks to read.
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is recommended to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum time required, in seconds, to read all the needed tracks.
Examples
Input
3 4
2 5 6
1 3 6 8
Output
2
Input
3 3
1 2 3
1 2 3
Output
0
Input
1 2
165
142 200
Output
81
Note
The first test coincides with the figure. In this case the given tracks can be read in 2 seconds in the following way:
1. during the first second move the 1-st head to the left and let it stay there;
2. move the second head to the left twice;
3. move the third head to the right twice (note that the 6-th track has already been read at the beginning).
One cannot read the tracks in 1 second as the 3-rd head is at distance 2 from the 8-th track. | ```python
import sys
from itertools import *
from math import *
def solve():
n, m = map(int, input().split())
h = list(map(int, input().split()))
p = list(map(int, input().split()))
ss, ll = 0, int(2.2e10)
while ss < ll:
avg = (ss + ll) // 2
works = True
hidx = 0
pidx = 0
while hidx < len(h) and pidx < len(p):
leftget = p[pidx]
curpos = h[hidx]
if curpos - leftget > avg:
works = False
break
getbacktime = max(0, 2*(curpos - leftget))
alsotoright = max(0, avg - getbacktime)
leftime = max(0, curpos - leftget)
remtime = max(0, (avg - leftime) // 2)
furthestright = curpos + max(alsotoright, remtime)
while pidx < len(p) and p[pidx] <= furthestright: pidx += 1
hidx += 1
if pidx != len(p): works = False
if works: ll = avg
else: ss = avg + 1
print(ss)
if sys.hexversion == 50594544 : sys.stdin = open("test.txt")
solve()
``` |
366_E. Dima and Magic Guitar | Dima loves Inna very much. He decided to write a song for her. Dima has a magic guitar with n strings and m frets. Dima makes the guitar produce sounds like that: to play a note, he needs to hold one of the strings on one of the frets and then pull the string. When Dima pulls the i-th string holding it on the j-th fret the guitar produces a note, let's denote it as aij. We know that Dima's guitar can produce k distinct notes. It is possible that some notes can be produced in multiple ways. In other words, it is possible that aij = apq at (i, j) ≠ (p, q).
Dima has already written a song — a sequence of s notes. In order to play the song, you need to consecutively produce the notes from the song on the guitar. You can produce each note in any available way. Dima understood that there are many ways to play a song and he wants to play it so as to make the song look as complicated as possible (try to act like Cobein).
We'll represent a way to play a song as a sequence of pairs (xi, yi) (1 ≤ i ≤ s), such that the xi-th string on the yi-th fret produces the i-th note from the song. The complexity of moving between pairs (x1, y1) and (x2, y2) equals <image> + <image>. The complexity of a way to play a song is the maximum of complexities of moving between adjacent pairs.
Help Dima determine the maximum complexity of the way to play his song! The guy's gotta look cool!
Input
The first line of the input contains four integers n, m, k and s (1 ≤ n, m ≤ 2000, 1 ≤ k ≤ 9, 2 ≤ s ≤ 105).
Then follow n lines, each containing m integers aij (1 ≤ aij ≤ k). The number in the i-th row and the j-th column (aij) means a note that the guitar produces on the i-th string and the j-th fret.
The last line of the input contains s integers qi (1 ≤ qi ≤ k) — the sequence of notes of the song.
Output
In a single line print a single number — the maximum possible complexity of the song.
Examples
Input
4 6 5 7
3 1 2 2 3 1
3 2 2 2 5 5
4 2 2 2 5 3
3 2 2 1 4 3
2 3 1 4 1 5 1
Output
8
Input
4 4 9 5
4 7 9 5
1 2 1 7
8 3 4 9
5 7 7 2
7 1 9 2 5
Output
4 | ```python
def solution() : # 最大的距离来自于角落附近的点
n,m,k,s = map(int, input().split())
dis = lambda a,b : abs(a[0] - b[0]) + abs(a[1] - b[1])
corner = [(0,0), (0,m-1), (n-1,0), (n-1,m-1)]
vertex = [[(n,m), (n,-1), (-1,m), (-1,-1)] for _ in range(k+1)]
for i in range(n) :
for j,note in enumerate(map(int, input().split())) :
vertex[note] = [
(i,j) if dis((i,j), c) < dis(v, c) else v
for v,c in zip(vertex[note], corner)]
maxdis = [[-1] * (k+1) for _ in range(k+1)]
pairs = [(0,3),(3,0),(1,2),(2,1)]
for i in range(1, k+1) :
for j in range(i, k+1) :
vi,vj = vertex[i],vertex[j]
maxdis[i][j] = max(dis(vi[a], vj[b]) for a,b in pairs)
maxdis[j][i] = maxdis[i][j]
s = list(map(int, input().split()))
print(max(maxdis[s[i]][s[i+1]] for i in range(len(s) - 1)))
solution()
``` |
38_D. Vasya the Architect | Once Vasya played bricks. All the bricks in the set had regular cubical shape. Vasya vas a talented architect, however the tower he built kept falling apart.
Let us consider the building process. Vasya takes a brick and puts it on top of the already built tower so that the sides of the brick are parallel to the sides of the bricks he has already used. Let's introduce a Cartesian coordinate system on the horizontal plane, where Vasya puts the first brick. Then the projection of brick number i on the plane is a square with sides parallel to the axes of coordinates with opposite corners in points (xi, 1, yi, 1) and (xi, 2, yi, 2). The bricks are cast from homogeneous plastic and the weight of a brick a × a × a is a3 grams.
It is guaranteed that Vasya puts any brick except the first one on the previous one, that is the area of intersection of the upper side of the previous brick and the lower side of the next brick is always positive.
We (Vasya included) live in a normal world where the laws of physical statics work. And that is why, perhaps, if we put yet another brick, the tower will collapse under its own weight. Vasya puts the cubes consecutively one on top of the other until at least one cube loses the balance and falls down. If it happens, Vasya gets upset and stops the construction. Print the number of bricks in the maximal stable tower, that is the maximal number m satisfying the condition that all the towers consisting of bricks 1, 2, ..., k for every integer k from 1 to m remain stable.
Input
The first input file contains an integer n (1 ≤ n ≤ 100) which is the number of bricks. Each of the next n lines contains four numbers xi, 1, yi, 1, xi, 2, yi, 2 (xi, 1 ≠ xi, 2, |xi, 1 - xi, 2| = |yi, 1 - yi, 2|) which are the coordinates of the opposite angles of the base of the brick number i. The coordinates are integers and their absolute value does not exceed 50.
The cubes are given in the order Vasya puts them. It is guaranteed that the area of intersection of the upper side of the brick number i - 1 and the lower side of the brick number i is strictly strictly greater than zero for all i ≥ 2.
Output
Print the number of bricks in the maximal stable tower.
Examples
Input
2
0 0 3 3
1 0 4 3
Output
2
Input
2
0 0 3 3
2 0 5 3
Output
1
Input
3
0 0 3 3
1 0 4 3
2 0 5 3
Output
3 | ```python
a=[list(map(int,input().split())) for i in range(int(input()))]
n=len(a)
z=n
for i in range(n):
if i!=0:
c=[(a[i][0]+a[i][2])/2,(a[i][1]+a[i][3])/2]
m=abs(a[i][0]-a[i][2])**3
for j in range(i-1,-1,-1):
x1,y1,x2,y2=min(a[j][0],a[j][2]),min(a[j][1],a[j][3]),max(a[j][0],a[j][2]),max(a[j][1],a[j][3])
if not(x1<=c[0]<=x2 and y1<=c[1]<=y2):
z=i
break
x=c[0]+((a[j][0]+a[j][2])/2-c[0])*((abs(a[j][0]-a[j][2])**3)/(m+abs(a[j][0]-a[j][2])**3))
y=c[1]+((a[j][1]+a[j][3])/2-c[1])*((abs(a[j][0]-a[j][2])**3)/(m+abs(a[j][0]-a[j][2])**3))
c=[x,y]
m+=abs(a[j][0]-a[j][2])**3
if z!=n:
break
print(z)
``` |
40_C. Berland Square | Last year the world's largest square was built in Berland. It is known that the square can be represented as an infinite plane with an introduced Cartesian system of coordinates. On that square two sets of concentric circles were painted. Let's call the set of concentric circles with radii 1, 2, ..., K and the center in the point (z, 0) a (K, z)-set. Thus, on the square were painted a (N, x)-set and a (M, y)-set. You have to find out how many parts those sets divided the square into.
Input
The first line contains integers N, x, M, y. (1 ≤ N, M ≤ 100000, - 100000 ≤ x, y ≤ 100000, x ≠ y).
Output
Print the sought number of parts.
Examples
Input
1 0 1 1
Output
4
Input
1 0 1 2
Output
3
Input
3 3 4 7
Output
17
Note
Picture for the third sample:
<image> | ```python
def readGen(trans):
while 1:
for x in input().split():
yield(trans(x))
readint=readGen(int)
[N,x,M,y]=(next(readint) for i in range(4))
d=abs(y-x)
def interval(a,b): return range(a,b+1)
def case1(N,M,d): # d>=N
ans=0
for r in interval(1, min(M,d-N)):
ans+=1
if (M<=d-N):
return ans
for r in interval(d-N+1, min(M,d)):
ans+=2*(N+r-d)
if (M<=d):
return ans
for r in interval(d+1,min(M,d+N)):
ans+=2*(d+N-r+1)
if (M<=d+N):
return ans
for r in interval(d+N+1,M):
ans+=1
return ans
def partA(N,M,d):
ans=0
for r in interval(1,min(M,d)):
ans+=2*r-1
if (M<d+1):
return ans
for r in interval(d+1,min(M,2*d)):
ans+=2*(2*d-r)+1
return ans
def partB(N,M,d):
ans=0
bound1=min(2*d,N-d)
for r in interval(1,min(M,bound1)):
ans+=2*(r-1)+1
if (M<=bound1):
return ans
if (2*d<=N-d):
for r in interval(bound1+1,min(M,N-d)):
ans+=4*d
if (M<=N-d):
return ans
if (2*d>N-d):
for r in interval(bound1+1,min(M,2*d)):
ans+=2*(N-d)+1
if (M<=2*d):
return ans
bound2=max(2*d,N-d)
for r in interval(bound2+1,min(M,d+N)):
ans+=2*(d+N-r)+2
if (M<=d+N):
return ans
for r in interval(d+N+1,M):
ans+=1
return ans
def case2(N,M,d): # d<N
return partA(N,M,d)+partB(N,M,d)
def remain(N,M,d):
if (M>=d+N):
return 1
if (M>d):
return d+N-M+1
if (M<=d):
return N+1
def calc(N,M,d):
if (N<=d): return remain(N,M,d)+case1(N,M,d)
else: return remain(N,M,d)+case2(N,M,d)
print(calc(N,M,d))
``` |
438_B. The Child and Zoo | Of course our child likes walking in a zoo. The zoo has n areas, that are numbered from 1 to n. The i-th area contains ai animals in it. Also there are m roads in the zoo, and each road connects two distinct areas. Naturally the zoo is connected, so you can reach any area of the zoo from any other area using the roads.
Our child is very smart. Imagine the child want to go from area p to area q. Firstly he considers all the simple routes from p to q. For each route the child writes down the number, that is equal to the minimum number of animals among the route areas. Let's denote the largest of the written numbers as f(p, q). Finally, the child chooses one of the routes for which he writes down the value f(p, q).
After the child has visited the zoo, he thinks about the question: what is the average value of f(p, q) for all pairs p, q (p ≠ q)? Can you answer his question?
Input
The first line contains two integers n and m (2 ≤ n ≤ 105; 0 ≤ m ≤ 105). The second line contains n integers: a1, a2, ..., an (0 ≤ ai ≤ 105). Then follow m lines, each line contains two integers xi and yi (1 ≤ xi, yi ≤ n; xi ≠ yi), denoting the road between areas xi and yi.
All roads are bidirectional, each pair of areas is connected by at most one road.
Output
Output a real number — the value of <image>.
The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
4 3
10 20 30 40
1 3
2 3
4 3
Output
16.666667
Input
3 3
10 20 30
1 2
2 3
3 1
Output
13.333333
Input
7 8
40 20 10 30 20 50 40
1 2
2 3
3 4
4 5
5 6
6 7
1 4
5 7
Output
18.571429
Note
Consider the first sample. There are 12 possible situations:
* p = 1, q = 3, f(p, q) = 10.
* p = 2, q = 3, f(p, q) = 20.
* p = 4, q = 3, f(p, q) = 30.
* p = 1, q = 2, f(p, q) = 10.
* p = 2, q = 4, f(p, q) = 20.
* p = 4, q = 1, f(p, q) = 10.
Another 6 cases are symmetrical to the above. The average is <image>.
Consider the second sample. There are 6 possible situations:
* p = 1, q = 2, f(p, q) = 10.
* p = 2, q = 3, f(p, q) = 20.
* p = 1, q = 3, f(p, q) = 10.
Another 3 cases are symmetrical to the above. The average is <image>. | ```python
R = lambda:map(int, input().split())
n, m = R()
a = list(R())
p, f, sz =[], [], []
e = [[] for i in range(n)]
vis = [0] * n
ans = 0
def find(u):
if f[u] != u:
f[u] = find(f[u])
return f[u]
for i in range(n):
p.append([a[i], i])
f.append(i)
sz.append(1)
p.sort()
p.reverse()
for i in range(m):
u, v = R()
e[u - 1].append(v - 1)
e[v - 1].append(u - 1)
for i in range(n):
u = p[i][1]
for v in e[u]:
if (vis[v] and find(u) != find(v)):
pu, pv = u, v
if (sz[f[u]] > sz[f[v]]):
pu, pv = pv, pu
ans += p[i][0] * sz[f[pu]] * sz[f[pv]]
sz[f[pv]] += sz[f[pu]]
f[f[pu]] = f[pv]
vis[u] = 1
print("%.6f" %(2. * ans / n / (n - 1)))
``` |
45_I. TCMCF+++ | Vasya has gotten interested in programming contests in TCMCF+++ rules. On the contest n problems were suggested and every problem had a cost — a certain integral number of points (perhaps, negative or even equal to zero). According to TCMCF+++ rules, only accepted problems can earn points and the overall number of points of a contestant was equal to the product of the costs of all the problems he/she had completed. If a person didn't solve anything, then he/she didn't even appear in final standings and wasn't considered as participant. Vasya understood that to get the maximal number of points it is not always useful to solve all the problems. Unfortunately, he understood it only after the contest was finished. Now he asks you to help him: find out what problems he had to solve to earn the maximal number of points.
Input
The first line contains an integer n (1 ≤ n ≤ 100) — the number of the suggested problems. The next line contains n space-separated integers ci ( - 100 ≤ ci ≤ 100) — the cost of the i-th task. The tasks' costs may coinсide.
Output
Print space-separated the costs of the problems that needed to be solved to get the maximal possible number of points. Do not forget, please, that it was necessary to solve at least one problem. If there are several solutions to that problem, print any of them.
Examples
Input
5
1 2 -3 3 3
Output
3 1 2 3
Input
13
100 100 100 100 100 100 100 100 100 100 100 100 100
Output
100 100 100 100 100 100 100 100 100 100 100 100 100
Input
4
-2 -2 -2 -2
Output
-2 -2 -2 -2 | ```python
import sys
input=sys.stdin.readline
n=int(input())
s=list(map(int,input().split()))
s.sort()
s.reverse()
num_manfi=0
num_sefr=0
flag=0
for i in s:
if i>0:
print(i,end=' ')
flag=1
elif i==0:
num_sefr+=1
else:
num_manfi+=1
num_manfi-=(num_manfi%2)
s.reverse()
for i in range(num_manfi):
print(s[i],end=' ')
if (not flag) and num_manfi<=0 and num_sefr>0 :
print(0,end=' ')
exit()
if (not flag) and num_sefr<=0 and num_manfi<=0 :
print(s[0])
exit()
``` |
483_C. Diverse Permutation | Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers not larger than n. We'll denote as n the length of permutation p1, p2, ..., pn.
Your task is to find such permutation p of length n, that the group of numbers |p1 - p2|, |p2 - p3|, ..., |pn - 1 - pn| has exactly k distinct elements.
Input
The single line of the input contains two space-separated positive integers n, k (1 ≤ k < n ≤ 105).
Output
Print n integers forming the permutation. If there are multiple answers, print any of them.
Examples
Input
3 2
Output
1 3 2
Input
3 1
Output
1 2 3
Input
5 2
Output
1 3 2 4 5
Note
By |x| we denote the absolute value of number x. | ```python
from collections import Counter
import string
import math
import sys
# sys.setrecursionlimit(10**6)
from fractions import Fraction
def array_int():
return [int(i) for i in sys.stdin.readline().split()]
def vary(arrber_of_variables):
if arrber_of_variables==1:
return int(sys.stdin.readline())
if arrber_of_variables>=2:
return map(int,sys.stdin.readline().split())
def makedict(var):
return dict(Counter(var))
testcases=1
# testcases=vary(1)
for _ in range(testcases):
n,k=vary(2)
temp=k
num=[i for i in range(1,n+1)]
j=0
for i in range(k+1):
if i%2==0:
print(num[j],end=" ")
j+=1
else:
print(num[k],end=" ")
k-=1
for i in range(temp+1,n):
print(num[i],end=" ")
``` |
507_C. Guess Your Way Out! | Amr bought a new video game "Guess Your Way Out!". The goal of the game is to find an exit from the maze that looks like a perfect binary tree of height h. The player is initially standing at the root of the tree and the exit from the tree is located at some leaf node.
Let's index all the leaf nodes from the left to the right from 1 to 2h. The exit is located at some node n where 1 ≤ n ≤ 2h, the player doesn't know where the exit is so he has to guess his way out!
Amr follows simple algorithm to choose the path. Let's consider infinite command string "LRLRLRLRL..." (consisting of alternating characters 'L' and 'R'). Amr sequentially executes the characters of the string using following rules:
* Character 'L' means "go to the left child of the current node";
* Character 'R' means "go to the right child of the current node";
* If the destination node is already visited, Amr skips current command, otherwise he moves to the destination node;
* If Amr skipped two consecutive commands, he goes back to the parent of the current node before executing next command;
* If he reached a leaf node that is not the exit, he returns to the parent of the current node;
* If he reaches an exit, the game is finished.
Now Amr wonders, if he follows this algorithm, how many nodes he is going to visit before reaching the exit?
Input
Input consists of two integers h, n (1 ≤ h ≤ 50, 1 ≤ n ≤ 2h).
Output
Output a single integer representing the number of nodes (excluding the exit node) Amr is going to visit before reaching the exit by following this algorithm.
Examples
Input
1 2
Output
2
Input
2 3
Output
5
Input
3 6
Output
10
Input
10 1024
Output
2046
Note
A perfect binary tree of height h is a binary tree consisting of h + 1 levels. Level 0 consists of a single node called root, level h consists of 2h nodes called leaves. Each node that is not a leaf has exactly two children, left and right one.
Following picture illustrates the sample test number 3. Nodes are labeled according to the order of visit.
<image> | ```python
import sys
def main():
rdl = list(map(int,input().split()))
obx(rdl[0],rdl[1],0,1)
def obx(lvl, ind, kl, current):
if lvl ==0:
print(int(kl))
sys.exit()
all = 0
for i in range(lvl+1):
all += 2**i
all -= 1
if ind > (2**(lvl))/2:
if current == 1:
kl += all / 2 + 1
else:
kl += 1
current *= -1
obx(lvl-1,ind-(2**lvl)/2,kl,current)
else:
if current == -1:
kl += all/2+1
else:
kl += 1
current *= -1
obx(lvl-1,ind,kl,current)
main()
``` |
556_D. Case of Fugitive | Andrewid the Android is a galaxy-famous detective. He is now chasing a criminal hiding on the planet Oxa-5, the planet almost fully covered with water.
The only dry land there is an archipelago of n narrow islands located in a row. For more comfort let's represent them as non-intersecting segments on a straight line: island i has coordinates [li, ri], besides, ri < li + 1 for 1 ≤ i ≤ n - 1.
To reach the goal, Andrewid needs to place a bridge between each pair of adjacent islands. A bridge of length a can be placed between the i-th and the (i + 1)-th islads, if there are such coordinates of x and y, that li ≤ x ≤ ri, li + 1 ≤ y ≤ ri + 1 and y - x = a.
The detective was supplied with m bridges, each bridge can be used at most once. Help him determine whether the bridges he got are enough to connect each pair of adjacent islands.
Input
The first line contains integers n (2 ≤ n ≤ 2·105) and m (1 ≤ m ≤ 2·105) — the number of islands and bridges.
Next n lines each contain two integers li and ri (1 ≤ li ≤ ri ≤ 1018) — the coordinates of the island endpoints.
The last line contains m integer numbers a1, a2, ..., am (1 ≤ ai ≤ 1018) — the lengths of the bridges that Andrewid got.
Output
If it is impossible to place a bridge between each pair of adjacent islands in the required manner, print on a single line "No" (without the quotes), otherwise print in the first line "Yes" (without the quotes), and in the second line print n - 1 numbers b1, b2, ..., bn - 1, which mean that between islands i and i + 1 there must be used a bridge number bi.
If there are multiple correct answers, print any of them. Note that in this problem it is necessary to print "Yes" and "No" in correct case.
Examples
Input
4 4
1 4
7 8
9 10
12 14
4 5 3 8
Output
Yes
2 3 1
Input
2 2
11 14
17 18
2 9
Output
No
Input
2 1
1 1
1000000000000000000 1000000000000000000
999999999999999999
Output
Yes
1
Note
In the first sample test you can, for example, place the second bridge between points 3 and 8, place the third bridge between points 7 and 10 and place the first bridge between points 10 and 14.
In the second sample test the first bridge is too short and the second bridge is too long, so the solution doesn't exist. | ```python
#!/usr/bin/env python
# 556D_fug.py - Codeforces.com 556D Fug quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Input
The first line contains integers n and m - the number of islands and bridges.
Next n lines each contain two integers li and ri - the coordinates of the
island endpoints.
The last line contains m integer numbers a1..am - the lengths of the bridges
that Andrewid got.
Output
If it is impossible to place a bridge between each pair of adjacent islands
in the required manner, print on a single line "No" (without the quotes)
, otherwise print in the first line "Yes" (without the quotes), and in the
second line print n-1 numbers b1, bn-1, which mean that between islands
i and i+1 there must be used a bridge number bi.
If there are multiple correct answers, print any of them. Note that in this
problem it is necessary to print "Yes" and "No" in correct case
"""
# Standard modules
import unittest
import sys
import re
# Additional modules
import bisect
###############################################################################
# Fastlist Class
###############################################################################
class Fastlist(object):
""" Fastlist representation """
def __init__(self, l=[], load=5000, sorted=0):
self._load = load
self._sorted = sorted
self._lists = []
self._starts = []
self._mins = []
self._insert_list()
self._irev = 0
self.extend(l)
def _index_location(self, index):
if len(self._lists[0]) == 0:
raise IndexError("List index out of range")
if index == 0:
return (0, 0)
if index == -1:
return (len(self._lists) - 1, len(self._lists[-1]) - 1)
if self._sorted:
raise RuntimeError("No index access to the sorted list, exc 0, -1")
length = len(self)
if index < 0:
index = length + index
if index >= length:
raise IndexError("List index out of range")
il = bisect.bisect_right(self._starts, index) - 1
return (il, index - self._starts[il])
def _insert_list(self, il=None):
if il is None:
il = len(self._lists)
self._lists.insert(il, [])
if self._sorted:
if il == 0:
self._mins.insert(il, None)
else:
self._mins.insert(il, self._lists[il-1][-1])
else:
if il == 0:
self._starts.insert(il, 0)
else:
start = self._starts[il-1] + len(self._lists[il-1])
self._starts.insert(il, start)
def _del_list(self, il):
del self._lists[il]
if self._sorted:
del self._mins[il]
else:
del self._starts[il]
def _rebalance(self, il):
illen = len(self._lists[il])
if illen >= self._load * 2:
self._insert_list(il)
self._even_lists(il)
if illen <= self._load * 0.2:
if il != 0:
self._even_lists(il-1)
elif len(self._lists) > 1:
self._even_lists(il)
def _even_lists(self, il):
tot = len(self._lists[il]) + len(self._lists[il+1])
if tot < self._load * 1:
self._lists[il] += self._lists[il+1]
self._del_list(il+1)
if self._sorted:
self._mins[il] = self._lists[il][0]
else:
half = tot//2
ltot = self._lists[il] + self._lists[il+1]
self._lists[il] = ltot[:half]
self._lists[il+1] = ltot[half:]
if self._sorted:
self._mins[il] = self._lists[il][0]
self._mins[il+1] = self._lists[il+1][0]
else:
self._starts[il+1] = self._starts[il] + len(self._lists[il])
def _obj_location(self, obj, l=0):
if not self._sorted:
raise RuntimeError("No by value access to an unserted list")
il = 0
if len(self._mins) > 1 and obj > self._mins[0]:
if l:
il = bisect.bisect_left(self._mins, obj) - 1
else:
il = bisect.bisect_right(self._mins, obj) - 1
if l:
ii = bisect.bisect_left(self._lists[il], obj)
else:
ii = bisect.bisect_right(self._lists[il], obj)
if ii == len(self._lists[il]) and il != len(self._lists) - 1:
ii = 0
il += 1
return (il, ii)
def insert(self, index, obj):
(il, ii) = self._index_location(index)
self._lists[il].insert(ii, obj)
for j in range(il + 1, len(self._starts)):
self._starts[j] += 1
self._rebalance(il)
def append(self, obj):
if len(self._lists[-1]) >= self._load:
self._insert_list()
self._lists[-1].append(obj)
if self._sorted and self._mins[0] is None:
self._mins[0] = self._lists[0][0]
def extend(self, iter):
for n in iter:
self.append(n)
def pop(self, index=None):
if index is None:
index = -1
(il, ii) = self._index_location(index)
item = self._lists[il].pop(ii)
if self._sorted:
if ii == 0 and len(self._lists[il]) > 0:
self._mins[il] = self._lists[il][0]
else:
for j in range(il + 1, len(self._starts)):
self._starts[j] -= 1
self._rebalance(il)
return item
def clear(self):
self._lists.clear()
self._starts.clear()
self._mins.clear()
self._insert_list()
def as_list(self):
return sum(self._lists, [])
def insort(self, obj, l=0):
(il, ii) = self._obj_location(obj, l)
self._lists[il].insert(ii, obj)
if ii == 0:
self._mins[il] = obj
self._rebalance(il)
def add(self, obj):
if self._sorted:
self.insort(obj)
else:
self.append(obj)
def insort_left(self, obj):
self.insort(obj, l=1)
def lower_bound(self, obj):
(self._il, self._ii) = self._obj_location(obj, l=1)
return self
def upper_bound(self, obj):
(self._il, self._ii) = self._obj_location(obj)
return self
def __str__(self):
return str(self.as_list())
def __setitem__(self, index, obj):
if isinstance(index, int):
(il, ii) = self._index_location(index)
self._lists[il][ii] = obj
elif isinstance(index, slice):
raise RuntimeError("Slice assignment is not supported")
def __getitem__(self, index):
if isinstance(index, int):
(il, ii) = self._index_location(index)
return self._lists[il][ii]
elif isinstance(index, slice):
rg = index.indices(len(self))
if rg[0] == 0 and rg[1] == len(self) and rg[2] == 1:
return self.as_list()
return [self.__getitem__(index) for index in range(*rg)]
def __iadd__(self, obj):
if self._sorted:
[self.insort(n) for n in obj]
else:
[self.append(n) for n in obj]
return self
def __delitem__(self, index):
if isinstance(index, int):
self.pop(index)
elif isinstance(index, slice):
rg = index.indices(len(self))
[self.__delitem__(rg[0]) for i in range(*rg)]
def __len__(self):
if self._sorted:
return sum([len(l) for l in self._lists])
return self._starts[-1] + len(self._lists[-1])
def __contains__(self, obj):
if self._sorted:
it = self.lower_bound(obj)
return not it.iter_end() and obj == it.iter_getitem()
else:
for n in self:
if obj == n:
return True
return False
def __bool__(self):
return len(self._lists[0]) != 0
def __iter__(self):
self._il = self._ii = self._irev = 0
return self
def __reversed__(self):
self._il = len(self._lists) - 1
self._ii = len(self._lists[self._il]) - 1
self._irev = 1
return self
def __next__(self):
if self._il in (-1, len(self._lists)) or len(self._lists[0]) == 0:
raise StopIteration("Iteration stopped")
item = self._lists[self._il][self._ii]
if not self._irev:
self._ii += 1
if self._ii == len(self._lists[self._il]):
self._il += 1
self._ii = 0
else:
self._ii -= 1
if self._ii == 0:
self._il -= 1
self._ii = len(self._lists[self._il])
return item
def iter_getitem(self):
return self._lists[self._il][self._ii]
def iter_end(self):
return (self._il == len(self._lists) - 1 and
self._ii == len(self._lists[self._il]))
def iter_del(self):
self.iter_pop()
def iter_pop(self):
item = self._lists[self._il].pop(self._ii)
if self._sorted:
if self._ii == 0 and len(self._lists[self._il]) > 0:
self._mins[self._il] = self._lists[self._il][0]
else:
for j in range(self._il + 1, len(self._starts)):
self._starts[j] -= 1
self._rebalance(self._il)
return item
###############################################################################
# Fug Class
###############################################################################
class Fug:
""" Fug representation """
def __init__(self, args):
""" Default constructor """
self.gsrt = args[0]
self.asrt = args[1]
self.gn = args[2]
self.result = [0]*self.gn
self.a = Fastlist(self.asrt, load=500, sorted=1)
def calculate(self):
""" Main calcualtion function of the class """
for i in range(self.gn):
g = self.gsrt[i]
it = self.a.lower_bound((g[1], 0))
if not it.iter_end():
alb = it.iter_getitem()
if alb[0] > g[0]:
return "No"
self.result[g[2]] = alb[1]+1
it.iter_del()
else:
return "No"
answer = "Yes\n" + " ".join(str(n) for n in self.result)
return answer
###############################################################################
# Executable code
###############################################################################
def get_inputs(test_inputs=None):
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
""" Unit-testable input function wrapper """
if it:
return next(it)
else:
return sys.stdin.readline()
# Getting string inputs. Place all uinput() calls here
num = [int(s) for s in uinput().split()]
gaps = []
prevli = [int(s) for s in uinput().split()]
for i in range(num[0] - 1):
li = [int(s) for s in uinput().split()]
min = li[0] - prevli[1]
max = li[1] - prevli[0]
gaps.append((max, min, i))
prevli = li
alist = [(int(s), i) for i, s in enumerate(uinput().split())]
# Decoding inputs into a list
inputs = [sorted(gaps), sorted(alist), num[0]-1]
return inputs
def calculate(test_inputs=None):
""" Base class calculate method wrapper """
return Fug(get_inputs(test_inputs)).calculate()
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_sample_tests(self):
""" Quiz sample tests. Add \n to separate lines """
# Sample test 1
test = "4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8"
self.assertEqual(calculate(test), "Yes\n2 3 1")
self.assertEqual(
get_inputs(test),
[[(3, 1, 1), (5, 2, 2), (7, 3, 0)],
[(3, 2), (4, 0), (5, 1), (8, 3)], 3])
# My tests
test = "5 5\n1 1\n2 7\n8 8\n10 10\n16 16\n1 1 5 6 2"
self.assertEqual(calculate(test), "Yes\n1 2 5 4")
# Other tests
test = "2 2\n11 14\n17 18\n2 9"
self.assertEqual(calculate(test), "No")
# Other tests
test = (
"2 1\n1 1\n1000000000000000000 1000000000000000000" +
"\n999999999999999999")
self.assertEqual(calculate(test), "Yes\n1")
test = ("5 9\n1 2\n3 3\n5 7\n11 13\n14 20\n2 3 4 10 6 2 6 9 5")
self.assertEqual(calculate(test), "Yes\n1 6 3 2")
size = 200000
test = str(size) + " " + str(size) + "\n"
x = size*1000
for i in range(size):
test += str(x) + " " + str(x + i + 1) + "\n"
x += 2 * (i + 1)
for i in reversed(range(size)):
test += str(i) + " "
self.assertEqual(calculate(test)[0], "Y")
def test_Fug_class__basic_functions(self):
""" Fug class basic functions testing """
# Constructor test
d = Fug([[(1, 3, 1), (2, 5, 2), (3, 7, 0)],
[(3, 2), (4, 0), (5, 1), (8, 3)], 3])
# Sort bridges
self.assertEqual(d.asrt[0], (3, 2))
# Sort Gaps
self.assertEqual(d.gsrt[0], (1, 3, 1))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(calculate())
``` |
582_B. Once Again... | You are given an array of positive integers a1, a2, ..., an × T of length n × T. We know that for any i > n it is true that ai = ai - n. Find the length of the longest non-decreasing sequence of the given array.
Input
The first line contains two space-separated integers: n, T (1 ≤ n ≤ 100, 1 ≤ T ≤ 107). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 300).
Output
Print a single number — the length of a sought sequence.
Examples
Input
4 3
3 1 4 2
Output
5
Note
The array given in the sample looks like that: 3, 1, 4, 2, 3, 1, 4, 2, 3, 1, 4, 2. The elements in bold form the largest non-decreasing subsequence. | ```python
f = lambda: map(int, input().split())
n, m = f()
t = list(f())
s = [0] * 301
d = s[:]
for i in t: d[i] += 1
for i in t * min(m, 2 * n): s[i] = max(s[:i + 1]) + 1
print(max(s) + max((m - n * 2) * max(d), 0))
``` |
604_B. More Cowbell | Kevin Sun wants to move his precious collection of n cowbells from Naperthrill to Exeter, where there is actually grass instead of corn. Before moving, he must pack his cowbells into k boxes of a fixed size. In order to keep his collection safe during transportation, he won't place more than two cowbells into a single box. Since Kevin wishes to minimize expenses, he is curious about the smallest size box he can use to pack his entire collection.
Kevin is a meticulous cowbell collector and knows that the size of his i-th (1 ≤ i ≤ n) cowbell is an integer si. In fact, he keeps his cowbells sorted by size, so si - 1 ≤ si for any i > 1. Also an expert packer, Kevin can fit one or two cowbells into a box of size s if and only if the sum of their sizes does not exceed s. Given this information, help Kevin determine the smallest s for which it is possible to put all of his cowbells into k boxes of size s.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 2·k ≤ 100 000), denoting the number of cowbells and the number of boxes, respectively.
The next line contains n space-separated integers s1, s2, ..., sn (1 ≤ s1 ≤ s2 ≤ ... ≤ sn ≤ 1 000 000), the sizes of Kevin's cowbells. It is guaranteed that the sizes si are given in non-decreasing order.
Output
Print a single integer, the smallest s for which it is possible for Kevin to put all of his cowbells into k boxes of size s.
Examples
Input
2 1
2 5
Output
7
Input
4 3
2 3 5 9
Output
9
Input
3 2
3 5 7
Output
8
Note
In the first sample, Kevin must pack his two cowbells into the same box.
In the second sample, Kevin can pack together the following sets of cowbells: {2, 3}, {5} and {9}.
In the third sample, the optimal solution is {3, 5} and {7}. | ```python
n, k = map(int, input().split())
a = [int(s) for s in input().split()]
p = n - k
q = 2*k - n
if n < k:
q = n
p = 0
ma = 0
for i in range ((n - q) // 2):
ma = max((a[i] + a[n - q - i - 1]), ma)
ma2 = 0
for i in range(n - q, n):
ma2 = max(a[i], ma2)
print(max(ma,ma2))
``` |
626_E. Simple Skewness | Define the simple skewness of a collection of numbers to be the collection's mean minus its median. You are given a list of n (not necessarily distinct) integers. Find the non-empty subset (with repetition) with the maximum simple skewness.
The mean of a collection is the average of its elements. The median of a collection is its middle element when all of its elements are sorted, or the average of its two middle elements if it has even size.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of elements in the list.
The second line contains n integers xi (0 ≤ xi ≤ 1 000 000) — the ith element of the list.
Output
In the first line, print a single integer k — the size of the subset.
In the second line, print k integers — the elements of the subset in any order.
If there are multiple optimal subsets, print any.
Examples
Input
4
1 2 3 12
Output
3
1 2 12
Input
4
1 1 2 2
Output
3
1 1 2
Input
2
1 2
Output
2
1 2
Note
In the first case, the optimal subset is <image>, which has mean 5, median 2, and simple skewness of 5 - 2 = 3.
In the second case, the optimal subset is <image>. Note that repetition is allowed.
In the last case, any subset has the same median and mean, so all have simple skewness of 0. | ```python
from itertools import accumulate
from fractions import Fraction
n = int(input())
A = [int(x) for x in input().split()]
A.sort()
B = list(accumulate([0] + A))
def condition(i, z):
return (2*z - 1)*(A[i-z] + A[-z]) > 2*(B[i+1] - B[i-z+1] + B[-1] - B[-z])
def average(i, z):
return Fraction((B[i+1] - B[i-z] + B[-1] - B[-z-1]) , 2*z + 1)
maxans = 0
argmax = (0, 0)
for i in range(1, n-1):
x, y = 0, min(i, n-1-i)
while y - x > 1:
z = (x + y)//2
if condition(i, z):
x = z
else:
y = z
if condition(i, y): x = y
if maxans < average(i, x) - A[i]:
maxans = average(i, x) - A[i]
argmax = (i, x)
print(argmax[1]*2 + 1)
for i in range(argmax[0] - argmax[1], argmax[0] + 1):
print(A[i], end = ' ')
for i in range(-argmax[1], 0):
print(A[i], end = ' ')
``` |
676_A. Nicholas and Permutation | Nicholas has an array a that contains n distinct integers from 1 to n. In other words, Nicholas has a permutation of size n.
Nicholas want the minimum element (integer 1) and the maximum element (integer n) to be as far as possible from each other. He wants to perform exactly one swap in order to maximize the distance between the minimum and the maximum elements. The distance between two elements is considered to be equal to the absolute difference between their positions.
Input
The first line of the input contains a single integer n (2 ≤ n ≤ 100) — the size of the permutation.
The second line of the input contains n distinct integers a1, a2, ..., an (1 ≤ ai ≤ n), where ai is equal to the element at the i-th position.
Output
Print a single integer — the maximum possible distance between the minimum and the maximum elements Nicholas can achieve by performing exactly one swap.
Examples
Input
5
4 5 1 3 2
Output
3
Input
7
1 6 5 3 4 7 2
Output
6
Input
6
6 5 4 3 2 1
Output
5
Note
In the first sample, one may obtain the optimal answer by swapping elements 1 and 2.
In the second sample, the minimum and the maximum elements will be located in the opposite ends of the array if we swap 7 and 2.
In the third sample, the distance between the minimum and the maximum elements is already maximum possible, so we just perform some unnecessary swap, for example, one can swap 5 and 2. | ```python
n = int(input())
a = list(map(int, input().split()))
maxLocate = a.index(n)
minLocate = a.index(1)
distanceMax = len(a) - 1 - a.index(n)
distanceMin = len(a) - 1 - a.index(1)
print(max(maxLocate, minLocate, distanceMax, distanceMin))
``` |
69_A. Young Physicist | A guy named Vasya attends the final grade of a high school. One day Vasya decided to watch a match of his favorite hockey team. And, as the boy loves hockey very much, even more than physics, he forgot to do the homework. Specifically, he forgot to complete his physics tasks. Next day the teacher got very angry at Vasya and decided to teach him a lesson. He gave the lazy student a seemingly easy task: You are given an idle body in space and the forces that affect it. The body can be considered as a material point with coordinates (0; 0; 0). Vasya had only to answer whether it is in equilibrium. "Piece of cake" — thought Vasya, we need only to check if the sum of all vectors is equal to 0. So, Vasya began to solve the problem. But later it turned out that there can be lots and lots of these forces, and Vasya can not cope without your help. Help him. Write a program that determines whether a body is idle or is moving by the given vectors of forces.
Input
The first line contains a positive integer n (1 ≤ n ≤ 100), then follow n lines containing three integers each: the xi coordinate, the yi coordinate and the zi coordinate of the force vector, applied to the body ( - 100 ≤ xi, yi, zi ≤ 100).
Output
Print the word "YES" if the body is in equilibrium, or the word "NO" if it is not.
Examples
Input
3
4 1 7
-2 4 -1
1 -5 -3
Output
NO
Input
3
3 -1 7
-5 2 -4
2 -1 -3
Output
YES | ```python
sum1,sum2,sum3 = 0,0,0
n = int(input())
while n:
n-=1
l = list(map(int, input().split()))
sum1 += l[0]
sum2 += l[1]
sum3 += l[2]
if sum1==0 and sum2 ==0 and sum3 ==0:
print("YES")
else:
print("NO")
``` |
742_A. Arpa’s hard exam and Mehrdad’s naive cheat | There exists an island called Arpa’s land, some beautiful girls live there, as ugly ones do.
Mehrdad wants to become minister of Arpa’s land. Arpa has prepared an exam. Exam has only one question, given n, print the last digit of 1378n.
<image>
Mehrdad has become quite confused and wants you to help him. Please help, although it's a naive cheat.
Input
The single line of input contains one integer n (0 ≤ n ≤ 109).
Output
Print single integer — the last digit of 1378n.
Examples
Input
1
Output
8
Input
2
Output
4
Note
In the first example, last digit of 13781 = 1378 is 8.
In the second example, last digit of 13782 = 1378·1378 = 1898884 is 4. | ```python
n = int(input())
if n == 0:
print(1)
if n % 4 == 0 and n!= 0 :
print(6)
if n % 4 == 1:
print(8)
if n % 4 == 2:
print(4)
if n % 4 == 3:
print(2)
``` |
765_E. Tree Folding | Vanya wants to minimize a tree. He can perform the following operation multiple times: choose a vertex v, and two disjoint (except for v) paths of equal length a0 = v, a1, ..., ak, and b0 = v, b1, ..., bk. Additionally, vertices a1, ..., ak, b1, ..., bk must not have any neighbours in the tree other than adjacent vertices of corresponding paths. After that, one of the paths may be merged into the other, that is, the vertices b1, ..., bk can be effectively erased:
<image>
Help Vanya determine if it possible to make the tree into a path via a sequence of described operations, and if the answer is positive, also determine the shortest length of such path.
Input
The first line of input contains the number of vertices n (2 ≤ n ≤ 2·105).
Next n - 1 lines describe edges of the tree. Each of these lines contains two space-separated integers u and v (1 ≤ u, v ≤ n, u ≠ v) — indices of endpoints of the corresponding edge. It is guaranteed that the given graph is a tree.
Output
If it is impossible to obtain a path, print -1. Otherwise, print the minimum number of edges in a possible path.
Examples
Input
6
1 2
2 3
2 4
4 5
1 6
Output
3
Input
7
1 2
1 3
3 4
1 5
5 6
6 7
Output
-1
Note
In the first sample case, a path of three edges is obtained after merging paths 2 - 1 - 6 and 2 - 4 - 5.
It is impossible to perform any operation in the second sample case. For example, it is impossible to merge paths 1 - 3 - 4 and 1 - 5 - 6, since vertex 6 additionally has a neighbour 7 that is not present in the corresponding path. | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return list(map(int, input().split()))
def II(): return int(input())
def LS(): return input().split()
def S(): return input()
def main():
n = II()
d = collections.defaultdict(set)
for _ in range(n-1):
a,b = LI()
d[a].add(b)
d[b].add(a)
memo = [-1] * (n+1)
def path(t,s):
ps = set()
dt = list(d[t])
for k in dt:
if memo[k] < 0:
continue
ps.add(memo[k])
if s == -1 and len(ps) == 2:
memo[t] = sum(ps) + 2
return memo[t]
if len(ps) > 1:
return -t
if len(ps) == 0:
memo[t] = 0
return 0
memo[t] = list(ps)[0] + 1
return memo[t]
def _path(tt,ss):
q = [(tt,ss)]
tq = []
qi = 0
while len(q) > qi:
t,s = q[qi]
for k in d[t]:
if k == s:
continue
q.append((k,t))
qi += 1
for t,s in q[::-1]:
r = path(t,s)
if r < 0:
return r
return memo[tt]
def _path2(tt,ss):
q = [(tt,ss)]
tq = []
qi = 0
while len(q) > qi:
t,s = q[qi]
for k in d[t]:
if k == s or memo[k] >= 0:
continue
q.append((k,t))
qi += 1
for t,s in q[::-1]:
r = path(t,s)
if r < 0:
return r
return memo[tt]
t = _path(1,-1)
if t < 0:
t = _path2(-t,-1)
if t > 0:
while t%2 == 0:
t//=2
return t
return -1
print(main())
``` |
789_B. Masha and geometric depression | Masha really loves algebra. On the last lesson, her strict teacher Dvastan gave she new exercise.
You are given geometric progression b defined by two integers b1 and q. Remind that a geometric progression is a sequence of integers b1, b2, b3, ..., where for each i > 1 the respective term satisfies the condition bi = bi - 1·q, where q is called the common ratio of the progression. Progressions in Uzhlyandia are unusual: both b1 and q can equal 0. Also, Dvastan gave Masha m "bad" integers a1, a2, ..., am, and an integer l.
Masha writes all progression terms one by one onto the board (including repetitive) while condition |bi| ≤ l is satisfied (|x| means absolute value of x). There is an exception: if a term equals one of the "bad" integers, Masha skips it (doesn't write onto the board) and moves forward to the next term.
But the lesson is going to end soon, so Masha has to calculate how many integers will be written on the board. In order not to get into depression, Masha asked you for help: help her calculate how many numbers she will write, or print "inf" in case she needs to write infinitely many integers.
Input
The first line of input contains four integers b1, q, l, m (-109 ≤ b1, q ≤ 109, 1 ≤ l ≤ 109, 1 ≤ m ≤ 105) — the initial term and the common ratio of progression, absolute value of maximal number that can be written on the board and the number of "bad" integers, respectively.
The second line contains m distinct integers a1, a2, ..., am (-109 ≤ ai ≤ 109) — numbers that will never be written on the board.
Output
Print the only integer, meaning the number of progression terms that will be written on the board if it is finite, or "inf" (without quotes) otherwise.
Examples
Input
3 2 30 4
6 14 25 48
Output
3
Input
123 1 2143435 4
123 11 -5453 141245
Output
0
Input
123 1 2143435 4
54343 -13 6 124
Output
inf
Note
In the first sample case, Masha will write integers 3, 12, 24. Progression term 6 will be skipped because it is a "bad" integer. Terms bigger than 24 won't be written because they exceed l by absolute value.
In the second case, Masha won't write any number because all terms are equal 123 and this is a "bad" integer.
In the third case, Masha will write infinitely integers 123. | ```python
b1,q,l,m = map(int,input().split())
a = set(map(int,input().split()))
if q==0:
if 0 in a:
if b1 in a:
print(0)
elif abs(b1)<=l:
print(1)
else:
print(0)
elif abs(b1)<=l:
print("inf")
else:
print(0)
elif q==1:
if abs(b1)<=l and b1 not in a:
print("inf")
else:
print(0)
elif q==-1:
if abs(b1)<=l and (b1 not in a or -b1 not in a):
print('inf')
else:
print(0)
elif b1==0:
if 0 in a:
print(0)
else:
print("inf")
else:
cnt = 0
p = b1
while abs(p)<=l:
if p not in a:
cnt += 1
p *= q
print(cnt)
``` |
80_D. Falling Anvils | For some reason in many American cartoons anvils fall from time to time onto heroes' heads. Of course, safes, wardrobes, cruisers, planes fall sometimes too... But anvils do so most of all.
Anvils come in different sizes and shapes. Quite often they get the hero stuck deep in the ground. But have you ever thought who throws anvils from the sky? From what height? We are sure that such questions have never troubled you!
It turns out that throwing an anvil properly is not an easy task at all. Let's describe one of the most popular anvil throwing models.
Let the height p of the potential victim vary in the range [0;a] and the direction of the wind q vary in the range [ - b;b]. p and q could be any real (floating) numbers. Then we can assume that the anvil will fit the toon's head perfectly only if the following equation has at least one real root:
<image>
Determine the probability with which an aim can be successfully hit by an anvil.
You can assume that the p and q coefficients are chosen equiprobably and independently in their ranges.
Input
The first line contains integer t (1 ≤ t ≤ 10000) — amount of testcases.
Each of the following t lines contain two space-separated integers a and b (0 ≤ a, b ≤ 106).
Pretests contain all the tests with 0 < a < 10, 0 ≤ b < 10.
Output
Print t lines — the probability of a successful anvil hit for each testcase. The absolute or relative error of the answer should not exceed 10 - 6.
Examples
Input
2
4 2
1 2
Output
0.6250000000
0.5312500000 | ```python
t = int(input())
for i in range(t):
a, b = map(int, input().split())
denom = a * b * 2
if denom == 0:
if b == 0:
print('1')
else:
print('0.5')
continue
if a > 4 * b:
nom = 2 * b * b
else:
nom = (b - a / 4.0 + b) / 2.0 * a
print('%.9f' % ((denom - nom) * 1.0 / denom))
``` |
835_B. The number on the board | Some natural number was written on the board. Its sum of digits was not less than k. But you were distracted a bit, and someone changed this number to n, replacing some digits with others. It's known that the length of the number didn't change.
You have to find the minimum number of digits in which these two numbers can differ.
Input
The first line contains integer k (1 ≤ k ≤ 109).
The second line contains integer n (1 ≤ n < 10100000).
There are no leading zeros in n. It's guaranteed that this situation is possible.
Output
Print the minimum number of digits in which the initial number and n can differ.
Examples
Input
3
11
Output
1
Input
3
99
Output
0
Note
In the first example, the initial number could be 12.
In the second example the sum of the digits of n is not less than k. The initial number could be equal to n. | ```python
"""
Author : Arif Ahmad
Date :
Algo :
Difficulty :
"""
from sys import stdin, stdout
def main():
k = int(stdin.readline().strip())
n = stdin.readline().strip()
n = sorted(n)
total = 0
for c in n:
d = ord(c) - 48
total += d
ans = 0
for c in n:
if total >= k: break
d = ord(c) - 48
total = total - d + 9
ans += 1
stdout.write(str(ans) + '\n')
if __name__ == '__main__':
main()
``` |
87_C. Interesting Game | Two best friends Serozha and Gena play a game.
Initially there is one pile consisting of n stones on the table. During one move one pile should be taken and divided into an arbitrary number of piles consisting of a1 > a2 > ... > ak > 0 stones. The piles should meet the condition a1 - a2 = a2 - a3 = ... = ak - 1 - ak = 1. Naturally, the number of piles k should be no less than two.
The friends play in turns. The player who cannot make a move loses. Serozha makes the first move. Who will win if both players play in the optimal way?
Input
The single line contains a single integer n (1 ≤ n ≤ 105).
Output
If Serozha wins, print k, which represents the minimal number of piles into which he can split the initial one during the first move in order to win the game.
If Gena wins, print "-1" (without the quotes).
Examples
Input
3
Output
2
Input
6
Output
-1
Input
100
Output
8 | ```python
import math
from collections import Counter
n = int(input())
g = [0 for i in range(n + 1)]
prefix_xor = g.copy()
def in_range(d, k):
if (2 * k - d * d + d) % (2 * d) != 0:
return -1
x = (2 * k - d * d + d) / (2 * d)
return int(x) if x > 0 else -1
def mex(arr):
counter = Counter()
for i in arr:
counter[i] += 1
for i in range(0, len(arr) + 1):
if counter[i] == 0:
return i
def find_move(arr):
for i in range(0, len(arr)):
if arr[i] == 0:
return i
return -1
if n < 3:
print(-1)
exit(0)
for i in range(3, n + 1):
for_range = range(2, int(math.sqrt(2 * i)) + 1)
filter_range = [l for l in for_range if in_range(l, i) > 0]
branches = [prefix_xor[in_range(d, i) + d - 1] ^ prefix_xor[in_range(d, i) - 1] for d in filter_range]
g[i] = mex(branches)
prefix_xor[i] = prefix_xor[i - 1] ^ g[i]
if i == n:
print(-1 if g[i] == 0 else filter_range[find_move(branches)])
``` |
903_E. Swapping Characters | We had a string s consisting of n lowercase Latin letters. We made k copies of this string, thus obtaining k identical strings s1, s2, ..., sk. After that, in each of these strings we swapped exactly two characters (the characters we swapped could be identical, but they had different indices in the string).
You are given k strings s1, s2, ..., sk, and you have to restore any string s so that it is possible to obtain these strings by performing aforementioned operations. Note that the total length of the strings you are given doesn't exceed 5000 (that is, k·n ≤ 5000).
Input
The first line contains two integers k and n (1 ≤ k ≤ 2500, 2 ≤ n ≤ 5000, k · n ≤ 5000) — the number of strings we obtained, and the length of each of these strings.
Next k lines contain the strings s1, s2, ..., sk, each consisting of exactly n lowercase Latin letters.
Output
Print any suitable string s, or -1 if such string doesn't exist.
Examples
Input
3 4
abac
caab
acba
Output
acab
Input
3 4
kbbu
kbub
ubkb
Output
kbub
Input
5 4
abcd
dcba
acbd
dbca
zzzz
Output
-1
Note
In the first example s1 is obtained by swapping the second and the fourth character in acab, s2 is obtained by swapping the first and the second character, and to get s3, we swap the third and the fourth character.
In the second example s1 is obtained by swapping the third and the fourth character in kbub, s2 — by swapping the second and the fourth, and s3 — by swapping the first and the third.
In the third example it's impossible to obtain given strings by aforementioned operations. | ```python
import collections
def swapCharacters(strings, k, n):
"""
Time: O(n^2 * k)
Space: O(1)
"""
if k == 1:
s0 = list(strings[0])
s0[0], s0[1] = s0[1], s0[0]
return ''.join(s0)
# Initial check for validity
freq = collections.Counter(strings[0])
canSame = (max(freq.values()) >= 2) # could swap two of the same characters ==> same string
for s in strings:
if collections.Counter(s) != freq:
return -1
# Find diff indices between first two strings
max_dist = 0
max_dist_s = None
s0 = strings[0]
for s1 in strings[1:]:
dist = HammingDistance(s0, s1, n)
if dist > max_dist:
max_dist = dist
max_dist_s = s1
# Hamming distance <= 2*2 between input strings to be valid
if max_dist > 4:
return -1
diffs = [i for i in range(n) if s0[i] != s1[i]]
# Checks all possible strings which match first two -- Finding strings (O(N)), testing string (O(KN))
s0 = list(s0)
for i in diffs:
for j in range(n):
# try swapping
s0[i], s0[j] = s0[j], s0[i]
# see if matches second string now
#dist = sum([s0[i] != s1[i] for i in diffs])
dist = HammingDistance(s0, s1, n)
if dist == 2 or (dist == 0 and canSame):
cand = ''.join(s0)
if verifyAll(strings, k, n, cand, canSame):
return cand
# revert
s0[i], s0[j] = s0[j], s0[i]
# nothing works
return -1
def HammingDistance(s0, s1, n):
count = 0
for i in range(n):
if s0[i] != s1[i]:
count += 1
return count
def verifyAll(strings, k, n, cand, canSame):
for s in strings:
dist = HammingDistance(s, cand, n)
if (dist != 0 or not canSame) and dist != 2:
return False
return True
k, n = [int(x) for x in input().split()]
strings = set() # discard duplicates
for _ in range(k):
strings.add(input())
strings = list(strings)
k = len(strings)
res = swapCharacters(strings, k, n)
print(res)
``` |
954_G. Castle Defense | Today you are going to lead a group of elven archers to defend the castle that is attacked by an army of angry orcs. Three sides of the castle are protected by impassable mountains and the remaining side is occupied by a long wall that is split into n sections. At this moment there are exactly ai archers located at the i-th section of this wall. You know that archer who stands at section i can shoot orcs that attack section located at distance not exceeding r, that is all such sections j that |i - j| ≤ r. In particular, r = 0 means that archers are only capable of shooting at orcs who attack section i.
Denote as defense level of section i the total number of archers who can shoot at the orcs attacking this section. Reliability of the defense plan is the minimum value of defense level of individual wall section.
There is a little time left till the attack so you can't redistribute archers that are already located at the wall. However, there is a reserve of k archers that you can distribute among wall sections in arbitrary way. You would like to achieve maximum possible reliability of the defence plan.
Input
The first line of the input contains three integers n, r and k (1 ≤ n ≤ 500 000, 0 ≤ r ≤ n, 0 ≤ k ≤ 1018) — the number of sections of the wall, the maximum distance to other section archers can still shoot and the number of archers yet to be distributed along the wall. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — the current number of archers at each section.
Output
Print one integer — the maximum possible value of defense plan reliability, i.e. the maximum possible value of minimum defense level if we distribute k additional archers optimally.
Examples
Input
5 0 6
5 4 3 4 9
Output
5
Input
4 2 0
1 2 3 4
Output
6
Input
5 1 1
2 1 2 1 2
Output
3 | ```python
import sys
border = 1 << 30
def build(x=0):
res = [0, 0]
i = 0
while x and i < 30:
if x & 1:
res[1] += (1 << i)
x >>= 1
i += 1
i = 0
while x:
if x & 1:
res[0] += (1 << i)
x >>= 1
i += 1
return res
n, r, k = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
a = list(map(int, sys.stdin.buffer.readline().decode('utf-8').split()))
k_big, k_small = build(k)
left = build(sum(a[:r]))
minus_big, minus_small = [0]*n, [0]*n
w = 2*r+1
def solve(level_big, level_small):
used_big = used_small = 0
acc_big, acc_small = left
for i in range(n):
if minus_small[i] or minus_big[i]:
acc_big -= minus_big[i]
acc_small -= minus_small[i]
if acc_small < 0:
acc_small += border
acc_big -= 1
elif acc_small >= border:
acc_small -= border
acc_big += 1
minus_big[i] = minus_small[i] = 0
acc_small += (a[i+r] if i+r < n else 0) - (a[i-r-1] if i-r >= 1 else 0)
if acc_small >= border:
acc_small -= border
acc_big += 1
elif acc_small < 0:
acc_small += border
acc_big -= 1
if acc_big < level_big or acc_big == level_big and acc_small < level_small:
used_big += level_big - acc_big
used_small += level_small - acc_small
if used_small >= border:
used_small -= border
used_big += 1
elif used_small < 0:
used_small += border
used_big -= 1
if used_big > k_big or used_big == k_big and used_small > k_small:
break
if i+w < n:
minus_big[i+w] = level_big - acc_big
minus_small[i+w] = level_small - acc_small
acc_big = level_big
acc_small = level_small
for i in range(i+1, n):
if minus_small[i] or minus_big[i]:
minus_small[i] = minus_big[i] = 0
return used_big < k_big or used_big == k_big and used_small <= k_small
ok, ng = min(a), k + sum(a) + 1
while abs(ok - ng) > 1:
mid = (ok + ng) >> 1
if solve(*build(mid)):
ok = mid
else:
ng = mid
print(ok)
``` |
p02549 AtCoder Beginner Contest 179 - Leaping Tak | There are N cells arranged in a row, numbered 1, 2, \ldots, N from left to right.
Tak lives in these cells and is currently on Cell 1. He is trying to reach Cell N by using the procedure described below.
You are given an integer K that is less than or equal to 10, and K non-intersecting segments [L_1, R_1], [L_2, R_2], \ldots, [L_K, R_K]. Let S be the union of these K segments. Here, the segment [l, r] denotes the set consisting of all integers i that satisfy l \leq i \leq r.
* When you are on Cell i, pick an integer d from S and move to Cell i + d. You cannot move out of the cells.
To help Tak, find the number of ways to go to Cell N, modulo 998244353.
Constraints
* 2 \leq N \leq 2 \times 10^5
* 1 \leq K \leq \min(N, 10)
* 1 \leq L_i \leq R_i \leq N
* [L_i, R_i] and [L_j, R_j] do not intersect (i \neq j)
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
L_1 R_1
L_2 R_2
:
L_K R_K
Output
Print the number of ways for Tak to go from Cell 1 to Cell N, modulo 998244353.
Examples
Input
5 2
1 1
3 4
Output
4
Input
5 2
3 3
5 5
Output
0
Input
5 1
1 2
Output
5
Input
60 3
5 8
1 3
10 15
Output
221823067 | ```python
import sys
input = sys.stdin.readline
N,K=map(int,input().split())
K=[tuple(map(int,input().split())) for i in range(K)]
mod=998244353
DP=[0]*(4*10**5+100)
DP[1]=1
DP[2]=-1
for i in range(1,N+1):
DP[i]+=DP[i-1]
DP[i]%=mod
for l,r in K:
DP[i+l]+=DP[i]
DP[i+l]%=mod
DP[i+r+1]-=DP[i]
DP[i+r+1]%=mod
#print(DP[:10])
print(DP[N])
``` |
p02680 AtCoder Beginner Contest 168 - . (Single Dot) | There is a grass field that stretches infinitely.
In this field, there is a negligibly small cow. Let (x, y) denote the point that is x\ \mathrm{cm} south and y\ \mathrm{cm} east of the point where the cow stands now. The cow itself is standing at (0, 0).
There are also N north-south lines and M east-west lines drawn on the field. The i-th north-south line is the segment connecting the points (A_i, C_i) and (B_i, C_i), and the j-th east-west line is the segment connecting the points (D_j, E_j) and (D_j, F_j).
What is the area of the region the cow can reach when it can move around as long as it does not cross the segments (including the endpoints)? If this area is infinite, print `INF` instead.
Constraints
* All values in input are integers between -10^9 and 10^9 (inclusive).
* 1 \leq N, M \leq 1000
* A_i < B_i\ (1 \leq i \leq N)
* E_j < F_j\ (1 \leq j \leq M)
* The point (0, 0) does not lie on any of the given segments.
Input
Input is given from Standard Input in the following format:
N M
A_1 B_1 C_1
:
A_N B_N C_N
D_1 E_1 F_1
:
D_M E_M F_M
Output
If the area of the region the cow can reach is infinite, print `INF`; otherwise, print an integer representing the area in \mathrm{cm^2}.
(Under the constraints, it can be proved that the area of the region is always an integer if it is not infinite.)
Examples
Input
5 6
1 2 0
0 1 1
0 2 2
-3 4 -1
-2 6 3
1 0 1
0 1 2
2 0 2
-1 -4 5
3 -2 4
1 2 4
Output
13
Input
6 1
-3 -1 -2
-3 -1 1
-2 -1 2
1 4 -2
1 4 -1
1 4 1
3 1 4
Output
INF | ```python
I=lambda:map(int,input().split());F=1e21;r=range;n,m=I();f=[-F,F];X=[0]+f;Y=X[:];R=[(f,F),(f,-F)];H=[(F,f),(-F,f)]
for i in r(n):*a,c=I();R+=[(a,c)];Y+=c,;X+=a
for i in r(m):a,*b=I();H+=[(a,b)];X+=a,;Y+=b
def g(X):s=dict(enumerate(sorted(set(X))));return{s[i]:i for i in s},s,len(s)+1
h,s,K=g(X);w,t,L=g(Y);j=lambda:[[0]*-~K for i in r(L+1)];V=j();U=j();v=j()
for(a,b),c in R:U[w[c]][h[a]]+=1;U[w[c]][h[b]]+=-1
for d,(e,f)in H:V[w[e]][h[d]]+=1;V[w[f]][h[d]]+=-1
for i in r(L):
for j in r(K):U[i][j+1]+=U[i][j];V[i+1][j]+=V[i][j]
q=[(h[0],w[0])];v[w[0]][h[0]]=1;a=0
while q:
x,y=q.pop();a+=(s[x]-s[x+1])*(t[y]-t[y+1])
for e,f in[(-1,0),(1,0),(0,1),(0,-1)]:
c=x+e;d=y+f
if 0==v[d][c]and(U[(f>0)+y][x]|e==0)|(V[y][(e>0)+x]|f==0):q+=[(c,d)];v[d][c]=1
print([a,'INF'][a>F])
``` |
p02808 Dwango Programming Contest 6th - Cookie Distribution | There are N children, numbered 1,2,\ldots,N. In the next K days, we will give them some cookies. In the i-th day, we will choose a_i children among the N with equal probability, and give one cookie to each child chosen. (We make these K choices independently.)
Let us define the happiness of the children as c_1 \times c_2 \times \ldots \times c_N, where c_i is the number of cookies received by Child i in the K days. Find the expected happiness multiplied by \binom{N}{a_1} \times \binom{N}{a_2} \times \ldots \times \binom{N}{a_K} (we can show that this value is an integer), modulo (10^{9}+7).
Constraints
* 1 \leq N \leq 1000
* 1 \leq K \leq 20
* 1 \leq a_i \leq N
Input
Input is given from Standard Input in the following format:
N K
a_1 a_2 \ldots a_K
Output
Print the answer.
Examples
Input
3 2
3 2
Output
12
Input
856 16
399 263 665 432 206 61 784 548 422 313 848 478 827 26 398 63
Output
337587117 | ```python
n,k = map(int,input().split())
a = tuple(map(int,input().split()))
mod = 10**9+7
rng = 1001
fctr = [1]
finv = [1]
for i in range(1,rng):
fctr.append(fctr[-1]*i%mod)
finv.append(pow(fctr[i],mod-2,mod))
dp = [[0 for i in range(n+1)] for j in range(k+1)]
dp[0][0] = 1
for i in range(1,k+1):
x = a[i-1]
for j in range(n+1):
if dp[i-1][j] == 0:
continue
y = dp[i-1][j]*fctr[n-j]*finv[n-x]%mod
for t in range(min(n-j,x)+1):
dp[i][j+t]=(dp[i][j+t]+y*fctr[n-t]*finv[n-j-t]*finv[t]*finv[x-t])%mod
print(dp[k][n])
``` |
p03081 ExaWizards 2019 - Snuke the Wizard | There are N squares numbered 1 to N from left to right. Each square has a character written on it, and Square i has a letter s_i. Besides, there is initially one golem on each square.
Snuke cast Q spells to move the golems.
The i-th spell consisted of two characters t_i and d_i, where d_i is `L` or `R`. When Snuke cast this spell, for each square with the character t_i, all golems on that square moved to the square adjacent to the left if d_i is `L`, and moved to the square adjacent to the right if d_i is `R`.
However, when a golem tried to move left from Square 1 or move right from Square N, it disappeared.
Find the number of golems remaining after Snuke cast the Q spells.
Constraints
* 1 \leq N,Q \leq 2 \times 10^{5}
* |s| = N
* s_i and t_i are uppercase English letters.
* d_i is `L` or `R`.
Input
Input is given from Standard Input in the following format:
N Q
s
t_1 d_1
\vdots
t_{Q} d_Q
Output
Print the answer.
Examples
Input
3 4
ABC
A L
B L
B R
A R
Output
2
Input
8 3
AABCBDBA
A L
B R
A R
Output
5
Input
10 15
SNCZWRCEWB
B R
R R
E R
W R
Z L
S R
Q L
W L
B R
C L
A L
N L
E R
Z L
S L
Output
3 | ```python
n, q = map(int, input().split())
s = input()
o = []
for _ in range(q):
t, d = input().split()
o.append((t, d))
def check(x):
cur = s[x]
ind = x
for i in range(q):
if o[i][0] == cur:
if o[i][1] == 'L':
ind -= 1
if ind < 0:
return "LEFT"
cur = s[ind]
else:
ind += 1
if ind > n-1:
return "RIGHT"
cur = s[ind]
return "MID"
ans = n
bottom = -1
top = n
while top - bottom > 1:
mid = (top+bottom)//2
if check(mid) == "LEFT":
bottom = mid
else:
top = mid
ans -= 1+bottom
bottom = -1
top = n
while top - bottom > 1:
mid = (top+bottom)//2
if check(mid) == "RIGHT":
top = mid
else:
bottom = mid
ans -= n-top
print(ans)
``` |
p03226 Tenka1 Programmer Contest - Circular | You are given a sequence of N integers: A_1,A_2,...,A_N.
Find the number of permutations p_1,p_2,...,p_N of 1,2,...,N that can be changed to A_1,A_2,...,A_N by performing the following operation some number of times (possibly zero), modulo 998244353:
* For each 1\leq i\leq N, let q_i=min(p_{i-1},p_{i}), where p_0=p_N. Replace the sequence p with the sequence q.
Constraints
* 1 \leq N \leq 3 × 10^5
* 1 \leq A_i \leq N
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
A_1
:
A_N
Output
Print the number of the sequences that satisfy the condition, modulo 998244353.
Examples
Input
3
1
2
1
Output
2
Input
5
3
1
4
1
5
Output
0
Input
8
4
4
4
1
1
1
2
2
Output
24
Input
6
1
1
6
2
2
2
Output
0 | ```python
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from operator import itemgetter
MOD = 998244353
N,*A = map(int,read().split())
T = A.count(1)
if T == 0:
print(0)
exit()
if T == 1:
answer = 1 if len(set(A)) == N else 0
print(answer)
exit()
if T == N:
answer = 1
for n in range(1,N+1):
answer *= n
answer %= MOD
print(answer)
exit()
n = A.index(1)
while A[n-1] == 1:
n -= 1
A = A[n:] + A[:n]
# assert len(A) == N and A[0] == 1 and A[-1] != 1
L = [0] * (N+1)
R = [-1] * (N+1)
ctr = [0] * (N+1)
nums = []
prev = 0
for i,x in enumerate(A):
ctr[x] += 1
R[x] = i
if prev != x:
nums.append(x)
L[x] = i
prev = x
if any(y - x + 1 != z for x,y,z in zip(L,R,ctr)):
print(0)
exit()
if any(x > T for x in ctr[2:]):
print(0)
exit()
free = [0] * (N+1) # ある数値を書き込んだ時点で、死亡確定になってるマス数
answer = 1
for x,y,z in zip(nums,nums[1:],nums[2:]+[1]):
if x > y < z:
if ctr[y] != T:
answer = 0
break
elif x < y < z:
free[y] += ctr[y] - 1
elif x > y > z:
free[y] += ctr[y] - 1
else:
# x < y > z
answer *= (T + 1 - ctr[y])
answer %= MOD
free[y] += ctr[y] + T - 2
f = 0
for n in range(1,N+1):
if ctr[n] >= 1:
f += free[n]
continue
answer *= f
answer %= MOD
f -= 1
print(answer)
``` |
p03374 AtCoder Regular Contest 096 - Static Sushi | "Teishi-zushi", a Japanese restaurant, is a plain restaurant with only one round counter. The outer circumference of the counter is C meters. Customers cannot go inside the counter.
Nakahashi entered Teishi-zushi, and he was guided to the counter. Now, there are N pieces of sushi (vinegared rice with seafood and so on) on the counter. The distance measured clockwise from the point where Nakahashi is standing to the point where the i-th sushi is placed, is x_i meters. Also, the i-th sushi has a nutritive value of v_i kilocalories.
Nakahashi can freely walk around the circumference of the counter. When he reach a point where a sushi is placed, he can eat that sushi and take in its nutrition (naturally, the sushi disappears). However, while walking, he consumes 1 kilocalories per meter.
Whenever he is satisfied, he can leave the restaurant from any place (he does not have to return to the initial place). On balance, at most how much nutrition can he take in before he leaves? That is, what is the maximum possible value of the total nutrition taken in minus the total energy consumed? Assume that there are no other customers, and no new sushi will be added to the counter. Also, since Nakahashi has plenty of nutrition in his body, assume that no matter how much he walks and consumes energy, he never dies from hunger.
Constraints
* 1 ≤ N ≤ 10^5
* 2 ≤ C ≤ 10^{14}
* 1 ≤ x_1 < x_2 < ... < x_N < C
* 1 ≤ v_i ≤ 10^9
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N C
x_1 v_1
x_2 v_2
:
x_N v_N
Output
If Nakahashi can take in at most c kilocalories on balance before he leaves the restaurant, print c.
Examples
Input
3 20
2 80
9 120
16 1
Output
191
Input
3 20
2 80
9 1
16 120
Output
192
Input
1 100000000000000
50000000000000 1
Output
0
Input
15 10000000000
400000000 1000000000
800000000 1000000000
1900000000 1000000000
2400000000 1000000000
2900000000 1000000000
3300000000 1000000000
3700000000 1000000000
3800000000 1000000000
4000000000 1000000000
4100000000 1000000000
5200000000 1000000000
6600000000 1000000000
8000000000 1000000000
9300000000 1000000000
9700000000 1000000000
Output
6500000000 | ```python
N, C = map(int, input().split())
xv = [[int(i) for i in input().split()] for _ in range(N)]
av = 0
fa1 = 0
bv = 0
fb1 = 0
fa = []
fb = []
ga = []
gb = []
for i in range(N):
ax = xv[i][0]
av += xv[i][1]
bx = C - xv[-(i+1)][0]
bv += xv[-(i+1)][1]
fa1 = max(fa1, av-ax)
fa.append(fa1)
ga.append(av - 2*ax)
fb1 = max(fb1, bv-bx)
fb.append(fb1)
gb.append(bv - 2*bx)
p = max(0, fa[-1], fb[-1])
for i in range(N-1):
p = max(p, fa[i]+gb[N-i-2], ga[i]+fb[N-i-2])
print(p)
``` |
p03535 CODE FESTIVAL 2017 Final (Parallel) - Time Gap | In CODE FESTIVAL XXXX, there are N+1 participants from all over the world, including Takahashi.
Takahashi checked and found that the time gap (defined below) between the local times in his city and the i-th person's city was D_i hours. The time gap between two cities is defined as follows. For two cities A and B, if the local time in city B is d o'clock at the moment when the local time in city A is 0 o'clock, then the time gap between these two cities is defined to be min(d,24-d) hours. Here, we are using 24-hour notation. That is, the local time in the i-th person's city is either d o'clock or 24-d o'clock at the moment when the local time in Takahashi's city is 0 o'clock, for example.
Then, for each pair of two people chosen from the N+1 people, he wrote out the time gap between their cities. Let the smallest time gap among them be s hours.
Find the maximum possible value of s.
Constraints
* 1 \leq N \leq 50
* 0 \leq D_i \leq 12
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
D_1 D_2 ... D_N
Output
Print the maximum possible value of s.
Examples
Input
3
7 12 8
Output
4
Input
2
11 11
Output
2
Input
1
0
Output
0 | ```python
N = int(input())
D = [int(x) for x in input().split()]
D.append(0)
D.sort()
ans = []
for i in range(N + 1):
if i % 2 == 0:
ans.append(D[i])
else:
ans.append((24 - D[i]) % 24)
ans.sort()
print(min(min(ans[i + 1] - ans[i] for i in range(N)), 24 - ans[-1]))
``` |
p03695 AtCoder Beginner Contest 064 - Colorful Leaderboard | In AtCoder, a person who has participated in a contest receives a color, which corresponds to the person's rating as follows:
* Rating 1-399 : gray
* Rating 400-799 : brown
* Rating 800-1199 : green
* Rating 1200-1599 : cyan
* Rating 1600-1999 : blue
* Rating 2000-2399 : yellow
* Rating 2400-2799 : orange
* Rating 2800-3199 : red
Other than the above, a person whose rating is 3200 or higher can freely pick his/her color, which can be one of the eight colors above or not.
Currently, there are N users who have participated in a contest in AtCoder, and the i-th user has a rating of a_i.
Find the minimum and maximum possible numbers of different colors of the users.
Constraints
* 1 ≤ N ≤ 100
* 1 ≤ a_i ≤ 4800
* a_i is an integer.
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the minimum possible number of different colors of the users, and the maximum possible number of different colors, with a space in between.
Examples
Input
4
2100 2500 2700 2700
Output
2 2
Input
5
1100 1900 2800 3200 3200
Output
3 5
Input
20
800 810 820 830 840 850 860 870 880 890 900 910 920 930 940 950 960 970 980 990
Output
1 1 | ```python
n,a=open(0)
s=set();x=0
for i in map(int,a.split()):
j=i//400
if j<8:s.add(j)
else:x+=1
print(max(1,len(s)),len(s)+x)
``` |
p03850 AtCoder Regular Contest 066 - Addition and Subtraction Hard | Joisino has a formula consisting of N terms: A_1 op_1 A_2 ... op_{N-1} A_N. Here, A_i is an integer, and op_i is an binary operator either `+` or `-`. Because Joisino loves large numbers, she wants to maximize the evaluated value of the formula by inserting an arbitrary number of pairs of parentheses (possibly zero) into the formula. Opening parentheses can only be inserted immediately before an integer, and closing parentheses can only be inserted immediately after an integer. It is allowed to insert any number of parentheses at a position. Your task is to write a program to find the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Constraints
* 1≦N≦10^5
* 1≦A_i≦10^9
* op_i is either `+` or `-`.
Input
The input is given from Standard Input in the following format:
N
A_1 op_1 A_2 ... op_{N-1} A_N
Output
Print the maximum possible evaluated value of the formula after inserting an arbitrary number of pairs of parentheses.
Examples
Input
3
5 - 1 - 3
Output
7
Input
5
1 - 2 + 3 - 4 + 5
Output
5
Input
5
1 - 20 - 13 + 14 - 5
Output
13 | ```python
#!/usr/bin/env python3
def solve(n):
s = input()
sum_a = 0
sum_n = 0
sum_np = 0
min_sum_np = 10 ** 15
j = s.find('-')
if j < 0:
return sum(list(map(int, s.split(' + '))))
sum_a = sum(list(map(int, s[:j - 1].split(' + '))))
j += 2
s += ' '
len_s = len(s)
sign = -1
w = ''
while j < len_s:
ch = s[j]
j += 1
if ch == ' ':
if len(w):
a = int(w)
sum_a += a
w = ''
if sign < 0:
sum_n += a
sum_np = 0
else:
sum_np += a
elif ch == '+':
sign = 1
elif ch == '-':
min_sum_np = min(min_sum_np, sum_n + sum_np)
sign = -1
else:
w += ch
min_sum_np = min(min_sum_np, sum_n + sum_np)
return sum_a - 2 * min_sum_np
def main():
n = input()
n = int(n)
print(solve(n))
if __name__ == '__main__':
main()
``` |
p04017 AtCoder Regular Contest 060 - Tak and Hotels | N hotels are located on a straight line. The coordinate of the i-th hotel (1 \leq i \leq N) is x_i.
Tak the traveler has the following two personal principles:
* He never travels a distance of more than L in a single day.
* He never sleeps in the open. That is, he must stay at a hotel at the end of a day.
You are given Q queries. The j-th (1 \leq j \leq Q) query is described by two distinct integers a_j and b_j. For each query, find the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel following his principles. It is guaranteed that he can always travel from the a_j-th hotel to the b_j-th hotel, in any given input.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq L \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq x_i < x_2 < ... < x_N \leq 10^9
* x_{i+1} - x_i \leq L
* 1 \leq a_j,b_j \leq N
* a_j \neq b_j
* N,\,L,\,Q,\,x_i,\,a_j,\,b_j are integers.
Input
The input is given from Standard Input in the following format:
N
x_1 x_2 ... x_N
L
Q
a_1 b_1
a_2 b_2
:
a_Q b_Q
Output
Print Q lines. The j-th line (1 \leq j \leq Q) should contain the minimum number of days that Tak needs to travel from the a_j-th hotel to the b_j-th hotel.
Example
Input
9
1 3 6 13 15 18 19 29 31
10
4
1 8
7 3
6 7
8 5
Output
4
2
1
2 | ```python
import bisect
N = int(input())
x = list(map(int, input().split()))
L = int(input())
dest = []
dest_1 = [0] * N
for i in range(N):
dest_1[i] = bisect.bisect_left(x, x[i] + L + 0.5) - 1
dest.append(dest_1)
for i in range(1, len(bin(N - 1)) - 1):
dest_prev = dest[i - 1]
dest_i = [0] * N
for j in range(N):
dest_i[j] = dest_prev[dest_prev[j]]
dest.append(dest_i)
Q = int(input())
for _ in range(Q):
a, b = map(int, input().split())
a -= 1
b -= 1
if a > b:
a, b = b, a
k = len(dest) - 1
ans = 0
while True:
d = dest[k][a]
if d >= b:
if k > 0:
k -= 1
else:
ans += 1
break
else:
ans += 2 ** k
a = d
print(ans)
``` |
p00101 Aizu PR | An English booklet has been created for publicizing Aizu to the world. When you read it carefully, you found a misnomer (an error in writing) on the last name of Masayuki Hoshina, the lord of the Aizu domain. The booklet says "Hoshino" not "Hoshina".
Your task is to write a program which replace all the words "Hoshino" with "Hoshina". You can assume that the number of characters in a text is less than or equal to 1000.
Input
The input consists of several datasets. There will be the number of datasets n in the first line. There will be n lines. A line consisting of english texts will be given for each dataset.
Output
For each dataset, print the converted texts in a line.
Example
Input
3
Hoshino
Hashino
Masayuki Hoshino was the grandson of Ieyasu Tokugawa.
Output
Hoshina
Hashino
Masayuki Hoshina was the grandson of Ieyasu Tokugawa. | ```python
[print(input().replace("Hoshino","Hoshina")) for i in range(int(input()))]
``` |
p00234 Aizu Buried Treasure | Aizu has an ancient legend of buried treasure. You have finally found the place where the buried treasure is buried. Since we know the depth of the buried treasure and the condition of the strata to be dug, we can reach the buried treasure at the lowest cost with careful planning. So you decided to create a program that reads the condition of the formation and calculates the route to reach the buried treasure depth at the lowest cost.
The state of the formation is represented by cells arranged in a two-dimensional grid, and the position of each cell is represented by the coordinates (x, y). Let the upper left be (1,1), and assume that the x coordinate increases as it goes to the right and the y coordinate increases as it goes deeper down. You choose one of the cells with the smallest y-coordinate and start digging from there, then dig into one of the cells with the largest y-coordinate. There are two types of cells in the formation:
1. A cell filled with soil. There is a fixed cost for each cell to dig.
2. Oxygen-filled cell. There is no need to dig, and each cell can be replenished with a fixed amount of oxygen. The oxygen in the cell that has been replenished with oxygen is exhausted and cannot be replenished again. Also, when you reach this cell, you must replenish oxygen.
Only left, right, and down cells can be dug from a cell. Once you have dug a cell, you can move it left or right, but you cannot move it up.
You must carry an oxygen cylinder with you when excavating. The moment the oxygen cylinder reaches zero, you will not be able to move, excavate, or replenish oxygen. The remaining amount is decremented by 1 each time you move the cell. Even if the remaining amount of the oxygen cylinder is 0 and the depth of the buried treasure is reached, it is not considered to have been reached. In addition, oxygen can be replenished in cells that have accumulated oxygen, but the excess capacity is discarded.
Create a program that inputs the size of the formation, the excavation cost, the capacity of the oxygen cylinder, the amount of oxygen in the initial state, and the information of the formation, and outputs the minimum cost to reach the deepest cell. However, if the minimum cost exceeds the excavation cost, or if you cannot reach the buried treasure no matter how you dig, please output "NA".
<image>
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two zero lines. Each dataset is given in the following format.
W H
f m o
c1,1 c2,1 ... cW,1
c1,2 c2,2 ... cW,2
...
c1, H c2, H ... cW, H
The horizontal size W of the formation and the vertical size H (3 ≤ W, H ≤ 10) are given in the first line. The second line is the integer f (1 ≤ f ≤ 10000) that represents your excavation cost, the integer m (3 ≤ m ≤ 50) that represents the capacity of the oxygen cylinder, and the integer o that represents the amount of oxygen you have in the initial state. o ≤ m) is given.
The following H line is given the geological information ci, j. ci, j represents the cell information for coordinates (i, j) and is given in the following format:
If the value is negative, the cell is full of soil and the value represents the cost.
If the value is positive, it is a cell filled with oxygen, and the value represents the amount of oxygen.
However, there are no more than 50 cells in which oxygen has accumulated.
The number of datasets does not exceed 50.
Output
Print the minimum cost or NA on one line for each dataset.
Example
Input
3 3
100 10 10
-100 -20 -100
-100 -20 -100
-100 -20 -100
3 3
100 10 10
-100 -20 -100
-100 -20 -20
-100 -60 -20
3 3
100 10 3
-100 -20 -100
-20 -20 -20
-20 -100 -20
3 3
100 3 3
-100 -20 -30
-100 -20 2
-100 -20 -20
4 5
1500 5 4
-10 -380 -250 -250
-90 2 -80 8
-250 -130 -330 -120
-120 -40 -50 -20
-250 -10 -20 -150
0 0
Output
60
80
NA
50
390 | ```python
import sys
sys.setrecursionlimit(1000000)
INF = 10 ** 20
def update_state(state, newx):
tmp = list(state)
tmp[newx] = 1
return tuple(tmp)
def get_co(x, y):
dc = do = 0
score = mp[y][x]
if score < 0:
dc = -score
else:
do = score
return dc, do
def minimum_cost(x, y, state, ox, goal, dic, w, m):
if (x, y, state, ox) in dic:
return dic[(x, y, state, ox)]
if y == goal:
return 0
if ox <= 1:
return INF
ret = INF
if x >= 1:
if state[x - 1] == 0:
dc, do = get_co(x - 1, y)
ret = min(ret, minimum_cost(x - 1, y, update_state(state, x - 1), min(ox + do - 1, m), goal, dic, w, m) + dc)
else:
ret = min(ret, minimum_cost(x - 1, y, state, ox - 1, goal, dic, w, m))
if x < w - 1:
if state[x + 1] == 0:
dc, do = get_co(x + 1, y)
ret = min(ret, minimum_cost(x + 1, y, update_state(state, x + 1), min(ox + do - 1, m), goal, dic, w, m) + dc)
else:
ret = min(ret, minimum_cost(x + 1, y, state, ox - 1, goal, dic, w, m))
dc, do = get_co(x, y + 1)
ret = min(ret, minimum_cost(x, y + 1, tuple((1 if i == x else 0 for i in range(w))), min(ox + do - 1, m), goal, dic, w, m) + dc)
dic[(x, y, state, ox)] = ret
return ret
while True:
w, h = map(int, input().split())
if w == 0:
break
f, m, o = map(int, input().split())
mp = [list(map(int, input().split())) for _ in range(h)]
if o <= 1:
print("NA")
continue
dic = {}
ans = INF
for i in range(w):
dc, do = get_co(i, 0)
state = tuple(1 if i == j else 0 for j in range(w))
ans = min(ans, minimum_cost(i, 0, state, min(o + do - 1, m), h - 1, dic, w, m) + dc)
if ans > f:
print("NA")
else:
print(ans)
``` |
p00396 Playing With Stones | Playing with Stones
Koshiro and Ukiko are playing a game with black and white stones. The rules of the game are as follows:
1. Before starting the game, they define some small areas and place "one or more black stones and one or more white stones" in each of the areas.
2. Koshiro and Ukiko alternately select an area and perform one of the following operations.
(a) Remove a white stone from the area
(b) Remove one or more black stones from the area. Note, however, that the number of the black stones must be less than or equal to white ones in the area.
(c) Pick up a white stone from the stone pod and replace it with a black stone. There are plenty of white stones in the pod so that there will be no shortage during the game.
3. If either Koshiro or Ukiko cannot perform 2 anymore, he/she loses.
They played the game several times, with Koshiro’s first move and Ukiko’s second move, and felt the winner was determined at the onset of the game. So, they tried to calculate the winner assuming both players take optimum actions.
Given the initial allocation of black and white stones in each area, make a program to determine which will win assuming both players take optimum actions.
Input
The input is given in the following format.
$N$
$w_1$ $b_1$
$w_2$ $b_2$
:
$w_N$ $b_N$
The first line provides the number of areas $N$ ($1 \leq N \leq 10000$). Each of the subsequent $N$ lines provides the number of white stones $w_i$ and black stones $b_i$ ($1 \leq w_i, b_i \leq 100$) in the $i$-th area.
Output
Output 0 if Koshiro wins and 1 if Ukiko wins.
Examples
Input
4
24 99
15 68
12 90
95 79
Output
0
Input
3
2 46
94 8
46 57
Output
1 | ```python
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
g = defaultdict(lambda : None)
g[(0,0)] = 0
def grundy(w,b):
if g[(w,b)] != None:
return g[(w,b)]
s = set()
if w:
s.add(grundy(w-1,b))
if b:
s.add(grundy(w+1,b-1))
for i in range(1,min(w,b)+1):
s.add(grundy(w,b-i))
i = 0
while i in s:
i += 1
g[(w,b)] = i
return i
n = I()
ans = 0
for _ in range(n):
w,b = LI()
ans ^= grundy(w,b)
print(0 if ans else 1)
return
#Solve
if __name__ == "__main__":
solve()
``` |
p00749 Off Balance | You are working for an administration office of the International Center for Picassonian Cubism (ICPC), which plans to build a new art gallery for young artists. The center is organizing an architectural design competition to find the best design for the new building.
Submitted designs will look like a screenshot of a well known game as shown below.
<image>
This is because the center specifies that the building should be constructed by stacking regular units called pieces, each of which consists of four cubic blocks. In addition, the center requires the competitors to submit designs that satisfy the following restrictions.
* All the pieces are aligned. When two pieces touch each other, the faces of the touching blocks must be placed exactly at the same position.
* All the pieces are stable. Since pieces are merely stacked, their centers of masses must be carefully positioned so as not to collapse.
* The pieces are stacked in a tree-like form in order to symbolize boundless potentiality of young artists. In other words, one and only one piece touches the ground, and each of other pieces touches one and only one piece on its bottom faces.
* The building has a flat shape. This is because the construction site is a narrow area located between a straight moat and an expressway where no more than one block can be placed between the moat and the expressway as illustrated below.
<image>
It will take many days to fully check stability of designs as it requires complicated structural calculation. Therefore, you are asked to quickly check obviously unstable designs by focusing on centers of masses. The rules of your quick check are as follows.
Assume the center of mass of a block is located at the center of the block, and all blocks have the same weight. We denote a location of a block by xy-coordinates of its left-bottom corner. The unit length is the edge length of a block.
Among the blocks of the piece that touch another piece or the ground on their bottom faces, let xL be the leftmost x-coordinate of the leftmost block, and let xR be the rightmost x-coordinate of the rightmost block. Let the x-coordinate of its accumulated center of mass of the piece be M, where the accumulated center of mass of a piece P is the center of the mass of the pieces that are directly and indirectly supported by P, in addition to P itself. Then the piece is stable, if and only if xL < M < xR. Otherwise, it is unstable. A design of a building is unstable if any of its pieces is unstable.
Note that the above rules could judge some designs to be unstable even if it would not collapse in reality. For example, the left one of the following designs shall be judged to be unstable.
<image> | | <image>
---|---|---
Also note that the rules judge boundary cases to be unstable. For example, the top piece in the above right design has its center of mass exactly above the right end of the bottom piece. This shall be judged to be unstable.
Write a program that judges stability of each design based on the above quick check rules.
Input
The input is a sequence of datasets. The end of the input is indicated by a line containing two zeros separated by a space. Each dataset, which represents a front view of a building, is formatted as follows.
> w h
> p0(h-1)p1(h-1)...p(w-1)(h-1)
> ...
> p01p11...p(w-1)1
> p00p10...p(w-1)0
>
The integers w and h separated by a space are the numbers of columns and rows of the layout, respectively. You may assume 1 ≤ w ≤ 10 and 1 ≤ h ≤ 60. The next h lines specify the placement of the pieces. The character pxy indicates the status of a block at (x,y), either ``.`', meaning empty, or one digit character between ``1`' and ``9`', inclusive, meaning a block of a piece. (As mentioned earlier, we denote a location of a block by xy-coordinates of its left-bottom corner.)
When two blocks with the same number touch each other by any of their top, bottom, left or right face, those blocks are of the same piece. (Note that there might be two different pieces that are denoted by the same number.) The bottom of a block at (x,0) touches the ground.
You may assume that the pieces in each dataset are stacked in a tree-like form.
Output
For each dataset, output a line containing a word `STABLE` when the design is stable with respect to the above quick check rules. Otherwise, output `UNSTABLE`. The output should be written with uppercase letters, and should not contain any other extra characters.
Sample Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output for the Sample Input
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
Example
Input
4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0
Output
STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE | ```python
while True:
w, h = map(int, input().split())
if w == 0:
break
mp = [[0] + list(input()) + [0] for _ in range(h)]
mp.insert(0, [0] * (w + 2))
mp.append([0] * (w + 2))
for y in range(1, h + 1):
for x in range(1, w + 1):
if mp[y][x] == ".":
mp[y][x] = 0
else:
mp[y][x] = int(mp[y][x])
last_id = 10
vec = ((0, 1), (0, -1), (1, 0), (-1, 0))
def update(last_id, target, x, y):
if mp[y][x] != target:
return
mp[y][x] = last_id
for dx, dy in vec:
update(last_id, target, x + dx, y + dy)
for y in range(1, h + 1):
for x in range(1, w + 1):
if 1 <= mp[y][x] <= 9:
update(last_id, mp[y][x], x, y)
last_id += 1
node_num = last_id - 10
edges = [set() for _ in range(node_num)]
for y in range(1, h + 1):
for x in range(1, w + 1):
if mp[y - 1][x] != mp[y][x] and mp[y - 1][x] != 0 and mp[y][x] != 0:
edges[mp[y][x] - 10].add(mp[y - 1][x] - 10)
for x in range(1, w + 1):
if mp[h][x] != 0:
root = mp[h][x] - 10
break
center = [0] * node_num
ground = [None] * node_num
for y in range(1, h + 1):
for x in range(1, w + 1):
if mp[y][x] != 0:
target = mp[y][x] - 10
center[target] += (x + 0.5) / 4
if mp[y + 1][x] in (0, target + 10):
continue
if ground[target] == None:
ground[target] = [x, x + 1]
else:
ground[target][0] = min(ground[target][0], x)
ground[target][1] = max(ground[target][1], x + 1)
for x in range(1, w + 1):
if mp[h][x] == root + 10:
if ground[root] == None:
ground[root] = [x, x + 1]
else:
ground[root][0] = min(ground[root][0], x)
ground[root][1] = max(ground[root][1], x + 1)
total_center = [None] * node_num
def get_total_center(node):
mom = center[node]
wei = 1
for to in edges[node]:
to_wei, to_pos = get_total_center(to)
mom += to_wei * to_pos
wei += to_wei
total_center[node] = mom / wei
return wei, total_center[node]
get_total_center(root)
for gr, cen in zip(ground, total_center):
l, r = gr
if not (l < cen < r):
print("UNSTABLE")
break
else:
print("STABLE")
``` |
p00887 Awkward Lights | You are working as a night watchman in an office building. Your task is to check whether all the lights in the building are turned off after all the office workers in the building have left the office. If there are lights that are turned on, you must turn off those lights. This task is not as easy as it sounds to be because of the strange behavior of the lighting system of the building as described below. Although an electrical engineer checked the lighting system carefully, he could not determine the cause of this behavior. So you have no option but to continue to rely on this system for the time being.
Each floor in the building consists of a grid of square rooms. Every room is equipped with one light and one toggle switch. A toggle switch has two positions but they do not mean fixed ON/OFF. When the position of the toggle switch of a room is changed to the other position, in addition to that room, the ON/OFF states of the lights of the rooms at a certain Manhattan distance from that room are reversed. The Manhattan distance between the room at (x1, y1) of a grid of rooms and the room at (x2, y2) is given by |x1 - x2| + |y1 - y2|. For example, if the position of the toggle switch of the room at (2, 2) of a 4 × 4 grid of rooms is changed and the given Manhattan distance is two, the ON/OFF states of the lights of the rooms at (1, 1), (1, 3), (2, 4), (3, 1), (3, 3), and (4, 2) as well as at (2, 2) are reversed as shown in Figure D.1, where black and white squares represent the ON/OFF states of the lights.
<image>
Figure D.1: An example behavior of the lighting system
Your mission is to write a program that answer whether all the lights on a floor can be turned off.
Input
The input is a sequence of datasets. Each dataset is formatted as follows.
m n d
S11 S12 S13 ... S1m
S21 S22 S23 ... S2m
...
Sn1 Sn2 Sn3 ... Snm
The first line of a dataset contains three integers. m and n (1 ≤ m ≤ 25, 1 ≤ n ≤ 25) are the numbers of columns and rows of the grid, respectively. d (1 ≤ d ≤ m + n) indicates the Manhattan distance. Subsequent n lines of m integers are the initial ON/OFF states. Each Sij (1 ≤ i ≤ n, 1 ≤ j ≤ m) indicates the initial ON/OFF state of the light of the room at (i, j): '0' for OFF and '1' for ON.
The end of the input is indicated by a line containing three zeros.
Output
For each dataset, output '1' if all the lights can be turned off. If not, output '0'. In either case, print it in one line for each input dataset.
Example
Input
1 1 1
1
2 2 1
1 1
1 1
3 2 1
1 0 1
0 1 0
3 3 1
1 0 1
0 1 0
1 0 1
4 4 2
1 1 0 1
0 0 0 1
1 0 1 1
1 0 0 0
5 5 1
1 1 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
5 5 2
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
11 11 3
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 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 1 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 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
11 11 3
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 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 1 1 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 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
13 13 7
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 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 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 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
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 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0
Output
1
1
0
1
0
0
1
1
0
1 | ```python
import sys,queue,math,copy,itertools
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
while True:
M,N,D = LI()
if N == 0 : break
S = []
for _ in range(N):
S.extend(LI())
x = []
for i in range(N):
for j in range(M):
y = [0 for _ in range(N*M)]
for p in range(-D,D+1):
q1 = j + (D - abs(p))
q2 = j - (D - abs(p))
if 0 <= i + p < N and 0 <= q1 < M:
y[(i+p) * M + q1] = 1
if 0 <= i+ p < N and 0 <= q2 < M:
y[(i+p) * M + q2] = 1
y[i * M + j] = 1
x.append(y)
x.append(S)
z = []
for i in range(N*M):
b = 0
for j in range(N*M+1):
b <<= 1
b += x[j][i]
z.append(b)
c = [True for _ in range(N*M)]
b = 1 << (N * M)
for i in range(N*M):
for j in range(N*M):
if z[j] & b and c[j]:
for k in range(N*M):
if k == j or z[k] & b == 0: continue
z[k] ^= z[j]
c[j] = False
break
b >>= 1
if z.count(1):
print (0)
else:
print (1)
``` |
p01018 Warping Girl | Problem
Aizu Magic School is a school where people who can use magic gather. Haruka, one of the students of that school, can use the magic of warp on the magic team.
From her house to the school, there is a straight road of length L. There are also magic circles on this road.
She uses this road every day to go to school, so she wants to get to school in the shortest possible time.
So as a programmer, you decided to teach her the minimum amount of time it would take to get to school.
Haruka can walk forward by a distance of 1 in 1 minute (* cannot go back). Also, by casting magic at the position Pi where the magic circle of the warp is written, you can move in Ti minutes to the place just Di from Pi. Even if there is a magic circle at the destination, it will be continuous. You can use warp magic.
The location of her house is 0 and the location of her school is L.
Constraints
The input meets the following conditions.
* All numbers given are integers
* 1 ≤ L ≤ 109
* 0 ≤ n ≤ min (103, L) (min represents the smaller of A and B)
* 0 ≤ Pi ≤ L -1
* 0 ≤ Di ≤ L --Pi
* 0 ≤ Ti ≤ 103
* Pi ≠ Pj
Input
L n
P1 D1 T1
P2 D2 T2
..
..
Pn Dn Tn
The first line is given the length of the road L, the number of magic circles n. Next, the state of n magic circles is given. Pi is the position where the i-th magic circle is, and Di is the i-th magic circle. Distance to warp from, Ti represents the time it takes to warp using the i-th magic circle.
Output
Output the minimum time to get to school in one line.
Examples
Input
10 3
2 2 1
4 2 1
8 1 1
Output
8
Input
10 2
2 3 1
3 5 1
Output
6
Input
1 0
Output
1 | ```python
INF = 10 ** 20
l, n = map(int, input().split())
lst = [list(map(int, input().split())) for _ in range(n)] + [[l, 0, INF]]
lst.sort()
score = {}
for p, _, _ in lst:
score[p] = p
for i in range(n + 1):
p, d, t = lst[i]
for j in range(i + 1, n + 1):
to_p, _, _ = lst[j]
if to_p >= p + d:
score[to_p] = min(score[to_p], score[p] + t + to_p - p - d, score[p] + to_p - p)
else:
score[to_p] = min(score[to_p], score[p] + to_p - p)
print(score[l])
``` |
p01290 Queen's Case | A small country called Maltius was governed by a queen. The queen was known as an oppressive ruler. People in the country suffered from heavy taxes and forced labor. So some young people decided to form a revolutionary army and fight against the queen. Now, they besieged the palace and have just rushed into the entrance.
Your task is to write a program to determine whether the queen can escape or will be caught by the army.
Here is detailed description.
* The palace can be considered as grid squares.
* The queen and the army move alternately. The queen moves first.
* At each of their turns, they either move to an adjacent cell or stay at the same cell.
* Each of them must follow the optimal strategy.
* If the queen and the army are at the same cell, the queen will be caught by the army immediately.
* If the queen is at any of exit cells alone after the army’s turn, the queen can escape from the army.
* There may be cases in which the queen cannot escape but won’t be caught by the army forever, under their optimal strategies.
Hint
On the first sample input, the queen can move to exit cells, but either way the queen will be caught at the next army’s turn. So the optimal strategy for the queen is staying at the same cell. Then the army can move to exit cells as well, but again either way the army will miss the queen from the other exit. So the optimal strategy for the army is also staying at the same cell. Thus the queen cannot escape but won’t be caught.
Input
The input consists of multiple datasets. Each dataset describes a map of the palace. The first line of the input contains two integers W (1 ≤ W ≤ 30) and H (1 ≤ H ≤ 30), which indicate the width and height of the palace. The following H lines, each of which contains W characters, denote the map of the palace. "Q" indicates the queen, "A" the army,"E" an exit,"#" a wall and "." a floor.
The map contains exactly one "Q", exactly one "A" and at least one "E". You can assume both the queen and the army can reach all the exits.
The last dataset is followed by a line containing two zeros. This line is not a part of any dataset and should not be processed.
Output
For each dataset, output "Queen can escape.", "Army can catch Queen." or "Queen can not escape and Army can not catch Queen." in a line.
Examples
Input
2 2
QE
EA
3 1
QAE
3 1
AQE
5 5
..E..
.###.
A###Q
.###.
..E..
5 1
A.E.Q
5 5
A....
####.
..E..
.####
....Q
0 0
Output
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Queen can escape.
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Army can catch Queen.
Input
2 2
QE
EA
3 1
QAE
3 1
AQE
5 5
..E..
.###.
A###Q
.###.
..E..
5 1
A.E.Q
5 5
A....
.
..E..
.####
....Q
0 0
Output
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Queen can escape.
Queen can not escape and Army can not catch Queen.
Army can catch Queen.
Army can catch Queen. | ```python
from collections import deque, defaultdict
import sys
readline = sys.stdin.readline
write = sys.stdout.write
dd = ((-1, 0), (0, -1), (1, 0), (0, 1), (0, 0))
def solve():
W, H = map(int, readline().split())
if W == H == 0:
return False
S = [readline().strip() for i in range(H)]
px = py = qx = qy = 0
rs = []
pp = []
MP = [[0]*W for i in range(H)]
for i in range(H):
for j, c in enumerate(S[i]):
if c == "Q":
px = j; py = i
elif c == "A":
qx = j; qy = i
elif c == "E":
MP[i][j] = 1
rs.append((j, i))
elif c == "#":
MP[i][j] = 2
if c != "#":
pp.append((j, i))
mp = {}
L = 0
for ax, ay in pp:
for bx, by in pp:
mp[ax, ay, bx, by, 0] = L
L += 1
mp[ax, ay, bx, by, 1] = L
L += 1
que1 = deque()
ss = [-1]*L
cc = [0]*L
que = deque([(px, py, qx, qy, 0)])
used = [0]*L
used[mp[px, py, qx, qy, 0]] = 1
RG = [[] for i in range(L)]
deg = [0]*L
while que:
ax, ay, bx, by, t = key = que.popleft()
k0 = mp[key]
if ax == bx and ay == by:
que1.append(k0)
ss[k0] = 1
continue
if t == 0 and MP[ay][ax] == 1:
que1.append(k0)
ss[k0] = 0
continue
if t == 1:
for dx, dy in dd:
nx = bx + dx; ny = by + dy
if not 0 <= nx < W or not 0 <= ny < H or MP[ny][nx] == 2:
continue
k1 = mp[ax, ay, nx, ny, t^1]
deg[k0] += 1
RG[k1].append(k0)
if not used[k1]:
used[k1] = 1
que.append((ax, ay, nx, ny, t^1))
else:
for dx, dy in dd:
nx = ax + dx; ny = ay + dy
if not 0 <= nx < W or not 0 <= ny < H or MP[ny][nx] == 2:
continue
k1 = mp[nx, ny, bx, by, t^1]
deg[k0] += 1
RG[k1].append(k0)
if not used[k1]:
used[k1] = 1
que.append((nx, ny, bx, by, t^1))
while que1:
v = que1.popleft()
s = ss[v]; t = v % 2
if t == 0:
for w in RG[v]:
if ss[w] != -1:
continue
if s == 1:
que1.append(w)
ss[w] = 1
else:
deg[w] -= 1
if deg[w] == 0:
que1.append(w)
ss[w] = 0
else:
for w in RG[v]:
if ss[w] != -1:
continue
if s == 0:
que1.append(w)
ss[w] = 0
else:
deg[w] -= 1
if deg[w] == 0:
que1.append(w)
ss[w] = 1
k0 = mp[px, py, qx, qy, 0]
if ss[k0] == -1:
write("Queen can not escape and Army can not catch Queen.\n")
elif ss[k0] == 0:
write("Queen can escape.\n")
else:
write("Army can catch Queen.\n")
return True
while solve():
...
``` |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.