name
stringlengths 9
112
| description
stringlengths 29
13k
| solutions
stringlengths 24
49.8k
|
|---|---|---|
645_D. Robot Rapping Results Report | While Farmer John rebuilds his farm in an unfamiliar portion of Bovinia, Bessie is out trying some alternative jobs. In her new gig as a reporter, Bessie needs to know about programming competition results as quickly as possible. When she covers the 2016 Robot Rap Battle Tournament, she notices that all of the robots operate under deterministic algorithms. In particular, robot i will beat robot j if and only if robot i has a higher skill level than robot j. And if robot i beats robot j and robot j beats robot k, then robot i will beat robot k. Since rapping is such a subtle art, two robots can never have the same skill level.
Given the results of the rap battles in the order in which they were played, determine the minimum number of first rap battles that needed to take place before Bessie could order all of the robots by skill level.
Input
The first line of the input consists of two integers, the number of robots n (2 ≤ n ≤ 100 000) and the number of rap battles m (<image>).
The next m lines describe the results of the rap battles in the order they took place. Each consists of two integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), indicating that robot ui beat robot vi in the i-th rap battle. No two rap battles involve the same pair of robots.
It is guaranteed that at least one ordering of the robots satisfies all m relations.
Output
Print the minimum k such that the ordering of the robots by skill level is uniquely defined by the first k rap battles. If there exists more than one ordering that satisfies all m relations, output -1.
Examples
Input
4 5
2 1
1 3
2 3
4 2
4 3
Output
4
Input
3 2
1 2
3 2
Output
-1
Note
In the first sample, the robots from strongest to weakest must be (4, 2, 1, 3), which Bessie can deduce after knowing the results of the first four rap battles.
In the second sample, both (1, 3, 2) and (3, 1, 2) are possible orderings of the robots from strongest to weakest after both rap battles. | ```python
from collections import defaultdict
class RobotRapping():
def __init__(self, n, m, battles):
self.n, self.m = n, m
self.battles = battles
def generate_graph(self, k):
edge_map = defaultdict(list)
rev_map = defaultdict(list)
for i in range(k):
edge_map[self.battles[i][0]-1].append((self.battles[i][1]-1, i))
rev_map[self.battles[i][1]-1].append((self.battles[i][0]-1, i))
return edge_map, rev_map
def check_order(self, num_battles):
edge_map, rev_map = self.generate_graph(num_battles)
outgoing_cnt = defaultdict(int)
for k in edge_map:
outgoing_cnt[k] = len(edge_map[k])
s = []
cntr = 0
for i in range(self.n):
if outgoing_cnt[i] == 0:
s.append(i)
while len(s) > cntr:
if len(s) > cntr+1 :
return False
else:
node = s[cntr]
for v in rev_map[node]:
outgoing_cnt[v] -= 1
if outgoing_cnt[v] == 0:
s.append(v)
cntr += 1
return True
def min_battles(self):
if not self.check_order(self.m):
print(-1)
else:
mn, mx = 0, self.m
while mn < mx-1:
md = int((mn+mx)/2)
if self.check_order(md):
mx = md
else:
mn = md
print(mx)
def min_battles2(self):
edge_map, rev_map = self.generate_graph(self.m)
outgoing_cnt = defaultdict(int)
for k in edge_map:
outgoing_cnt[k] = len(edge_map[k])
s = []
cntr = 0
order = []
for i in range(self.n):
if outgoing_cnt[i] == 0:
s.append(i)
while len(s) > cntr:
if len(s) > cntr+1 :
print(-1)
return
else:
node = s[cntr]
order.append(node)
for v,_ in rev_map[node]:
outgoing_cnt[v] -= 1
if outgoing_cnt[v] == 0:
s.append(v)
cntr += 1
mn_pos = -1
for i in range(1,self.n):
for v,ind in edge_map[order[i]]:
if v == order[i-1]:
mn_pos = max(mn_pos, ind)
break
print(mn_pos+1)
n,m = list(map(int,input().strip(' ').split(' ')))
battles = []
for i in range(m):
x,y = list(map(int,input().strip(' ').split(' ')))
battles.append((x,y))
rr = RobotRapping(n,m,battles)
rr.min_battles2()
``` |
672_B. Different is Good | A wise man told Kerem "Different is good" once, so Kerem wants all things in his life to be different.
Kerem recently got a string s consisting of lowercase English letters. Since Kerem likes it when things are different, he wants all substrings of his string s to be distinct. Substring is a string formed by some number of consecutive characters of the string. For example, string "aba" has substrings "" (empty substring), "a", "b", "a", "ab", "ba", "aba".
If string s has at least two equal substrings then Kerem will change characters at some positions to some other lowercase English letters. Changing characters is a very tiring job, so Kerem want to perform as few changes as possible.
Your task is to find the minimum number of changes needed to make all the substrings of the given string distinct, or determine that it is impossible.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100 000) — the length of the string s.
The second line contains the string s of length n consisting of only lowercase English letters.
Output
If it's impossible to change the string s such that all its substring are distinct print -1. Otherwise print the minimum required number of changes.
Examples
Input
2
aa
Output
1
Input
4
koko
Output
2
Input
5
murat
Output
0
Note
In the first sample one of the possible solutions is to change the first character to 'b'.
In the second sample, one may change the first character to 'a' and second character to 'b', so the string becomes "abko". | ```python
n = int(input())
s = input()
s = set(s)
if n<27:
print(n - len(s))
else:
print('-1')
``` |
697_D. Puzzles | Barney lives in country USC (United States of Charzeh). USC has n cities numbered from 1 through n and n - 1 roads between them. Cities and roads of USC form a rooted tree (Barney's not sure why it is rooted). Root of the tree is the city number 1. Thus if one will start his journey from city 1, he can visit any city he wants by following roads.
<image>
Some girl has stolen Barney's heart, and Barney wants to find her. He starts looking for in the root of the tree and (since he is Barney Stinson not a random guy), he uses a random DFS to search in the cities. A pseudo code of this algorithm is as follows:
let starting_time be an array of length n
current_time = 0
dfs(v):
current_time = current_time + 1
starting_time[v] = current_time
shuffle children[v] randomly (each permutation with equal possibility)
// children[v] is vector of children cities of city v
for u in children[v]:
dfs(u)
As told before, Barney will start his journey in the root of the tree (equivalent to call dfs(1)).
Now Barney needs to pack a backpack and so he wants to know more about his upcoming journey: for every city i, Barney wants to know the expected value of starting_time[i]. He's a friend of Jon Snow and knows nothing, that's why he asked for your help.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 105) — the number of cities in USC.
The second line contains n - 1 integers p2, p3, ..., pn (1 ≤ pi < i), where pi is the number of the parent city of city number i in the tree, meaning there is a road between cities numbered pi and i in USC.
Output
In the first and only line of output print n numbers, where i-th number is the expected value of starting_time[i].
Your answer for each city will be considered correct if its absolute or relative error does not exceed 10 - 6.
Examples
Input
7
1 2 1 1 4 4
Output
1.0 4.0 5.0 3.5 4.5 5.0 5.0
Input
12
1 1 2 2 4 4 3 3 1 10 8
Output
1.0 5.0 5.5 6.5 7.5 8.0 8.0 7.0 7.5 6.5 7.5 8.0 | ```python
import sys
input = sys.stdin.readline
n = int(input())
par = [-1] + [int(i) - 1 for i in input().split()]
child = [[] for i in range(n)]
for i in range(1, n):
child[par[i]].append(i)
size = [1] * n
def dfs():
stack = [0]
visit = [False] * n
while stack:
u = stack[-1]
if not visit[u]:
for v in child[u]:
stack.append(v)
visit[u] = True
else:
for v in child[u]:
size[u] += size[v]
stack.pop()
ans = [0] * n
ans[0] = 1
def dfs2():
stack = [0]
while stack:
u = stack.pop()
sm = 0
for v in child[u]:
sm += size[v]
for v in child[u]:
ans[v] = (sm - size[v]) * 0.5 + 1 + ans[u]
stack.append(v)
dfs()
dfs2()
print(*ans)
``` |
73_B. Need For Brake | Vasya plays the Need For Brake. He plays because he was presented with a new computer wheel for birthday! Now he is sure that he will win the first place in the championship in his favourite racing computer game!
n racers take part in the championship, which consists of a number of races. After each race racers are arranged from place first to n-th (no two racers share the same place) and first m places are awarded. Racer gains bi points for i-th awarded place, which are added to total points, obtained by him for previous races. It is known that current summary score of racer i is ai points. In the final standings of championship all the racers will be sorted in descending order of points. Racers with an equal amount of points are sorted by increasing of the name in lexicographical order.
Unfortunately, the championship has come to an end, and there is only one race left. Vasya decided to find out what the highest and lowest place he can take up as a result of the championship.
Input
The first line contains number n (1 ≤ n ≤ 105) — number of racers. Each of the next n lines contains si and ai — nick of the racer (nonempty string, which consist of no more than 20 lowercase Latin letters) and the racer's points (0 ≤ ai ≤ 106). Racers are given in the arbitrary order.
The next line contains the number m (0 ≤ m ≤ n). Then m nonnegative integer numbers bi follow. i-th number is equal to amount of points for the i-th awarded place (0 ≤ bi ≤ 106).
The last line contains Vasya's racer nick.
Output
Output two numbers — the highest and the lowest place Vasya can take up as a result of the championship.
Examples
Input
3
teama 10
teamb 20
teamc 40
2
10 20
teama
Output
2 3
Input
2
teama 10
teamb 10
2
10 10
teamb
Output
2 2 | ```python
class Racer:
def __init__(self, name, points):
self.name = name
self.points = points
def __str__(self):
return '%s %d' % (self.name, self.points)
n = int(input())
best = n * [ None ]
worst = n * [ None ]
for i in range(n):
name, points = input().split()
points = int(points)
best[i] = Racer(name, points)
worst[i] = Racer(name, points)
m = int(input())
place_bonus = list(reversed(sorted(map(int, input().split()))))
your_name = input().strip()
debugging = False
def debug_print(s):
if debugging:
print(s)
def find(racers, name):
for i in range(n):
if racers[i].name == name:
return i
def sort_racers(racers):
racers.sort(key=lambda racer: (-racer.points, racer.name))
# Highest possible ranking.
you = best[find(best, your_name)]
# You get the biggest bonus.
if m != 0:
you.points += place_bonus[0]
sort_racers(best)
# People ahead of you get the next biggest bonuses.
bonus_pos = 1
for i in range(find(best, your_name) - 1, -1, -1):
if bonus_pos >= m:
break
best[i].points += place_bonus[bonus_pos]
bonus_pos += 1
# People at the end get the remaining bonuses.
for i in range(n - 1, -1, -1):
if bonus_pos >= m:
break
best[i].points += place_bonus[bonus_pos]
bonus_pos += 1
sort_racers(best)
debug_print(list(map(str, best)))
best_ranking = find(best, your_name) + 1
debug_print('best ranking: %d' % best_ranking)
# Lowest possible ranking.
you = worst[find(worst, your_name)]
# If you must get a bonus, it's the smallest one.
if m == n:
you.points += place_bonus.pop()
m -= 1
sort_racers(worst)
# Award the smallest possible bonus to the person who can pass you most easily.
bonus_pos = m - 1
worst_pos = find(worst, your_name) + 1
while bonus_pos >= 0 and worst_pos < n:
debug_print('bonus_pos = %d, worst_pos = %d' % (bonus_pos, worst_pos))
candidate = worst[worst_pos]
need = you.points - candidate.points
if candidate.name > you.name:
need += 1
if place_bonus[bonus_pos] >= need:
candidate.points += place_bonus[bonus_pos]
worst_pos += 1
bonus_pos -= 1
sort_racers(worst)
debug_print(list(map(str, worst)))
worst_ranking = find(worst, your_name) + 1
debug_print('worst ranking: %d' % worst_ranking)
print('%d %d' % (best_ranking, worst_ranking))
# Made By Mostafa_Khaled
``` |
808_A. Lucky Year | Apart from having lots of holidays throughout the year, residents of Berland also have whole lucky years. Year is considered lucky if it has no more than 1 non-zero digit in its number. So years 100, 40000, 5 are lucky and 12, 3001 and 12345 are not.
You are given current year in Berland. Your task is to find how long will residents of Berland wait till the next lucky year.
Input
The first line contains integer number n (1 ≤ n ≤ 109) — current year in Berland.
Output
Output amount of years from the current year to the next lucky one.
Examples
Input
4
Output
1
Input
201
Output
99
Input
4000
Output
1000
Note
In the first example next lucky year is 5. In the second one — 300. In the third — 5000. | ```python
import math
a = int(input())
#print(math.log(a))
b = int(10 ** ((math.log(a+1) // math.log(10))))
#print(b)
total = b
while total <= a:
total += b
print(str(total-a))
``` |
832_B. Petya and Exam | It's hard times now. Today Petya needs to score 100 points on Informatics exam. The tasks seem easy to Petya, but he thinks he lacks time to finish them all, so he asks you to help with one..
There is a glob pattern in the statements (a string consisting of lowercase English letters, characters "?" and "*"). It is known that character "*" occurs no more than once in the pattern.
Also, n query strings are given, it is required to determine for each of them if the pattern matches it or not.
Everything seemed easy to Petya, but then he discovered that the special pattern characters differ from their usual meaning.
A pattern matches a string if it is possible to replace each character "?" with one good lowercase English letter, and the character "*" (if there is one) with any, including empty, string of bad lowercase English letters, so that the resulting string is the same as the given string.
The good letters are given to Petya. All the others are bad.
Input
The first line contains a string with length from 1 to 26 consisting of distinct lowercase English letters. These letters are good letters, all the others are bad.
The second line contains the pattern — a string s of lowercase English letters, characters "?" and "*" (1 ≤ |s| ≤ 105). It is guaranteed that character "*" occurs in s no more than once.
The third line contains integer n (1 ≤ n ≤ 105) — the number of query strings.
n lines follow, each of them contains single non-empty string consisting of lowercase English letters — a query string.
It is guaranteed that the total length of all query strings is not greater than 105.
Output
Print n lines: in the i-th of them print "YES" if the pattern matches the i-th query string, and "NO" otherwise.
You can choose the case (lower or upper) for each letter arbitrary.
Examples
Input
ab
a?a
2
aaa
aab
Output
YES
NO
Input
abc
a?a?a*
4
abacaba
abaca
apapa
aaaaax
Output
NO
YES
NO
YES
Note
In the first example we can replace "?" with good letters "a" and "b", so we can see that the answer for the first query is "YES", and the answer for the second query is "NO", because we can't match the third letter.
Explanation of the second example.
* The first query: "NO", because character "*" can be replaced with a string of bad letters only, but the only way to match the query string is to replace it with the string "ba", in which both letters are good.
* The second query: "YES", because characters "?" can be replaced with corresponding good letters, and character "*" can be replaced with empty string, and the strings will coincide.
* The third query: "NO", because characters "?" can't be replaced with bad letters.
* The fourth query: "YES", because characters "?" can be replaced with good letters "a", and character "*" can be replaced with a string of bad letters "x". | ```python
a=input()
s=input()
k=int(input())
def qw(c):
t=True
w=-1
if len(s)>len(c)+1: t=False
try:
for j in range(len(s)):
w+=1
if s[j]=='?':
if c[w] not in a: t=False
elif s[j]=='*':
b=len(c)-len(s)+1
for e in c[j:j+b]:
if e in a:
t=False
w+=b-1
else:
if s[j]!=c[w]: t=False
if t==False: break
except IndexError:
return False
return t if len(c)==w+1 else False
for i in range(k):
c=input()
print('YES') if qw(c) else print('NO')
``` |
877_D. Olya and Energy Drinks | Olya loves energy drinks. She loves them so much that her room is full of empty cans from energy drinks.
Formally, her room can be represented as a field of n × m cells, each cell of which is empty or littered with cans.
Olya drank a lot of energy drink, so now she can run k meters per second. Each second she chooses one of the four directions (up, down, left or right) and runs from 1 to k meters in this direction. Of course, she can only run through empty cells.
Now Olya needs to get from cell (x1, y1) to cell (x2, y2). How many seconds will it take her if she moves optimally?
It's guaranteed that cells (x1, y1) and (x2, y2) are empty. These cells can coincide.
Input
The first line contains three integers n, m and k (1 ≤ n, m, k ≤ 1000) — the sizes of the room and Olya's speed.
Then n lines follow containing m characters each, the i-th of them contains on j-th position "#", if the cell (i, j) is littered with cans, and "." otherwise.
The last line contains four integers x1, y1, x2, y2 (1 ≤ x1, x2 ≤ n, 1 ≤ y1, y2 ≤ m) — the coordinates of the first and the last cells.
Output
Print a single integer — the minimum time it will take Olya to get from (x1, y1) to (x2, y2).
If it's impossible to get from (x1, y1) to (x2, y2), print -1.
Examples
Input
3 4 4
....
###.
....
1 1 3 1
Output
3
Input
3 4 1
....
###.
....
1 1 3 1
Output
8
Input
2 2 1
.#
#.
1 1 2 2
Output
-1
Note
In the first sample Olya should run 3 meters to the right in the first second, 2 meters down in the second second and 3 meters to the left in the third second.
In second sample Olya should run to the right for 3 seconds, then down for 2 seconds and then to the left for 3 seconds.
Olya does not recommend drinking energy drinks and generally believes that this is bad. | ```python
from collections import deque
n, m, k = map(int, input().split())
INF = float("inf")
d = [[INF] * m for _ in range(n)]
t = [[] for i in range(n)]
for i in range(n):
a = list(input())
t[i] = a
sx, sy, gx, gy = map(int, input().split())
sx, sy, gx, gy = sx - 1, sy - 1, gx - 1, gy - 1
def bfs():
que = deque()
que.append((sx, sy))
d[sx][sy] = 0
while len(que):
x, y = que.popleft()
if x == gx and y == gy:
break
for dx, dy in [(0, 1), (1, 0), (-1, 0), (0, -1)]:
for i in range(1, k + 1):
nx, ny = x + i * dx, y + i * dy
if not 0 <= nx < n or not 0 <= ny < m or t[nx][ny] != "." or d[nx][ny] <= d[x][y]:
break
else:
if d[nx][ny] > d[x][y] + 1:
d[nx][ny] = d[x][y] + 1
que.append((nx, ny))
return d[gx][gy]
ans = bfs()
if ans == INF:
print(-1)
else:
print(ans)
``` |
900_E. Maximum Questions | Vasya wrote down two strings s of length n and t of length m consisting of small English letters 'a' and 'b'. What is more, he knows that string t has a form "abab...", namely there are letters 'a' on odd positions and letters 'b' on even positions.
Suddenly in the morning, Vasya found that somebody spoiled his string. Some letters of the string s were replaced by character '?'.
Let's call a sequence of positions i, i + 1, ..., i + m - 1 as occurrence of string t in s, if 1 ≤ i ≤ n - m + 1 and t1 = si, t2 = si + 1, ..., tm = si + m - 1.
The boy defines the beauty of the string s as maximum number of disjoint occurrences of string t in s. Vasya can replace some letters '?' with 'a' or 'b' (letters on different positions can be replaced with different letter). Vasya wants to make some replacements in such a way that beauty of string s is maximum possible. From all such options, he wants to choose one with the minimum number of replacements. Find the number of replacements he should make.
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the length of s.
The second line contains the string s of length n. It contains small English letters 'a', 'b' and characters '?' only.
The third line contains a single integer m (1 ≤ m ≤ 105) — the length of t. The string t contains letters 'a' on odd positions and 'b' on even positions.
Output
Print the only integer — the minimum number of replacements Vasya has to perform to make the beauty of string s the maximum possible.
Examples
Input
5
bb?a?
1
Output
2
Input
9
ab??ab???
3
Output
2
Note
In the first sample string t has a form 'a'. The only optimal option is to replace all characters '?' by 'a'.
In the second sample using two replacements we can make string equal to "aba?aba??". It is impossible to get more than two occurrences. | ```python
n = int(input()); s = input(); m = int(input())
a = [0]*(n+2); b = [0]*(n+2); q = [0]*(n+1);
dp = [(0, 0)]*(n+2)
for i in range(0, n):
b[i] = b[i-2]+(s[i] == 'b')
a[i] = a[i-2]+(s[i] == 'a')
q[i] = q[i-1]+(s[i] == '?')
for i in range(n-m, -1, -1):
dp[i] = dp[i+1]
i_b = 1 if m%2 == 1 else 2
i_a = 1 if m%2 == 0 else 2
if not (b[i+m-i_b]-b[i-2] or a[i+m-i_a]-a[i-1]):
t, r = dp[i+m]
dp[i] = min((t-1, r+q[i+m-1]-q[i-1]), dp[i])
print(dp[0][1])
``` |
923_C. Perfect Security | Alice has a very important message M consisting of some non-negative integers that she wants to keep secret from Eve. Alice knows that the only theoretically secure cipher is one-time pad. Alice generates a random key K of the length equal to the message's length. Alice computes the bitwise xor of each element of the message and the key (<image>, where <image> denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR)) and stores this encrypted message A. Alice is smart. Be like Alice.
For example, Alice may have wanted to store a message M = (0, 15, 9, 18). She generated a key K = (16, 7, 6, 3). The encrypted message is thus A = (16, 8, 15, 17).
Alice realised that she cannot store the key with the encrypted message. Alice sent her key K to Bob and deleted her own copy. Alice is smart. Really, be like Alice.
Bob realised that the encrypted message is only secure as long as the key is secret. Bob thus randomly permuted the key before storing it. Bob thinks that this way, even if Eve gets both the encrypted message and the key, she will not be able to read the message. Bob is not smart. Don't be like Bob.
In the above example, Bob may have, for instance, selected a permutation (3, 4, 1, 2) and stored the permuted key P = (6, 3, 16, 7).
One year has passed and Alice wants to decrypt her message. Only now Bob has realised that this is impossible. As he has permuted the key randomly, the message is lost forever. Did we mention that Bob isn't smart?
Bob wants to salvage at least some information from the message. Since he is not so smart, he asks for your help. You know the encrypted message A and the permuted key P. What is the lexicographically smallest message that could have resulted in the given encrypted text?
More precisely, for given A and P, find the lexicographically smallest message O, for which there exists a permutation π such that <image> for every i.
Note that the sequence S is lexicographically smaller than the sequence T, if there is an index i such that Si < Ti and for all j < i the condition Sj = Tj holds.
Input
The first line contains a single integer N (1 ≤ N ≤ 300000), the length of the message.
The second line contains N integers A1, A2, ..., AN (0 ≤ Ai < 230) representing the encrypted message.
The third line contains N integers P1, P2, ..., PN (0 ≤ Pi < 230) representing the permuted encryption key.
Output
Output a single line with N integers, the lexicographically smallest possible message O. Note that all its elements should be non-negative.
Examples
Input
3
8 4 13
17 2 7
Output
10 3 28
Input
5
12 7 87 22 11
18 39 9 12 16
Output
0 14 69 6 44
Input
10
331415699 278745619 998190004 423175621 42983144 166555524 843586353 802130100 337889448 685310951
226011312 266003835 342809544 504667531 529814910 684873393 817026985 844010788 993949858 1031395667
Output
128965467 243912600 4281110 112029883 223689619 76924724 429589 119397893 613490433 362863284
Note
In the first case, the solution is (10, 3, 28), since <image>, <image> and <image>. Other possible permutations of key yield messages (25, 6, 10), (25, 3, 15), (10, 21, 10), (15, 21, 15) and (15, 6, 28), which are all lexicographically larger than the solution. | ```python
def add(x):
global tree
now = 0
tree[now][2] += 1
for i in range(29, -1, -1):
bit = (x>>i)&1
if tree[now][bit]==0:
tree[now][bit]=len(tree)
tree.append([0, 0, 0])
now = tree[now][bit]
tree[now][2] += 1
def find_min(x):
global tree
now = ans = 0
for i in range(29, -1, -1):
bit = (x>>i)&1
if tree[now][bit] and tree[tree[now][bit]][2]:
now = tree[now][bit]
else:
now = tree[now][bit^1]
ans |= (1<<i)
tree[now][2] -= 1
return ans
tree = [[0, 0, 0]]
n = int(input())
a = list(map(int, input().split()))
list(map(add, map(int, input().split())))
[print(x, end=' ') for x in list(map(find_min, a))]
``` |
979_A. Pizza, Pizza, Pizza!!! | Katie, Kuro and Shiro are best friends. They have known each other since kindergarten. That's why they often share everything with each other and work together on some very hard problems.
Today is Shiro's birthday. She really loves pizza so she wants to invite her friends to the pizza restaurant near her house to celebrate her birthday, including her best friends Katie and Kuro.
She has ordered a very big round pizza, in order to serve her many friends. Exactly n of Shiro's friends are here. That's why she has to divide the pizza into n + 1 slices (Shiro also needs to eat). She wants the slices to be exactly the same size and shape. If not, some of her friends will get mad and go home early, and the party will be over.
Shiro is now hungry. She wants to cut the pizza with minimum of straight cuts. A cut is a straight segment, it might have ends inside or outside the pizza. But she is too lazy to pick up the calculator.
As usual, she will ask Katie and Kuro for help. But they haven't come yet. Could you help Shiro with this problem?
Input
A single line contains one non-negative integer n (0 ≤ n ≤ 10^{18}) — the number of Shiro's friends. The circular pizza has to be sliced into n + 1 pieces.
Output
A single integer — the number of straight cuts Shiro needs.
Examples
Input
3
Output
2
Input
4
Output
5
Note
To cut the round pizza into quarters one has to make two cuts through the center with angle 90^{\circ} between them.
To cut the round pizza into five equal parts one has to make five cuts. | ```python
n = int(input()) + 1
if n == 1:
print(0)
exit()
if n % 2 == 0:
print(n //2)
else:
print(n)
``` |
999_B. Reversing Encryption | A string s of length n can be encrypted by the following algorithm:
* iterate over all divisors of n in decreasing order (i.e. from n to 1),
* for each divisor d, reverse the substring s[1 ... d] (i.e. the substring which starts at position 1 and ends at position d).
For example, the above algorithm applied to the string s="codeforces" leads to the following changes: "codeforces" → "secrofedoc" → "orcesfedoc" → "rocesfedoc" → "rocesfedoc" (obviously, the last reverse operation doesn't change the string because d=1).
You are given the encrypted string t. Your task is to decrypt this string, i.e., to find a string s such that the above algorithm results in string t. It can be proven that this string s always exists and is unique.
Input
The first line of input consists of a single integer n (1 ≤ n ≤ 100) — the length of the string t. The second line of input consists of the string t. The length of t is n, and it consists only of lowercase Latin letters.
Output
Print a string s such that the above algorithm results in t.
Examples
Input
10
rocesfedoc
Output
codeforces
Input
16
plmaetwoxesisiht
Output
thisisexampletwo
Input
1
z
Output
z
Note
The first example is described in the problem statement. | ```python
l = int(input())
s = list(input())
for i in range(2, l + 1):
if l % i > 0: continue
s[:i] = s[i - 1::-1]
print(''.join(s))
``` |
p02664 NOMURA Programming Competition 2020 - Postdocs | For a string S consisting of the uppercase English letters `P` and `D`, let the doctoral and postdoctoral quotient of S be the total number of occurrences of `D` and `PD` in S as contiguous substrings. For example, if S = `PPDDP`, it contains two occurrences of `D` and one occurrence of `PD` as contiguous substrings, so the doctoral and postdoctoral quotient of S is 3.
We have a string T consisting of `P`, `D`, and `?`.
Among the strings that can be obtained by replacing each `?` in T with `P` or `D`, find one with the maximum possible doctoral and postdoctoral quotient.
Constraints
* 1 \leq |T| \leq 2 \times 10^5
* T consists of `P`, `D`, and `?`.
Input
Input is given from Standard Input in the following format:
T
Output
Print one string with the maximum possible doctoral and postdoctoral quotient among the strings that can be obtained by replacing each `?` in T with `P` or `D`. If there are multiple such strings, you may print any of them.
Examples
Input
PD?D??P
Output
PDPDPDP
Input
P?P?
Output
PDPD | ```python
# B - Postdocs
t = input()
print(t.replace('?', 'D'))
``` |
p02793 AtCoder Beginner Contest 152 - Flatten | Given are N positive integers A_1,...,A_N.
Consider positive integers B_1, ..., B_N that satisfy the following condition.
Condition: For any i, j such that 1 \leq i < j \leq N, A_i B_i = A_j B_j holds.
Find the minimum possible value of B_1 + ... + B_N for such B_1,...,B_N.
Since the answer can be enormous, print the sum modulo (10^9 +7).
Constraints
* 1 \leq N \leq 10^4
* 1 \leq A_i \leq 10^6
* 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 minimum possible value of B_1 + ... + B_N for B_1,...,B_N that satisfy the condition, modulo (10^9 +7).
Examples
Input
3
2 3 4
Output
13
Input
5
12 12 12 12 12
Output
5
Input
3
1000000 999999 999998
Output
996989508 | ```python
N = int(input())
A = [int(a) for a in input().split()]
import fractions
mod = 10**9+7
t = 1
for a in A:
t = a*t//fractions.gcd(a, t)
ans = 0
for a in A:
ans += t//a
print(ans%mod)
``` |
p02929 Japanese Student Championship 2019 Qualification - Cell Inversion | There are 2N squares arranged from left to right. You are given a string of length 2N representing the color of each of the squares.
The color of the i-th square from the left is black if the i-th character of S is `B`, and white if that character is `W`.
You will perform the following operation exactly N times: choose two distinct squares, then invert the colors of these squares and the squares between them. Here, to invert the color of a square is to make it white if it is black, and vice versa.
Throughout this process, you cannot choose the same square twice or more. That is, each square has to be chosen exactly once.
Find the number of ways to make all the squares white at the end of the process, modulo 10^9+7.
Two ways to make the squares white are considered different if and only if there exists i (1 \leq i \leq N) such that the pair of the squares chosen in the i-th operation is different.
Constraints
* 1 \leq N \leq 10^5
* |S| = 2N
* Each character of S is `B` or `W`.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the number of ways to make all the squares white at the end of the process, modulo 10^9+7. If there are no such ways, print 0.
Examples
Input
2
BWWB
Output
4
Input
4
BWBBWWWB
Output
288
Input
5
WWWWWWWWWW
Output
0 | ```python
from math import factorial
mod = 10 ** 9 + 7
n = int(input())
inp = list(input())
if inp[0] == 'W' or inp[-1] == 'W':
print(0)
exit(0)
arr = ['L']
swap_dict = {'L': 'R', 'R': 'L'}
for i in range(1, 2 * n):
arr.append(arr[i - 1] if inp[i] != inp[i - 1] else swap_dict[arr[i - 1]])
if arr.count('L') != arr.count('R'):
print(0)
exit(0)
cnt_tmp = 0
cnt_swap = 1
for a in arr:
if a == 'L':
cnt_tmp += 1
else:
cnt_swap = (cnt_swap * cnt_tmp) % mod
cnt_tmp -= 1
print(cnt_swap * factorial(n) % mod)
``` |
p03065 Tenka1 Programmer Contest 2019 - Polynomial Divisors | You are given a polynomial of degree N with integer coefficients: f(x)=a_Nx^N+a_{N-1}x^{N-1}+...+a_0. Find all prime numbers p that divide f(x) for every integer x.
Constraints
* 0 \leq N \leq 10^4
* |a_i| \leq 10^9(0\leq i\leq N)
* a_N \neq 0
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
a_N
:
a_0
Output
Print all prime numbers p that divide f(x) for every integer x, in ascending order.
Examples
Input
2
7
-7
14
Output
2
7
Input
3
1
4
1
5
Output
Input
0
998244353
Output
998244353 | ```python
def factors(z):
ret = []
for i in range(2, int(z**(1/2))+1):
if z%i == 0:
ret.append(i)
while z%i == 0:
z //= i
if z != 1:
ret.append(z)
return ret
def eratosthenes(N):
if N == 0:
return []
from collections import deque
work = [True] * (N+1)
work[0] = False
work[1] = False
ret = []
for i in range(N+1):
if work[i]:
ret.append(i)
for j in range(2* i, N+1, i):
work[j] = False
return ret
N = int( input())
A = [ int( input()) for _ in range(N+1)]
Primes = eratosthenes(N)
ANS = []
F = factors( abs(A[0]))
for f in F:
if f >= N+1:
Primes.append(f)
for p in Primes:
if p >= N+1:
check = 1
for i in range(N+1): # f が恒等的に 0 であるかどうかのチェック
if A[i]%p != 0:
check = 0
break
if check == 1:
ANS.append(p)
else:
poly = [0]*(p-1)
for i in range(N+1): # フェルマーの小定理
poly[(N-i)%(p-1)] = (poly[(N-i)%(p-1)] + A[i])%p
check = 0
if sum(poly) == 0 and A[N]%p == 0: # a_0 が 0 かつ、g が恒等的に 0 であることをチェックしている
check = 1
if check == 1:
ANS.append(p)
for ans in ANS:
print(ans)
``` |
p03208 AtCoder Beginner Contest 115 - Christmas Eve | In some other world, today is Christmas Eve.
There are N trees planted in Mr. Takaha's garden. The height of the i-th tree (1 \leq i \leq N) is h_i meters.
He decides to choose K trees from these trees and decorate them with electric lights. To make the scenery more beautiful, the heights of the decorated trees should be as close to each other as possible.
More specifically, let the height of the tallest decorated tree be h_{max} meters, and the height of the shortest decorated tree be h_{min} meters. The smaller the value h_{max} - h_{min} is, the better. What is the minimum possible value of h_{max} - h_{min}?
Constraints
* 2 \leq K < N \leq 10^5
* 1 \leq h_i \leq 10^9
* h_i is an integer.
Input
Input is given from Standard Input in the following format:
N K
h_1
h_2
:
h_N
Output
Print the minimum possible value of h_{max} - h_{min}.
Examples
Input
5 3
10
15
11
14
12
Output
2
Input
5 3
5
7
5
7
7
Output
0 | ```python
N, K = map(int, input().split())
H = [int(input()) for n in range(N)]
H.sort()
R = [H[i+K-1] - H[i] for i in range(N+1-K)]
print(min(R))
``` |
p03357 AtCoder Regular Contest 097 - Sorted and Sorted | There are 2N balls, N white and N black, arranged in a row. The integers from 1 through N are written on the white balls, one on each ball, and they are also written on the black balls, one on each ball. The integer written on the i-th ball from the left (1 ≤ i ≤ 2N) is a_i, and the color of this ball is represented by a letter c_i. c_i = `W` represents the ball is white; c_i = `B` represents the ball is black.
Takahashi the human wants to achieve the following objective:
* For every pair of integers (i,j) such that 1 ≤ i < j ≤ N, the white ball with i written on it is to the left of the white ball with j written on it.
* For every pair of integers (i,j) such that 1 ≤ i < j ≤ N, the black ball with i written on it is to the left of the black ball with j written on it.
In order to achieve this, he can perform the following operation:
* Swap two adjacent balls.
Find the minimum number of operations required to achieve the objective.
Constraints
* 1 ≤ N ≤ 2000
* 1 ≤ a_i ≤ N
* c_i = `W` or c_i = `B`.
* If i ≠ j, (a_i,c_i) ≠ (a_j,c_j).
Input
Input is given from Standard Input in the following format:
N
c_1 a_1
c_2 a_2
:
c_{2N} a_{2N}
Output
Print the minimum number of operations required to achieve the objective.
Examples
Input
3
B 1
W 2
B 3
W 1
W 3
B 2
Output
4
Input
4
B 4
W 4
B 3
W 3
B 2
W 2
B 1
W 1
Output
18
Input
9
W 3
B 1
B 4
W 1
B 5
W 9
W 2
B 6
W 5
B 3
W 8
B 9
W 7
B 2
B 8
W 4
W 6
B 7
Output
41 | ```python
import sys
input = sys.stdin.readline
n = int(input())
INF = 10 ** 9
info = [list(input().split()) for i in range(2 * n)]
ind = {}
for i in range(2 * n):
if info[i][0] == "B":
info[i] = (0, int(info[i][1]))
else:
info[i] = (1, int(info[i][1]))
ind[info[i][0] * 10 ** 5 + info[i][1]] = i
ru_b = [[0] * (2 * n + 1) for i in range(n + 1)]
ru_w = [[0] * (2 * n + 1) for i in range(n + 1)]
for i in range(n + 1):
for j in range(2 * n):
col, num = info[j]
if col == 0 and num > i:
ru_b[i][j + 1] += 1
elif col == 1 and num > i:
ru_w[i][j + 1] += 1
for j in range(2 * n):
ru_b[i][j + 1] += ru_b[i][j]
ru_w[i][j + 1] += ru_w[i][j]
dp = [[INF] * (n + 1) for i in range(n + 1)]
dp[0][0] = 0
for i in range(n + 1):
for j in range(n + 1):
if i + 1 <= n and j <= n:
bi = ind[i + 1]
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + ru_b[i][bi] + ru_w[j][bi])
if i <= n and j + 1 <= n:
wi = ind[10 ** 5 + j + 1]
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + ru_w[j][wi] + ru_b[i][wi])
print(dp[-1][-1])
``` |
p03515 CODE FESTIVAL 2017 Elimination Tournament Round 3 (Parallel) - Black Cats Deployment | Snuke Festival 2017 will be held in a tree with N vertices numbered 1,2, ...,N. The i-th edge connects Vertex a_i and b_i, and has joyfulness c_i.
The staff is Snuke and N-1 black cats. Snuke will set up the headquarters in some vertex, and from there he will deploy a cat to each of the other N-1 vertices.
For each vertex, calculate the niceness when the headquarters are set up in that vertex. The niceness when the headquarters are set up in Vertex i is calculated as follows:
* Let X=0.
* For each integer j between 1 and N (inclusive) except i, do the following:
* Add c to X, where c is the smallest joyfulness of an edge on the path from Vertex i to Vertex j.
* The niceness is the final value of X.
Constraints
* 1 \leq N \leq 10^{5}
* 1 \leq a_i,b_i \leq N
* 1 \leq c_i \leq 10^{9}
* The given graph is a tree.
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1 c_1
:
a_{N-1} b_{N-1} c_{N-1}
Output
Print N lines. The i-th line must contain the niceness when the headquarters are set up in Vertex i.
Examples
Input
3
1 2 10
2 3 20
Output
20
30
30
Input
15
6 3 2
13 3 1
1 13 2
7 1 2
8 1 1
2 8 2
2 12 2
5 2 2
2 11 2
10 2 2
10 9 1
9 14 2
4 14 1
11 15 2
Output
16
20
15
14
20
15
16
20
15
20
20
20
16
15
20
Input
19
19 14 48
11 19 23
17 14 30
7 11 15
2 19 15
2 18 21
19 10 43
12 11 25
3 11 4
5 19 50
4 11 19
9 12 29
14 13 3
14 6 12
14 15 14
5 1 6
8 18 13
7 16 14
Output
103
237
71
263
370
193
231
207
299
358
295
299
54
368
220
220
319
237
370 | ```python
import sys
from operator import itemgetter
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, N):
self.root = list(range(N + 1))
def __getitem__(self, x):
root = self.root
while root[x] != x:
root[x] = root[root[x]]
x = root[x]
return x
def merge(self, x, y):
x = self[x]
y = self[y]
if x == y:
return
# 番号の大きい頂点を根にする
if x < y:
x, y = y, x
self.root[y] = x
N = int(readline())
m = map(int, read().split())
ABC = sorted(zip(m, m, m), key=itemgetter(2), reverse=True)
uf = UnionFind(N + N)
parent = [0] * (N + N)
value = [0] * (N + N)
for n, (a, b, c) in enumerate(ABC, N + 1):
ra = uf[a]
rb = uf[b]
parent[ra] = n
parent[rb] = n
value[n] = c
uf.merge(ra, n)
uf.merge(rb, n)
size = [0] + [1] * N + [0] * (N - 1)
for n in range(N + N):
p = parent[n]
size[p] += size[n]
for n in range(N + N):
p = parent[n]
value[n] = 0
if not p:
continue
value[n] = value[p] * (size[p] - size[n])
for n in range(N + N - 2, 0, -1):
p = parent[n]
value[n] += value[p]
print('\n'.join(map(str, value[1:N + 1])))
``` |
p03833 AtCoder Regular Contest 067 - Yakiniku Restaurants | There are N barbecue restaurants along a street. The restaurants are numbered 1 through N from west to east, and the distance between restaurant i and restaurant i+1 is A_i.
Joisino has M tickets, numbered 1 through M. Every barbecue restaurant offers barbecue meals in exchange for these tickets. Restaurant i offers a meal of deliciousness B_{i,j} in exchange for ticket j. Each ticket can only be used once, but any number of tickets can be used at a restaurant.
Joisino wants to have M barbecue meals by starting from a restaurant of her choice, then repeatedly traveling to another barbecue restaurant and using unused tickets at the restaurant at her current location. Her eventual happiness is calculated by the following formula: "(The total deliciousness of the meals eaten) - (The total distance traveled)". Find her maximum possible eventual happiness.
Constraints
* All input values are integers.
* 2≤N≤5×10^3
* 1≤M≤200
* 1≤A_i≤10^9
* 1≤B_{i,j}≤10^9
Input
The input is given from Standard Input in the following format:
N M
A_1 A_2 ... A_{N-1}
B_{1,1} B_{1,2} ... B_{1,M}
B_{2,1} B_{2,2} ... B_{2,M}
:
B_{N,1} B_{N,2} ... B_{N,M}
Output
Print Joisino's maximum possible eventual happiness.
Examples
Input
3 4
1 4
2 2 5 1
1 3 3 2
2 2 5 1
Output
11
Input
5 3
1 2 3 4
10 1 1
1 1 1
1 10 1
1 1 1
1 1 10
Output
20 | ```python
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import itertools
INF=10**10
N,M = map(int,readline().split())
A = [0,0]+list(map(int,readline().split()))
B = [[INF]*M]+[list(map(int,line.split())) for line in readlines()]
for i in range(1,N+1):
A[i] += A[i-1]
answer = 0
INF = 10**12
diff = [INF]+[0]*N
left = [list(range(-1,N)) for m in range(M)]
arr = [INF,2,1,2]
for i in range(1,N+1):
for m in range(M):
p=i; prev_val=0
q=left[m][p]
x = B[i][m]
while prev_val<=x:
diff[p] += x-prev_val
diff[q] -= x-prev_val
p=q; q=left[m][p]
prev_val=B[p][m]
left[m][i]=p
# 出発地点ごとの収入
ticket_sum = list(itertools.accumulate(diff[::-1]))[::-1]
for start in range(1,i+1):
happy = ticket_sum[start] + A[start]-A[i]
if answer < happy:
answer = happy
print(answer)
``` |
p03998 AtCoder Beginner Contest 045 - Card Game for Three (ABC Edit) | Alice, Bob and Charlie are playing Card Game for Three, as below:
* At first, each of the three players has a deck consisting of some number of cards. Each card has a letter `a`, `b` or `c` written on it. The orders of the cards in the decks cannot be rearranged.
* The players take turns. Alice goes first.
* If the current player's deck contains at least one card, discard the top card in the deck. Then, the player whose name begins with the letter on the discarded card, takes the next turn. (For example, if the card says `a`, Alice takes the next turn.)
* If the current player's deck is empty, the game ends and the current player wins the game.
You are given the initial decks of the players. More specifically, you are given three strings S_A, S_B and S_C. The i-th (1≦i≦|S_A|) letter in S_A is the letter on the i-th card in Alice's initial deck. S_B and S_C describes Bob's and Charlie's initial decks in the same way.
Determine the winner of the game.
Constraints
* 1≦|S_A|≦100
* 1≦|S_B|≦100
* 1≦|S_C|≦100
* Each letter in S_A, S_B, S_C is `a`, `b` or `c`.
Input
The input is given from Standard Input in the following format:
S_A
S_B
S_C
Output
If Alice will win, print `A`. If Bob will win, print `B`. If Charlie will win, print `C`.
Examples
Input
aca
accc
ca
Output
A
Input
abcb
aacb
bccc
Output
C | ```python
hands = {char:list(input()) for char in 'abc'}
next_hand = 'a'
while hands[next_hand]:
next_hand = hands[next_hand].pop(0)
print(next_hand.upper())
``` |
p00086 Patrol | In 1862, the lord of Aizu was ordered to serve as a guardian of Kyoto. The Kyoto Shugoshoku is an important role to protect Kyoto at the end of the Edo period when security has deteriorated. You have to patrol the city by sharing it with the shogunate and other clan. However, when it came time to decide the sharing route, the following order was received from a stubborn old man who is famous among his vassals.
<image>
It was a big deal. Even the lord cannot ignore the statement of this vassal. Depending on the selection of the sharing route, it will be "the samurai's face is not noticeable".
So, please make a program to judge whether the above three conditions are met by inputting the information of the start point, the goal point, and the intersection, and give it to the lord.
The start point is represented by 1, the goal point is represented by 2, and other intersections are represented by integers of 3 or more. A road is represented by a set of intersection numbers that the roads connect to. The number of intersections shall be 100 or less, and there shall be one or more routes from all intersections to the start point and goal point.
input
Given multiple datasets. Each dataset is given in the following format:
a1 b1
a2 b2
:
:
0 0
The two integers in each row indicate that there is a road connecting intersection ai and intersection bi. When both ai and bi are 0, it indicates the end of inputting intersection information.
The number of datasets does not exceed 50.
output
For each data set, if the samurai's face stands out (if the three conditions are met), OK, otherwise (if the three conditions are not met), output NG on one line.
Example
Input
1 3
3 4
3 5
3 6
4 6
4 7
4 7
5 6
6 7
5 8
5 8
6 8
6 9
7 9
8 9
9 2
0 0
1 3
3 4
3 4
4 2
0 0
Output
OK
NG | ```python
import sys
def is_half_euler_graph(node_list):
for node in node_list:
isBool = True
for dic_key, dic_value in node.items():
if dic_key != 1 and dic_key != 2:
if dic_value % 2 != 0:
isBool = False
break
else :
if dic_value % 2 == 0:
isBool = False
break
if isBool :
print("OK")
else :
print("NG")
if __name__ == '__main__' :
from collections import defaultdict
data_list = []
for line in sys.stdin:
data_list.append(list(map(int, line.split())))
node_data_lists = []
tmp_list = []
count_lists = []
tmp_dic = {}
tmp_dic = defaultdict(int)
for i in range(0, len(data_list)):
if data_list[i][0] == 0 and data_list[i][1] == 0:
node_data_lists.append(tmp_list[:])
tmp_list.clear()
else :
tmp_list.append(data_list[i])
for node_data_list in node_data_lists :
tmp_dic.clear()
for i in range(0, len(node_data_list)):
tmp_dic[node_data_list[i][0]] += 1
tmp_dic[node_data_list[i][1]] += 1
count_lists.append(tmp_dic.copy())
is_half_euler_graph(count_lists)
``` |
p00218 Dividing Students | At Aizu Shingakujuku, students are divided into classes by conducting a proficiency test when they enter the cram school. The test consists of three subjects: Mathematics, English, and Japanese, and students are divided into A, B, and C classes. The level of class A is the highest and then decreases in order.
The classification decision is based on the table below.
Condition | Class
--- | ---
There are 100 subjects | A
Average score of math and English is 90 points or more | A
Average score of 3 subjects is 80 points or more | A
Average score of 3 subjects is 70 points or more | B
Average score of 3 subjects is 50 points or more and math or English is 80 points or more | B
Does not meet the above conditions | C
If you meet multiple conditions, you will be divided into higher level classes.
Number of students n (1 ≤ n ≤ 10000), math score pmi (0 ≤ pmi ≤ 100) for each student, English score pei (0 ≤ pei ≤ 100), national language score pji (0 ≤ pji ≤ 100) Create a program that outputs classes A, B, and C (half-width alphabetic characters) for each student.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by a single line of zeros. Each dataset is given in the following format:
n
pm1 pe1 pj1
pm2 pe2 pj2
::
pmn pen pjn
All inputs are given as integers. The number of datasets does not exceed 1000.
Output
Outputs each student's class in turn for each input dataset.
Example
Input
4
100 70 20
98 86 55
80 34 36
65 79 65
2
99 81 20
66 72 90
0
Output
A
A
B
C
A
B | ```python
while True:
#繰り返し回数を入力し0であった場合はbreakする
num = int(input())
if num == 0:
break
else:
for _ in range(num):
a,b,c = map(int,input().split())
#100 点の科目があるまたは数学と英語の平均点が 90 点以上または3 科目の平均点が 80 点以上の場合"A"を出力する
if a == 100 or b == 100 or c == 100 or (a + b) / 2 >= 90 or (a + b + c) / 3 >= 80:print("A")
#3 科目の平均点が 70 点以上または3 科目の平均点が 50 点以上で数学か英語が 80 点以上の場合"B"を出力する
elif (a + b + c) / 3 >= 70 or (a + b + c) / 3 >= 50 and a >= 80 or (a + b + c) / 3 >= 50 and b >= 80:print("B")
#上記のどれにも当てはまらない場合、"C"を出力する
else:print("C")
``` |
p00378 Heat Strokes | We have had record hot temperatures this summer. To avoid heat stroke, you decided to buy a quantity of drinking water at the nearby supermarket. Two types of bottled water, 1 and 0.5 liter, are on sale at respective prices there. You have a definite quantity in your mind, but are willing to buy a quantity larger than that if: no combination of these bottles meets the quantity, or, the total price becomes lower.
Given the prices for each bottle of water and the total quantity needed, make a program to seek the lowest price to buy greater than or equal to the quantity required.
Input
The input is given in the following format.
$A$ $B$ $X$
The first line provides the prices for a 1-liter bottle $A$ ($1\leq A \leq 1000$), 500-milliliter bottle $B$ ($1 \leq B \leq 1000$), and the total water quantity needed $X$ ($1 \leq X \leq 20000$). All these values are given as integers, and the quantity of water in milliliters.
Output
Output the total price.
Examples
Input
180 100 2400
Output
460
Input
200 90 2018
Output
450 | ```python
a, b, x = map(int, input().split())
if b * 2 <= a:
ans = b * (x // 500 + bool(x % 500))
else:
ans = a * (x // 1000) + min(b * ((x % 1000) // 500 + bool((x % 1000) % 500)), a * bool(x % 1000))
print(ans)
``` |
p00596 Dominoes Arrangement | [0, 0]
[0, 1] [1, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3] [3, 3]
[0, 4] [1, 4] [2, 4] [3, 4] [4, 4]
[0, 5] [1, 5] [2, 5] [3, 5] [4, 5] [5, 5]
[0, 6] [1, 6] [2, 6] [3, 6] [4, 6] [5, 6] [6, 6]
Consider the standard set of 28 western dominoes as shown in the above figure. Given a subset of the standard set dominoes, decide whether this subset can be arranged in a straight row in accordance with the familiar playing rule that touching ends must match. For example, the subset [1, 1], [2, 2], [1, 2] can be arranged in a row (as [1, 1] followed by [1, 2] followed by [2, 2]), while the subset [1, 1], [0, 3], [1, 4] can not be arranged in one row. Note that as in usual dominoes playing any pair [i, j] can also be treated as [j, i].
Your task is to write a program that takes as input any subset of the dominoes and output either yes (if the input subset can be arranged in one row) or no (if the input set can not be arranged in one row).
Input
Input file consists of pairs of lines. The first line of each pair is the number of elements N (1 ≤ N ≤ 18) in the subset, and the second line is the elements of the subset separated by blanks, see the input sample below.
The number of pairs (datasets) is less than 30.
Output
For each pair of lines of the input file, the corresponding output is either Yes or No, based on whether the input subset can be arranged in one line or not.
Example
Input
6
13 23 14 24 15 25
10
00 01 11 02 12 22 03 13 23 33
Output
Yes
No | ```python
import sys
def subset(line):
l = line.strip().split(" ")
a = list(map(int, l))
xy = list(map(lambda x: [x // 10, x % 10], a))
dominos = [[2 if [x, y] in xy and x == y else \
1 if [x, y] in xy else \
1 if [y, x] in xy else 0 \
for x in range(0, 7)] for y in range(0, 7)]
digits = []
for i in xy:
digits.extend(i)
digits = list(set(digits))
digits.sort()
return digits, dominos
def add_matrix(a, b):
c = [[a[j][i] + b[j][i] for i in range(0, 7)] for j in range(0, 7)]
return c
def mul_matrix(a, b):
c = [[0 for i in range(0, 7)] for j in range(0, 7)]
for j in range(0, 7):
for i in range(0, 7):
for k in range(0, 7):
c[j][i] += a[j][k] * b[k][i]
return c
def is_connected(d, g):
a = g[:]
z = [[0 for i in range(0, 7)] for j in range(0, 7)]
b = a
for i in range(0, 7):
z = add_matrix(z, b)
b = mul_matrix(b, a)
zeros = 0
for i in d:
if z[d[0]][i] == 0:
zeros += 1
return zeros == 0
lno = 0
for line in sys.stdin:
lno += 1
if lno == 1:
n = int(line)
else:
digits, dominos = subset(line)
if not is_connected(digits, dominos):
print("No")
else:
order = [sum(dominos[i]) for i in range(0, 7)]
odd = 0
for i in digits:
if order[i] % 2 != 0:
odd += 1
if odd <= 2:
print("Yes")
else:
print("No")
lno = 0
``` |
p01135 Poor Mail Forwarding | The postal system in the area where Masa lives has changed a bit. In this area, each post office is numbered consecutively from 1 to a different number, and mail delivered to a post office is intended from that post office via several post offices. Delivered to the post office. Mail "forwarding" is only done between specific post offices. However, the transfer is bidirectional between the post offices where the transfer is performed.
If there are multiple routes for forwarding mail from a post office to the destination, use the route that minimizes the distance to the destination. Therefore, the forwarding destination will be the next post office on such a shortest path. If there are multiple routes with the shortest total distance, the postal office number that is the direct transfer destination is transferred to the younger one.
<image> <image>
By the way, the region is suffering from a serious labor shortage, and each post office has only one transfer person to transfer between post offices. They are doing their best to go back and forth. Of course, if the forwarding agent belonging to a post office has paid the mail when the mail arrives at that post office, the forwarding from that post office will be temporarily stopped.
When they are at their post office, they depart immediately if there is mail that has not been forwarded from that post office, and return immediately after delivering it to the forwarding destination. When he returns from the destination post office, he will not carry the mail that will be forwarded to his post office, even if it is at that post office (the mail will be forwarded to that mail). It is the job of the post office transferman).
If multiple mail items are collected at the time of forwarding, the mail that was delivered to the post office earliest is transferred first. Here, if there are multiple mail items that arrived at the same time, the mail is forwarded from the one with the youngest post office number that is the direct forwarding destination. If there is mail that has the same forwarding destination, it will also be forwarded together. Also, if the mail that should be forwarded to the same post office arrives at the same time as the forwarding agent's departure time, it will also be forwarded. It should be noted that they all take 1 time to travel a distance of 1.
You will be given information about the transfer between post offices and a list of the times when the mail arrived at each post office. At this time, simulate the movement of the mail and report the time when each mail arrived at the destination post office. It can be assumed that all the times required during the simulation of the problem are in the range 0 or more and less than 231.
Input
The input consists of multiple datasets, and the end of the input is represented by a single line with only 0 0. The format of each dataset is as follows.
The first line of the dataset is given the integers n (2 <= n <= 32) and m (1 <= m <= 496), separated by a single character space. n represents the total number of post offices and m represents the number of direct forwarding routes between post offices. There can never be more than one direct forwarding route between two post offices.
On the next m line, three integers containing information on the direct transfer route between stations are written. The first and second are the postal numbers (1 or more and n or less) at both ends of the transfer route, and the last integer represents the distance between the two stations. The distance is greater than or equal to 1 and less than 10000.
The next line contains the integer l (1 <= l <= 1000), which represents the number of mail items to process, followed by the l line, which contains the details of each piece of mail. Three integers are written at the beginning of each line. These are, in order, the sender's postal office number, the destination postal office number, and the time of arrival at the sender's postal office. At the end of the line, a string representing the label of the mail is written. This label must be between 1 and 50 characters in length and consists only of letters, numbers, hyphens ('-'), and underscores ('_'). Information on each of these mail items is written in chronological order of arrival at the post office of the sender. At the same time, the order is not specified. In addition, there is no mail with the same label, mail with the same origin and destination, or mail without a delivery route.
Each number or string in the input line is separated by a single character space.
Output
Output l lines for each dataset. Each output follows the format below.
For each mail, the time when the mail arrived is output on one line. On that line, first print the label of the mail, then with a one-character space, and finally print the time when the mail arrived at the destination post office. These are output in order of arrival time. If there are multiple mails arriving at the same time, the ASCII code of the label is output in ascending order.
A blank line is inserted between the outputs corresponding to each dataset.
Example
Input
4 5
1 2 10
1 3 15
2 3 5
2 4 3
3 4 10
2
1 4 10 LoveLetter
2 3 20 Greetings
3 3
1 2 1
2 3 1
3 1 1
3
1 2 1 BusinessMailC
2 3 1 BusinessMailB
3 1 1 BusinessMailA
0 0
Output
Greetings 25
LoveLetter 33
BusinessMailA 2
BusinessMailB 2
BusinessMailC 2 | ```python
def solve():
from sys import stdin
f_i = stdin
ans = ''
while True:
n, m = map(int, f_i.readline().split())
if n == 0:
break
# prep for warshall-floyd algorithm
inf = 10000 * 31 + 1
dist = [[inf] * n for i in range(n)]
for i in range(n):
dist[i][i] = 0
for i in range(m):
s, t, d = map(int, f_i.readline().split())
s -= 1
t -= 1
dist[s][t] = d
dist[t][s] = d
# table for path reconstruction
next_p = [list(range(n)) for i in range(n)]
# Warshall-Floyd algorithm
for k in range(n):
for i in range(n):
for j in range(n):
d_ikj = dist[i][k] + dist[k][j]
d_ij = dist[i][j]
if d_ikj < d_ij:
dist[i][j] = d_ikj
next_p[i][j] = next_p[i][k]
# for restore the smallest path in lexicographic order
elif k != i and d_ikj == d_ij:
if next_p[i][k] < next_p[i][j]:
next_p[i][j] = next_p[i][k]
l = int(f_i.readline())
paths = []
mails = set()
messages = []
goals = []
for i in range(l):
start, goal, at, msg = f_i.readline().split()
start = int(start) - 1
goal = int(goal) - 1
at = int(at)
messages.append(msg)
goals.append(goal)
# path reconstruction
path = []
cur = start
while cur != goal:
path.append(cur)
cur = next_p[cur][goal]
path.append(goal)
paths.append(path)
# mail: (time, arrivalTime, next, cur, number)
mails.add((at, at, path[1], start, i))
step = [1] * l
deliv_time = [0] * n
# mail forwarding
tmp_ans = []
while mails:
t, at, nxt, cur, num = min(mails)
to_forward = set(filter(lambda x: x[0] == t and x[2] == nxt and x[3] == cur, mails))
mails = mails.difference(to_forward)
dt = deliv_time[cur]
# transferable
if t >= dt:
cost = dist[cur][nxt]
new_t = t + cost
for t, at, nxt, cur, num in to_forward:
if nxt == goals[num]:
tmp_ans.append((new_t, messages[num]))
else:
step[num] += 1
new_nxt = paths[num][step[num]]
mails.add((new_t, new_t, new_nxt, nxt, num))
deliv_time[cur] = t + cost * 2
# non-transferable
else:
for t, at, nxt, cur, num in to_forward:
mails.add((dt, at, nxt, cur, num))
tmp_ans.sort()
tmp_ans = (f"{label} {time}" for time, label in tmp_ans)
ans += '\n'.join(tmp_ans) + '\n\n'
print(ans.rstrip())
solve()
``` |
p01593 Earn Big | Problem C: Earn Big
A group of N people is trying to challenge the following game to earn big money.
First, N participants are isolated from each other. From this point, they are not allowed to contact each other, or to leave any information for other participants. The game organizer leads each participant, one by one, to a room with N boxes. The boxes are all closed at the beginning of the game, and the game organizer closes all the boxes whenever a participant enters the room. Each box contains a slip of paper on which a name of a distinct participant is written. The order of the boxes do not change during the game. Each participant is allowed to open up to M boxes. If every participant is able to open a box that contains a paper of his/her name, then the group wins the game, and everybody in the group earns big money. If anyone is failed to open a box that contains a paper of his/her name, then the group fails in the game, and nobody in the group gets money.
Obviously, if every participant picks up boxes randomly, the winning probability will be (M/N)N. However, there is a far more better solution.
Before discussing the solution, let us define some concepts. Let P = {p1, p2, ..., pN} be a set of the participants, and B = {b1, b2, ..., bN} be a set of the boxes. Let us define f, a mapping from B to P, such that f(b) is a participant whose name is written on a paper in a box b.
Here, consider a participant pi picks up the boxes in the following manner:
1. Let x := i.
2. If pi has already opened M boxes, then exit as a failure.
3. pi opens bx.
1. If f(bx) = pi, then exit as a success.
2. If f(bx) = pj (i != j), then let x := j, and go to 2.
Assuming every participant follows the algorithm above, the result of the game depends only on the initial order of the boxes (i.e. the definition of f). Let us define g to be a mapping from P to B, such that g(pi) = bi. The participants win the game if and only if, for every i ∈ {1, 2, ..., N}, there exists k(<=M) such that (f<image>g)k (pi) = pi.
Your task is to write a program that calculates the winning probability of this game. You can assume that the boxes are placed randomly.
Input
The input consists of one line. It contains two integers N and M (1 <= M <= N <= 1,000) in this order, delimited by a space.
Output
For given N and M, your program should print the winning probability of the game. The output value should be in a decimal fraction and should not contain an error greater than 10-8.
Examples
Input
2 1
Output
0.50000000
Input
100 50
Output
0.31182782 | ```python
dp=[1]+[0]*1000
n,m=map(int,input().split())
for i in range(n):
j=1
while i+j<=n and j<=m:dp[i+j]+=dp[i]/(n-i);j+=1
print('%.10f'%dp[n])
``` |
p01750 Hyperrectangle | Sunuke received a d-dimensional hypercube with a side length of l1 × ... × ld as a birthday present. Sunuke placed this rectangular parallelepiped so that the range of the i-th coordinate was 0 or more and li or less, and ate the part that satisfied x1 + ... + xd ≤ s. However, xi represents the i-th coordinate. If the volume of the part eaten by Sunuke is V, it can be proved that d! V (V multiplied by the factorial of d) is an integer. Find the remainder of d! V divided by 1,000,000,007.
Constraints
* 2 ≤ d ≤ 300
* 1 ≤ li ≤ 300
* 0 ≤ s ≤ $ \ sum l_ {i} $
* All inputs are integers
Input
d
l1
.. ..
ld
s
Output
Output d! V divided by 1,000,000,007.
Examples
Input
2
6
3
4
Output
15
Input
5
12
34
56
78
90
123
Output
433127538 | ```python
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
MOD = 10**9 + 7
D = int(readline())
L = [int(readline()) for i in range(D)]
S = int(readline())
dp = [0]*(S+1)
dp[S] = 1
for i in range(D):
l = L[i]
for i in range(l, S+1):
dp[i-l] -= dp[i]
ans = 0
for i in range(S+1):
ans += pow(i, D, MOD) * dp[i]
ans %= MOD
write("%d\n" % ans)
solve()
``` |
p02169 Count Words | Problem
There are $ M $ type characters. Use them to create a string of length $ N $. How many strings are used that have $ K $ or more? Find too much divided by $ 998244353 $.
Here, the difference between two strings of length $ N $ is defined as follows.
* If the two strings are $ S = S_1S_2 \ ldots S_N $, $ T = T_1T_2 \ ldots T_N $, then $ i $$ (1 \ leq i \ leq N) becomes $ S_i \ neq T_i $ ) $ Exists.
Constraints
The input satisfies the following conditions.
* $ 1 \ leq M \ leq 10 ^ {18} $
* $ 1 \ leq N \ leq 10 ^ {18} $
* $ 1 \ leq K \ leq 1000 $
* All inputs are integers
Input
The input is given in the following format.
$ M $ $ N $ $ K $
$ M, N, K $ are given on one line, separated by blanks.
Output
Output the remainder of the number of characters used in a string of length $ N $ that is greater than or equal to $ K $ divided by $ 998244353 $.
Examples
Input
2 10 1
Output
1024
Input
1 1 2
Output
0
Input
5 10 3
Output
9755400
Input
7 8 3
Output
5759460
Input
1000000000000000000 1000000000000000000 1000
Output
133611974 | ```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():
m,n,k = LI()
if n < k:
print(0)
return
if m < k:
print(0)
return
ans = pow(m,n,mod)
p = [pow(i,n,mod) for i in range(k+1)]
c = m
comb = [[0 for i in range(i+1)] for i in range(k+1)]
comb[0][0] = 1
for i in range(k):
for j in range(i+1):
comb[i+1][j] += comb[i][j]
comb[i+1][j+1] += comb[i][j]
for i in range(1,k):
k = 0
for j in range(1,i+1)[::-1]:
if (i+j)&1:
k -= comb[i][j]*p[j]
else:
k += comb[i][j]*p[j]
k *= c
c *= (m-i)
c *= pow(i+1,mod-2,mod)
c %= mod
ans -= k
ans %= mod
print(ans)
return
if __name__ == "__main__":
solve()
``` |
p02310 Tangent to a Circle | Find the tangent lines between a point $p$ and a circle $c$.
Constraints
* $-1,000 \leq px, py, cx, cy \leq 1,000$
* $1 \leq r \leq 1,000$
* Distance between $p$ and the center of $c$ is greater than the radius of $c$.
Input
The input is given in the following format.
$px \; py$
$cx \; cy \; r$
$px$ and $py$ represents the coordinate of the point $p$. $cx$, $cy$ and $r$ represents the center coordinate and radius of the circle $c$ respectively. All input values are given in integers.
Output
Print coordinates of the tangent points on the circle $c$ based on the following rules.
* Print the coordinate with smaller $x$ first. In case of a tie, print the coordinate with smaller $y$ first.
The output values should be in a decimal fraction with an error less than 0.00001.
Examples
Input
0 0
2 2 2
Output
0.0000000000 2.0000000000
2.0000000000 0.0000000000
Input
-3 0
2 2 2
Output
0.6206896552 3.4482758621
2.0000000000 0.0000000000 | ```python
import cmath
import itertools
import math
import os
import sys
from collections import defaultdict
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
PI = cmath.pi
TAU = cmath.pi * 2
EPS = 1e-10
class Point:
"""
2次元空間上の点
"""
# 反時計回り側にある
CCW_COUNTER_CLOCKWISE = 1
# 時計回り側にある
CCW_CLOCKWISE = -1
# 線分の後ろにある
CCW_ONLINE_BACK = 2
# 線分の前にある
CCW_ONLINE_FRONT = -2
# 線分上にある
CCW_ON_SEGMENT = 0
def __init__(self, c: complex):
self.c = c
@property
def x(self):
return self.c.real
@property
def y(self):
return self.c.imag
@staticmethod
def from_rect(x: float, y: float):
return Point(complex(x, y))
@staticmethod
def from_polar(r: float, phi: float):
return Point(cmath.rect(r, phi))
def __add__(self, p):
"""
:param Point p:
"""
return Point(self.c + p.c)
def __iadd__(self, p):
"""
:param Point p:
"""
self.c += p.c
return self
def __sub__(self, p):
"""
:param Point p:
"""
return Point(self.c - p.c)
def __isub__(self, p):
"""
:param Point p:
"""
self.c -= p.c
return self
def __mul__(self, f: float):
return Point(self.c * f)
def __imul__(self, f: float):
self.c *= f
return self
def __truediv__(self, f: float):
return Point(self.c / f)
def __itruediv__(self, f: float):
self.c /= f
return self
def __repr__(self):
return "({}, {})".format(round(self.x, 10), round(self.y, 10))
def __neg__(self):
return Point(-self.c)
def __eq__(self, p):
return abs(self.c - p.c) < EPS
def __abs__(self):
return abs(self.c)
@staticmethod
def ccw(a, b, c):
"""
線分 ab に対する c の位置
線分上にあるか判定するだけなら on_segment とかのが速い
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_C&lang=ja
:param Point a:
:param Point b:
:param Point c:
"""
b = b - a
c = c - a
det = b.det(c)
if det > EPS:
return Point.CCW_COUNTER_CLOCKWISE
if det < -EPS:
return Point.CCW_CLOCKWISE
if b.dot(c) < -EPS:
return Point.CCW_ONLINE_BACK
if c.norm() - b.norm() > EPS:
return Point.CCW_ONLINE_FRONT
return Point.CCW_ON_SEGMENT
def dot(self, p):
"""
内積
:param Point p:
:rtype: float
"""
return self.x * p.x + self.y * p.y
def det(self, p):
"""
外積
:param Point p:
:rtype: float
"""
return self.x * p.y - self.y * p.x
def dist(self, p):
"""
距離
:param Point p:
:rtype: float
"""
return abs(self.c - p.c)
def norm(self):
"""
原点からの距離
:rtype: float
"""
return abs(self.c)
def phase(self):
"""
原点からの角度
:rtype: float
"""
return cmath.phase(self.c)
def angle(self, p, q):
"""
p に向いてる状態から q まで反時計回りに回転するときの角度
-pi <= ret <= pi
:param Point p:
:param Point q:
:rtype: float
"""
return (cmath.phase(q.c - self.c) - cmath.phase(p.c - self.c) + PI) % TAU - PI
def area(self, p, q):
"""
p, q となす三角形の面積
:param Point p:
:param Point q:
:rtype: float
"""
return abs((p - self).det(q - self) / 2)
def projection_point(self, p, q, allow_outer=False):
"""
線分 pq を通る直線上に垂線をおろしたときの足の座標
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_A&lang=ja
:param Point p:
:param Point q:
:param allow_outer: 答えが線分の間になくても OK
:rtype: Point|None
"""
diff_q = q - p
# 答えの p からの距離
r = (self - p).dot(diff_q) / abs(diff_q)
# 線分の角度
phase = diff_q.phase()
ret = Point.from_polar(r, phase) + p
if allow_outer or (p - ret).dot(q - ret) < EPS:
return ret
return None
def reflection_point(self, p, q):
"""
直線 pq を挟んで反対にある点
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_B&lang=ja
:param Point p:
:param Point q:
:rtype: Point
"""
# 距離
r = abs(self - p)
# pq と p-self の角度
angle = p.angle(q, self)
# 直線を挟んで角度を反対にする
angle = (q - p).phase() - angle
return Point.from_polar(r, angle) + p
def on_segment(self, p, q, allow_side=True):
"""
点が線分 pq の上に乗っているか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_1_C&lang=ja
:param Point p:
:param Point q:
:param allow_side: 端っこでギリギリ触れているのを許容するか
:rtype: bool
"""
if not allow_side and (self == p or self == q):
return False
# 外積がゼロ: 面積がゼロ == 一直線
# 内積がマイナス: p - self - q の順に並んでる
return abs((p - self).det(q - self)) < EPS and (p - self).dot(q - self) < EPS
class Line:
"""
2次元空間上の直線
"""
def __init__(self, a: float, b: float, c: float):
"""
直線 ax + by + c = 0
"""
self.a = a
self.b = b
self.c = c
@staticmethod
def from_gradient(grad: float, intercept: float):
"""
直線 y = ax + b
:param grad: 傾き
:param intercept: 切片
:return:
"""
return Line(grad, -1, intercept)
@staticmethod
def from_segment(p1, p2):
"""
:param Point p1:
:param Point p2:
"""
a = p2.y - p1.y
b = p1.x - p2.x
c = p2.y * (p2.x - p1.x) - p2.x * (p2.y - p1.y)
return Line(a, b, c)
@property
def gradient(self):
"""
傾き
"""
return INF if self.b == 0 else -self.a / self.b
@property
def intercept(self):
"""
切片
"""
return INF if self.b == 0 else -self.c / self.b
def is_parallel_to(self, l):
"""
平行かどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A&lang=ja
:param Line l:
"""
# 法線ベクトル同士の外積がゼロ
return abs(Point.from_rect(self.a, self.b).det(Point.from_rect(l.a, l.b))) < EPS
def is_orthogonal_to(self, l):
"""
直行しているかどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A&lang=ja
:param Line l:
"""
# 法線ベクトル同士の内積がゼロ
return abs(Point.from_rect(self.a, self.b).dot(Point.from_rect(l.a, l.b))) < EPS
def intersection_point(self, l):
"""
交差する点
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_C&lang=ja
:param Line l:
:rtype: Point|None
"""
a1, b1, c1 = self.a, self.b, self.c
a2, b2, c2 = l.a, l.b, l.c
det = a1 * b2 - a2 * b1
if abs(det) < EPS:
# 並行
return None
x = (b1 * c2 - b2 * c1) / det
y = (a2 * c1 - a1 * c2) / det
return Point.from_rect(x, y)
def dist(self, p):
"""
他の点との最短距離
:param Point p:
"""
raise NotImplementedError()
def has_point(self, p):
"""
p が直線上に乗っているかどうか
:param Point p:
"""
return abs(self.a * p.x + self.b * p.y + self.c) < EPS
class Segment:
"""
2次元空間上の線分
"""
def __init__(self, p1, p2):
"""
:param Point p1:
:param Point p2:
"""
self.p1 = p1
self.p2 = p2
def norm(self):
"""
線分の長さ
"""
return abs(self.p1 - self.p2)
def phase(self):
"""
p1 を原点としたときの p2 の角度
"""
return (self.p2 - self.p1).phase()
def is_parallel_to(self, s):
"""
平行かどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A&lang=ja
:param Segment s:
:return:
"""
# 外積がゼロ
return abs((self.p1 - self.p2).det(s.p1 - s.p2)) < EPS
def is_orthogonal_to(self, s):
"""
直行しているかどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_A&lang=ja
:param Segment s:
:return:
"""
# 内積がゼロ
return abs((self.p1 - self.p2).dot(s.p1 - s.p2)) < EPS
def intersects_with(self, s, allow_side=True):
"""
交差するかどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_B&lang=ja
:param Segment s:
:param allow_side: 端っこでギリギリ触れているのを許容するか
"""
if self.is_parallel_to(s):
# 並行なら線分の端点がもう片方の線分の上にあるかどうか
return (s.p1.on_segment(self.p1, self.p2, allow_side) or
s.p2.on_segment(self.p1, self.p2, allow_side) or
self.p1.on_segment(s.p1, s.p2, allow_side) or
self.p2.on_segment(s.p1, s.p2, allow_side))
else:
# allow_side ならゼロを許容する
det_upper = EPS if allow_side else -EPS
ok = True
# self の両側に s.p1 と s.p2 があるか
ok &= (self.p2 - self.p1).det(s.p1 - self.p1) * (self.p2 - self.p1).det(s.p2 - self.p1) < det_upper
# s の両側に self.p1 と self.p2 があるか
ok &= (s.p2 - s.p1).det(self.p1 - s.p1) * (s.p2 - s.p1).det(self.p2 - s.p1) < det_upper
return ok
def closest_point(self, p):
"""
線分上の、p に最も近い点
:param Point p:
"""
# p からおろした垂線までの距離
d = (p - self.p1).dot(self.p2 - self.p1) / self.norm()
# p1 より前
if d < EPS:
return self.p1
# p2 より後
if -EPS < d - self.norm():
return self.p2
# 線分上
return Point.from_polar(d, (self.p2 - self.p1).phase()) + self.p1
def dist(self, p):
"""
他の点との最短距離
:param Point p:
"""
return abs(p - self.closest_point(p))
def dist_segment(self, s):
"""
他の線分との最短距離
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_2_D&lang=ja
:param Segment s:
"""
if self.intersects_with(s):
return 0.0
return min(
self.dist(s.p1),
self.dist(s.p2),
s.dist(self.p1),
s.dist(self.p2),
)
def has_point(self, p, allow_side=True):
"""
p が線分上に乗っているかどうか
:param Point p:
:param allow_side: 端っこでギリギリ触れているのを許容するか
"""
return p.on_segment(self.p1, self.p2, allow_side=allow_side)
class Polygon:
"""
2次元空間上の多角形
"""
def __init__(self, points):
"""
:param list of Point points:
"""
self.points = points
def iter2(self):
"""
隣り合う2点を順に返すイテレータ
:rtype: typing.Iterator[(Point, Point)]
"""
return zip(self.points, self.points[1:] + self.points[:1])
def iter3(self):
"""
隣り合う3点を順に返すイテレータ
:rtype: typing.Iterator[(Point, Point, Point)]
"""
return zip(self.points,
self.points[1:] + self.points[:1],
self.points[2:] + self.points[:2])
def area(self):
"""
面積
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_3_A&lang=ja
"""
# 外積の和 / 2
dets = []
for p, q in self.iter2():
dets.append(p.det(q))
return abs(math.fsum(dets)) / 2
def is_convex(self, allow_straight=False, allow_collapsed=False):
"""
凸多角形かどうか
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_3_B&lang=ja
:param allow_straight: 3点がまっすぐ並んでるのを許容するかどうか
:param allow_collapsed: 面積がゼロの場合を許容するか
"""
ccw = []
for a, b, c in self.iter3():
ccw.append(Point.ccw(a, b, c))
ccw = set(ccw)
if len(ccw) == 1:
if ccw == {Point.CCW_CLOCKWISE}:
return True
if ccw == {Point.CCW_COUNTER_CLOCKWISE}:
return True
if allow_straight and len(ccw) == 2:
if ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_CLOCKWISE}:
return True
if ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_COUNTER_CLOCKWISE}:
return True
if allow_collapsed and len(ccw) == 3:
return ccw == {Point.CCW_ONLINE_FRONT, Point.CCW_ONLINE_BACK, Point.CCW_ON_SEGMENT}
return False
def has_point_on_edge(self, p):
"""
指定した点が辺上にあるか
:param Point p:
:rtype: bool
"""
for a, b in self.iter2():
if p.on_segment(a, b):
return True
return False
def contains(self, p, allow_on_edge=True):
"""
指定した点を含むか
Winding Number Algorithm
https://www.nttpc.co.jp/technology/number_algorithm.html
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_3_C&lang=ja
:param Point p:
:param bool allow_on_edge: 辺上の点を許容するか
"""
angles = []
for a, b in self.iter2():
if p.on_segment(a, b):
return allow_on_edge
angles.append(p.angle(a, b))
# 一周以上するなら含む
return abs(math.fsum(angles)) > EPS
@staticmethod
def convex_hull(points, allow_straight=False):
"""
凸包。x が最も小さい点のうち y が最も小さい点から反時計回り。
Graham Scan O(N log N)
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_4_A&lang=ja
:param list of Point points:
:param allow_straight: 3点がまっすぐ並んでるのを許容するかどうか
:rtype: list of Point
"""
points = points[:]
points.sort(key=lambda p: (p.x, p.y))
# allow_straight なら 0 を許容する
det_lower = -EPS if allow_straight else EPS
sz = 0
#: :type: list of (Point|None)
ret = [None] * (len(points) * 2)
for p in points:
while sz > 1 and (ret[sz - 1] - ret[sz - 2]).det(p - ret[sz - 1]) < det_lower:
sz -= 1
ret[sz] = p
sz += 1
floor = sz
for p in reversed(points[:-1]):
while sz > floor and (ret[sz - 1] - ret[sz - 2]).det(p - ret[sz - 1]) < det_lower:
sz -= 1
ret[sz] = p
sz += 1
ret = ret[:sz - 1]
if allow_straight and len(ret) > len(points):
# allow_straight かつ全部一直線のときに二重にカウントしちゃう
ret = points
return ret
@staticmethod
def diameter(points):
"""
直径
凸包構築 O(N log N) + カリパー法 O(N)
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_4_B&lang=ja
:param list of Point points:
"""
# 反時計回り
points = Polygon.convex_hull(points, allow_straight=False)
if len(points) == 1:
return 0.0
if len(points) == 2:
return abs(points[0] - points[1])
# x軸方向に最も遠い点対
si = points.index(min(points, key=lambda p: (p.x, p.y)))
sj = points.index(max(points, key=lambda p: (p.x, p.y)))
n = len(points)
ret = 0.0
# 半周回転
i, j = si, sj
while i != sj or j != si:
ret = max(ret, abs(points[i] - points[j]))
ni = (i + 1) % n
nj = (j + 1) % n
# 2つの辺が並行になる方向にずらす
if (points[ni] - points[i]).det(points[nj] - points[j]) > 0:
j = nj
else:
i = ni
return ret
def convex_cut_by_line(self, line_p1, line_p2):
"""
凸多角形を直線 line_p1-line_p2 でカットする。
凸じゃないといけません
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_4_C&lang=ja
:param line_p1:
:param line_p2:
:return: (line_p1-line_p2 の左側の多角形, line_p1-line_p2 の右側の多角形)
:rtype: (Polygon|None, Polygon|None)
"""
n = len(self.points)
line = Line.from_segment(line_p1, line_p2)
# 直線と重なる点
on_line_points = []
for i, p in enumerate(self.points):
if line.has_point(p):
on_line_points.append(i)
# 辺が直線上にある
has_on_line_edge = False
if len(on_line_points) >= 3:
has_on_line_edge = True
elif len(on_line_points) == 2:
# 直線上にある点が隣り合ってる
has_on_line_edge = abs(on_line_points[0] - on_line_points[1]) in [1, n - 1]
# 辺が直線上にある場合、どっちか片方に全部ある
if has_on_line_edge:
for p in self.points:
ccw = Point.ccw(line_p1, line_p2, p)
if ccw == Point.CCW_COUNTER_CLOCKWISE:
return Polygon(self.points[:]), None
if ccw == Point.CCW_CLOCKWISE:
return None, Polygon(self.points[:])
ret_lefts = []
ret_rights = []
d = line_p2 - line_p1
for p, q in self.iter2():
det_p = d.det(p - line_p1)
det_q = d.det(q - line_p1)
if det_p > -EPS:
ret_lefts.append(p)
if det_p < EPS:
ret_rights.append(p)
# 外積の符号が違う == 直線の反対側にある場合は交点を追加
if det_p * det_q < -EPS:
intersection = line.intersection_point(Line.from_segment(p, q))
ret_lefts.append(intersection)
ret_rights.append(intersection)
# 点のみの場合を除いて返す
l = Polygon(ret_lefts) if len(ret_lefts) > 1 else None
r = Polygon(ret_rights) if len(ret_rights) > 1 else None
return l, r
def closest_pair(points):
"""
最近点対 O(N log N)
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_5_A&lang=ja
:param list of Point points:
:rtype: (float, (Point, Point))
:return: (距離, 点対)
"""
assert len(points) >= 2
def _rec(xsorted):
"""
:param list of Point xsorted:
:rtype: (float, (Point, Point))
"""
n = len(xsorted)
if n <= 2:
return xsorted[0].dist(xsorted[1]), (xsorted[0], xsorted[1])
if n <= 3:
# 全探索
d = INF
pair = None
for p, q in itertools.combinations(xsorted, r=2):
if p.dist(q) < d:
d = p.dist(q)
pair = p, q
return d, pair
# 分割統治
# 両側の最近点対
ld, lp = _rec(xsorted[:n // 2])
rd, rp = _rec(xsorted[n // 2:])
if ld <= rd:
d = ld
ret_pair = lp
else:
d = rd
ret_pair = rp
mid_x = xsorted[n // 2].x
# 中央から d 以内のやつを集める
mid_points = []
for p in xsorted:
# if abs(p.x - mid_x) < d:
if abs(p.x - mid_x) - d < -EPS:
mid_points.append(p)
# この中で距離が d 以内のペアがあれば更新
mid_points.sort(key=lambda p: p.y)
mid_n = len(mid_points)
for i in range(mid_n - 1):
j = i + 1
p = mid_points[i]
q = mid_points[j]
# while q.y - p.y < d
while (q.y - p.y) - d < -EPS:
pq_d = p.dist(q)
if pq_d < d:
d = pq_d
ret_pair = p, q
j += 1
if j >= mid_n:
break
q = mid_points[j]
return d, ret_pair
return _rec(list(sorted(points, key=lambda p: p.x)))
def closest_pair_randomized(points):
"""
最近点対 乱択版 O(N)
http://ir5.hatenablog.com/entry/20131221/1387557630
グリッドの管理が dict だから定数倍気になる
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_5_A&lang=ja
:param list of Point points:
:rtype: (float, (Point, Point))
:return: (距離, 点対)
"""
n = len(points)
assert n >= 2
if n == 2:
return points[0].dist(points[1]), (points[0], points[1])
# 逐次構成法
import random
points = points[:]
random.shuffle(points)
DELTA_XY = list(itertools.product([-1, 0, 1], repeat=2))
grid = defaultdict(list)
delta = INF
dist = points[0].dist(points[1])
ret_pair = points[0], points[1]
for i in range(2, n):
if delta < EPS:
return 0.0, ret_pair
# i 番目より前までを含む grid を構築
# if dist < delta:
if dist - delta < -EPS:
delta = dist
grid = defaultdict(list)
for a in points[:i]:
grid[a.x // delta, a.y // delta].append(a)
else:
p = points[i - 1]
grid[p.x // delta, p.y // delta].append(p)
p = points[i]
dist = delta
grid_x = p.x // delta
grid_y = p.y // delta
# 周り 9 箇所だけ調べれば OK
for dx, dy in DELTA_XY:
for q in grid[grid_x + dx, grid_y + dy]:
d = p.dist(q)
# if d < dist:
if d - dist < -EPS:
dist = d
ret_pair = p, q
return min(delta, dist), ret_pair
class Circle:
def __init__(self, o, r):
"""
:param Point o:
:param float r:
"""
self.o = o
self.r = r
def __eq__(self, other):
return self.o == other.o and abs(self.r - other.r) < EPS
def ctc(self, c):
"""
共通接線 common tangent の数
4: 離れてる
3: 外接
2: 交わってる
1: 内接
0: 内包
inf: 同一
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_7_A&lang=ja
:param Circle c:
:rtype: int
"""
if self.o == c.o:
return INF if abs(self.r - c.r) < EPS else 0
# 円同士の距離
d = self.o.dist(c.o) - self.r - c.r
if d > EPS:
return 4
elif d > -EPS:
return 3
# elif d > -min(self.r, c.r) * 2:
elif d + min(self.r, c.r) * 2 > EPS:
return 2
elif d + min(self.r, c.r) * 2 > -EPS:
return 1
return 0
def area(self):
"""
面積
"""
return self.r ** 2 * PI
def intersection_points(self, other, allow_outer=False):
"""
:param Segment|Circle other:
:param bool allow_outer:
"""
if isinstance(other, Segment):
return self.intersection_points_with_segment(other, allow_outer=allow_outer)
if isinstance(other, Circle):
return self.intersection_points_with_circle(other)
raise NotImplementedError()
def intersection_points_with_segment(self, s, allow_outer=False):
"""
線分と交差する点のリスト
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_7_D&lang=ja
:param Segment s:
:param bool allow_outer: 線分の間にない点を含む
:rtype: list of Point
"""
# 垂線の足
projection_point = self.o.projection_point(s.p1, s.p2, allow_outer=True)
# 線分との距離
dist = self.o.dist(projection_point)
# if dist > self.r:
if dist - self.r > EPS:
return []
if dist - self.r > -EPS:
if allow_outer or s.has_point(projection_point):
return [projection_point]
else:
return []
# 足から左右に diff だけ動かした座標が答え
diff = Point.from_polar(math.sqrt(self.r ** 2 - dist ** 2), s.phase())
ret1 = projection_point + diff
ret2 = projection_point - diff
ret = []
if allow_outer or s.has_point(ret1):
ret.append(ret1)
if allow_outer or s.has_point(ret2):
ret.append(ret2)
return ret
def intersection_points_with_circle(self, other):
"""
円と交差する点のリスト
Verify: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_7_E&langja
:param circle other:
:rtype: list of Point
"""
ctc = self.ctc(other)
if not 1 <= ctc <= 3:
return []
if ctc in (1, 3):
return [Point.from_polar(self.r, (other.o - self.o).phase()) + self.o]
# 2つ交点がある
assert ctc == 2
# 余弦定理で cos(a) を求めます
a = other.r
b = self.r
c = self.o.dist(other.o)
cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
angle = math.acos(cos_a)
phi = (other.o - self.o).phase()
return [
self.o + Point.from_polar(self.r, phi + angle),
self.o + Point.from_polar(self.r, phi - angle),
]
def tangent_points(self, p):
"""
p を通る接線との接点
:param Point p:
:rtype: list of Point
"""
dist = self.o.dist(p)
# if dist < self.r:
if dist - self.r < -EPS:
# p が円の内部にある
return []
if dist - self.r < EPS:
# p が円周上にある
return [Point(p.c)]
# 余弦定理で cos(a) を求めます
a = math.sqrt(dist ** 2 - self.r ** 2)
b = self.r
c = dist
cos_a = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
angle = math.acos(cos_a)
phi = (p - self.o).phase()
return [
self.o + Point.from_polar(self.r, phi + angle),
self.o + Point.from_polar(self.r, phi - angle),
]
def round_point(p):
"""
8桁で四捨五入して、-0を0に変換する
:param p:
:return:
"""
return round(p.x, 8) + 0, round(p.y, 8) + 0
px, py = list(map(int, sys.stdin.buffer.readline().split()))
cx, cy, r = list(map(int, sys.stdin.buffer.readline().split()))
circle = Circle(Point(complex(cx, cy)), r)
point = Point(complex(px, py))
ans = circle.tangent_points(point)
assert len(ans) == 2
p1, p2 = list(sorted(map(round_point, ans)))
print('{:.8f} {:.8f}'.format(*p1))
print('{:.8f} {:.8f}'.format(*p2))
``` |
p02458 Multi-Set | For a set $S$ of integers, perform a sequence of the following operations. Note that multiple elements can have equivalent values in $S$.
* insert($x$): Insert $x$ to $S$ and report the number of elements in $S$ after the operation.
* find($x$): Report the number of $x$ in $S$.
* delete($x$): Delete all $x$ from $S$.
* dump($L$, $R$): Print elements $x$ in $S$ such that $L \leq x \leq R$.
Constraints
* $1 \leq q \leq 200,000$
* $0 \leq x \leq 1,000,000,000$
* The total number of elements printed by dump operations does not exceed $1,000,000$
* The sum of numbers printed by find operations does not exceed $2,000,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 $x$
or
1 $x$
or
2 $x$
or
3 $L$ $R$
where the first digits 0, 1, 2 and 3 represent insert, find, delete and dump operations respectively.
Output
For each insert operation, print the number of elements in $S$.
For each find operation, print the number of specified elements in $S$.
For each dump operation, print the corresponding elements in ascending order. Print an element in a line.
Example
Input
10
0 1
0 1
0 2
0 3
2 2
1 1
1 2
1 3
0 4
3 1 4
Output
1
2
3
4
2
0
1
4
1
1
3
4 | ```python
import bisect
import collections
def main6():
values = collections.defaultdict(int)
element_count = 0
q = int(input())
for _ in range(q):
com, *para = map(int, input().split())
if com == 0:
values[para[0]] += 1
element_count += 1
print(element_count)
elif com == 1:
print(values[para[0]])
elif com == 2:
element_count -= values[para[0]]
values[para[0]] = 0
elif com == 3:
if para[0] == para[1]:
for _ in range(values[para[0]]):
print(para[0])
elif abs(para[0] - para[1]) < 10:
for i in range(para[0], para[1] + 1):
for _ in range(values[i]):
print(i)
else:
key_list = [k for k, v in values.items() if v != 0]
key_list = sorted(key_list)
lb = bisect.bisect_left(key_list, para[0])
rb = bisect.bisect_right(key_list, para[1])
for s in key_list[lb:rb] :
for _ in range(values[s]):
print(s)
main6()
``` |
1017_D. The Wu | Childan is making up a legendary story and trying to sell his forgery — a necklace with a strong sense of "Wu" to the Kasouras. But Mr. Kasoura is challenging the truth of Childan's story. So he is going to ask a few questions about Childan's so-called "personal treasure" necklace.
This "personal treasure" is a multiset S of m "01-strings".
A "01-string" is a string that contains n characters "0" and "1". For example, if n=4, strings "0110", "0000", and "1110" are "01-strings", but "00110" (there are 5 characters, not 4) and "zero" (unallowed characters) are not.
Note that the multiset S can contain equal elements.
Frequently, Mr. Kasoura will provide a "01-string" t and ask Childan how many strings s are in the multiset S such that the "Wu" value of the pair (s, t) is not greater than k.
Mrs. Kasoura and Mr. Kasoura think that if s_i = t_i (1≤ i≤ n) then the "Wu" value of the character pair equals to w_i, otherwise 0. The "Wu" value of the "01-string" pair is the sum of the "Wu" values of every character pair. Note that the length of every "01-string" is equal to n.
For example, if w=[4, 5, 3, 6], "Wu" of ("1001", "1100") is 7 because these strings have equal characters only on the first and third positions, so w_1+w_3=4+3=7.
You need to help Childan to answer Mr. Kasoura's queries. That is to find the number of strings in the multiset S such that the "Wu" value of the pair is not greater than k.
Input
The first line contains three integers n, m, and q (1≤ n≤ 12, 1≤ q, m≤ 5⋅ 10^5) — the length of the "01-strings", the size of the multiset S, and the number of queries.
The second line contains n integers w_1, w_2, …, w_n (0 ≤ w_i ≤ 100) — the value of the i-th caracter.
Each of the next m lines contains the "01-string" s of length n — the string in the multiset S.
Each of the next q lines contains the "01-string" t of length n and integer k (0≤ k≤ 100) — the query.
Output
For each query, print the answer for this query.
Examples
Input
2 4 5
40 20
01
01
10
11
00 20
00 40
11 20
11 40
11 60
Output
2
4
2
3
4
Input
1 2 4
100
0
1
0 0
0 100
1 0
1 100
Output
1
2
1
2
Note
In the first example, we can get:
"Wu" of ("01", "00") is 40.
"Wu" of ("10", "00") is 20.
"Wu" of ("11", "00") is 0.
"Wu" of ("01", "11") is 20.
"Wu" of ("10", "11") is 40.
"Wu" of ("11", "11") is 60.
In the first query, pairs ("11", "00") and ("10", "00") satisfy the condition since their "Wu" is not greater than 20.
In the second query, all strings satisfy the condition.
In the third query, pairs ("01", "11") and ("01", "11") satisfy the condition. Note that since there are two "01" strings in the multiset, the answer is 2, not 1.
In the fourth query, since k was increased, pair ("10", "11") satisfies the condition too.
In the fifth query, since k was increased, pair ("11", "11") satisfies the condition too. | ```python
from sys import stdin
def main():
n, m, q = map(int, input().split())
c = sz = 1 << n
costs, cnt = [0] * sz, [0] * sz
for w in map(int, input().split()):
c //= 2
for i in range(c, sz, c * 2):
for j in range(i, i + c):
costs[j] += w
for i, c in enumerate(costs):
if c > 101:
costs[i] = 101
costs.reverse()
l = stdin.read().splitlines()
for s in l[:m]:
cnt[int(s, 2)] += 1
del l[:m]
cache = []
for i in range(sz):
row = [0] * 102
cache.append(row)
for j, c in enumerate(cnt):
row[costs[i ^ j]] += c
a = 0
for j, b in enumerate(row):
a += b
row[j] = a
for i, s in enumerate(l):
row = s.split()
l[i] = str(cache[int(row[0], 2)][int(row[1])])
print('\n'.join(l))
if __name__ == '__main__':
main()
``` |
1041_A. Heist | There was an electronic store heist last night.
All keyboards which were in the store yesterday were numbered in ascending order from some integer number x. For example, if x = 4 and there were 3 keyboards in the store, then the devices had indices 4, 5 and 6, and if x = 10 and there were 7 of them then the keyboards had indices 10, 11, 12, 13, 14, 15 and 16.
After the heist, only n keyboards remain, and they have indices a_1, a_2, ..., a_n. Calculate the minimum possible number of keyboards that have been stolen. The staff remember neither x nor the number of keyboards in the store before the heist.
Input
The first line contains single integer n (1 ≤ n ≤ 1 000) — the number of keyboards in the store that remained after the heist.
The second line contains n distinct integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^{9}) — the indices of the remaining keyboards. The integers a_i are given in arbitrary order and are pairwise distinct.
Output
Print the minimum possible number of keyboards that have been stolen if the staff remember neither x nor the number of keyboards in the store before the heist.
Examples
Input
4
10 13 12 8
Output
2
Input
5
7 5 6 4 8
Output
0
Note
In the first example, if x=8 then minimum number of stolen keyboards is equal to 2. The keyboards with indices 9 and 11 were stolen during the heist.
In the second example, if x=4 then nothing was stolen during the heist. | ```python
def heist(n,a):
return max(a)-min(a)-n+1
n=int(input())
a=list(map(int,input().split()))
print(heist(n,a))
``` |
1105_C. Ayoub and Lost Array | Ayoub had an array a of integers of size n and this array had two interesting properties:
* All the integers in the array were between l and r (inclusive).
* The sum of all the elements was divisible by 3.
Unfortunately, Ayoub has lost his array, but he remembers the size of the array n and the numbers l and r, so he asked you to find the number of ways to restore the array.
Since the answer could be very large, print it modulo 10^9 + 7 (i.e. the remainder when dividing by 10^9 + 7). In case there are no satisfying arrays (Ayoub has a wrong memory), print 0.
Input
The first and only line contains three integers n, l and r (1 ≤ n ≤ 2 ⋅ 10^5 , 1 ≤ l ≤ r ≤ 10^9) — the size of the lost array and the range of numbers in the array.
Output
Print the remainder when dividing by 10^9 + 7 the number of ways to restore the array.
Examples
Input
2 1 3
Output
3
Input
3 2 2
Output
1
Input
9 9 99
Output
711426616
Note
In the first example, the possible arrays are : [1,2], [2,1], [3, 3].
In the second example, the only possible array is [2, 2, 2]. | ```python
MOD = 10**9 + 7
n,l,r = map(int,input().split())
dp = [[ 0,0,0]for i in range(n+1)]
# In condition l <= x <= r , mod 0,1,2 number count(define a,b,c)
a = r//3 - (l - 1)//3
b = (r+1)//3 - (l - 1 + 1)//3
c = (r+2)//3 - (l - 1 + 2)//3
#example
#l = 2 , r = 10
#a = 10//3 - 1//3 = 3 - 0 = 3 (3,6,9)
#b = 11//3 - 2//3 = 3 - 0 = 3 (4,7,10)
#c = 12//3 - 3//3 = 4 - 1 = 3 (2,5,8)
dp[1][0] = a
dp[1][1] = b
dp[1][2] = c
for i in range(1,n):
dp[i+1][0] = dp[i][0]*a%MOD + dp[i][1]*c%MOD + dp[i][2]*b%MOD
dp[i+1][1] = dp[i][0]*b%MOD + dp[i][1]*a%MOD + dp[i][2]*c%MOD
dp[i+1][2] = dp[i][0]*c%MOD + dp[i][1]*b%MOD + dp[i][2]*a%MOD
print(dp[n][0]%MOD)
``` |
1153_B. Serval and Toy Bricks | Luckily, Serval got onto the right bus, and he came to the kindergarten on time. After coming to kindergarten, he found the toy bricks very funny.
He has a special interest to create difficult problems for others to solve. This time, with many 1 × 1 × 1 toy bricks, he builds up a 3-dimensional object. We can describe this object with a n × m matrix, such that in each cell (i,j), there are h_{i,j} bricks standing on the top of each other.
However, Serval doesn't give you any h_{i,j}, and just give you the front view, left view, and the top view of this object, and he is now asking you to restore the object. Note that in the front view, there are m columns, and in the i-th of them, the height is the maximum of h_{1,i},h_{2,i},...,h_{n,i}. It is similar for the left view, where there are n columns. And in the top view, there is an n × m matrix t_{i,j}, where t_{i,j} is 0 or 1. If t_{i,j} equals 1, that means h_{i,j}>0, otherwise, h_{i,j}=0.
However, Serval is very lonely because others are bored about his unsolvable problems before, and refused to solve this one, although this time he promises there will be at least one object satisfying all the views. As his best friend, can you have a try?
Input
The first line contains three positive space-separated integers n, m, h (1≤ n, m, h ≤ 100) — the length, width and height.
The second line contains m non-negative space-separated integers a_1,a_2,...,a_m, where a_i is the height in the i-th column from left to right of the front view (0≤ a_i ≤ h).
The third line contains n non-negative space-separated integers b_1,b_2,...,b_n (0≤ b_j ≤ h), where b_j is the height in the j-th column from left to right of the left view.
Each of the following n lines contains m numbers, each is 0 or 1, representing the top view, where j-th number of i-th row is 1 if h_{i, j}>0, and 0 otherwise.
It is guaranteed that there is at least one structure satisfying the input.
Output
Output n lines, each of them contains m integers, the j-th number in the i-th line should be equal to the height in the corresponding position of the top view. If there are several objects satisfying the views, output any one of them.
Examples
Input
3 7 3
2 3 0 0 2 0 1
2 1 3
1 0 0 0 1 0 0
0 0 0 0 0 0 1
1 1 0 0 0 0 0
Output
1 0 0 0 2 0 0
0 0 0 0 0 0 1
2 3 0 0 0 0 0
Input
4 5 5
3 5 2 0 4
4 2 5 4
0 0 0 0 1
1 0 1 0 0
0 1 0 0 0
1 1 1 0 0
Output
0 0 0 0 4
1 0 2 0 0
0 5 0 0 0
3 4 1 0 0
Note
<image>
The graph above illustrates the object in the first example.
<image> <image>
The first graph illustrates the object in the example output for the second example, and the second graph shows the three-view drawing of it. | ```python
import sys, os, re, datetime
from collections import *
from bisect import *
def mat(v, *dims):
def submat(i):
if i == len(dims)-1: return [v for _ in range(dims[-1])]
return [submat(i+1) for _ in range(dims[i])]
return submat(0)
__cin__ = None
def cin():
global __cin__
if __cin__ is None: __cin__ = iter(input().split(" "))
try: return next(__cin__)
except StopIteration:
__cin__ = iter(input().split(" "))
return next(__cin__)
def iarr(n): return [int(cin()) for _ in range(n)]
def farr(n): return [float(cin()) for _ in range(n)]
def sarr(n): return [cin() for _ in range(n)]
def carr(n): return input()
def imat(n, m): return [iarr(m) for _ in range(n)]
def fmat(n, m): return [farr(m) for _ in range(n)]
def smat(n, m): return [sarr(m) for _ in range(n)]
def cmat(n, m): return [input() for _ in range(n)]
n = int(cin())
m = int(cin())
h = int(cin())
mv = iarr(m)
nv = iarr(n)
tv = imat(n, m)
ans = mat(0, n, m)
for i in range(n):
for j in range(m):
if tv[i][j] == 1: ans[i][j] = nv[i]
for j in range(m):
for i in range(n):
if tv[i][j] == 1: ans[i][j] = min(ans[i][j], mv[j])
for _r in ans:
for v in _r:
sys.stdout.write(str(v)+" ")
print()
``` |
1175_A. From Hero to Zero | You are given an integer n and an integer k.
In one step you can do one of the following moves:
* decrease n by 1;
* divide n by k if n is divisible by k.
For example, if n = 27 and k = 3 you can do the following steps: 27 → 26 → 25 → 24 → 8 → 7 → 6 → 2 → 1 → 0.
You are asked to calculate the minimum number of steps to reach 0 from n.
Input
The first line contains one integer t (1 ≤ t ≤ 100) — the number of queries.
The only line of each query contains two integers n and k (1 ≤ n ≤ 10^{18}, 2 ≤ k ≤ 10^{18}).
Output
For each query print the minimum number of steps to reach 0 from n in single line.
Example
Input
2
59 3
1000000000000000000 10
Output
8
19
Note
Steps for the first test case are: 59 → 58 → 57 → 19 → 18 → 6 → 2 → 1 → 0.
In the second test case you have to divide n by k 18 times and then decrease n by 1. | ```python
import math
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
count=0
a,b=int(n//k),int(n%k)
while n>0:
if k>n:
a,b=0,int(n%k)
else:
a,b=math.floor(n//k),int(n%k)
n=a
if a==0:
count+=b
else:
count+=(b+1)
print(count)
``` |
1231_C. Increasing Matrix | In this problem, a n × m rectangular matrix a is called increasing if, for each row of i, when go from left to right, the values strictly increase (that is, a_{i,1}<a_{i,2}<...<a_{i,m}) and for each column j, when go from top to bottom, the values strictly increase (that is, a_{1,j}<a_{2,j}<...<a_{n,j}).
In a given matrix of non-negative integers, it is necessary to replace each value of 0 with some positive integer so that the resulting matrix is increasing and the sum of its elements is maximum, or find that it is impossible.
It is guaranteed that in a given value matrix all values of 0 are contained only in internal cells (that is, not in the first or last row and not in the first or last column).
Input
The first line contains integers n and m (3 ≤ n, m ≤ 500) — the number of rows and columns in the given matrix a.
The following lines contain m each of non-negative integers — the values in the corresponding row of the given matrix: a_{i,1}, a_{i,2}, ..., a_{i,m} (0 ≤ a_{i,j} ≤ 8000).
It is guaranteed that for all a_{i,j}=0, 1 < i < n and 1 < j < m are true.
Output
If it is possible to replace all zeros with positive numbers so that the matrix is increasing, print the maximum possible sum of matrix elements. Otherwise, print -1.
Examples
Input
4 5
1 3 5 6 7
3 0 7 0 9
5 0 0 0 10
8 9 10 11 12
Output
144
Input
3 3
1 2 3
2 0 4
4 5 6
Output
30
Input
3 3
1 2 3
3 0 4
4 5 6
Output
-1
Input
3 3
1 2 3
2 3 4
3 4 2
Output
-1
Note
In the first example, the resulting matrix is as follows:
1 3 5 6 7
3 6 7 8 9
5 7 8 9 10
8 9 10 11 12
In the second example, the value 3 must be put in the middle cell.
In the third example, the desired resultant matrix does not exist. | ```python
def main():
n, m = map(int, input().split())
l = list(list(map(int, input().split()))[::-1] for _ in range(n))[::-1]
for r0, r1 in zip(l, l[1:-1]):
for i, a in enumerate(r1[1:-1], 1):
if not a:
r1[i] = min(r1[i - 1], r0[i]) - 1
print(sum(map(sum, l)) if all(r1[i - 1] > a < r0[i] for r0, r1 in zip(l, l[1:]) for i, a in enumerate(r1[1:], 1))
and all(a < b for a, b in zip(l[0][1:], l[0])) and all(
r1[0] < r0[0] for r0, r1 in zip(l, l[1:])) else -1)
if __name__ == '__main__':
main()
``` |
1272_E. Nearest Opposite Parity | You are given an array a consisting of n integers. In one move, you can jump from the position i to the position i - a_i (if 1 ≤ i - a_i) or to the position i + a_i (if i + a_i ≤ n).
For each position i from 1 to n you want to know the minimum the number of moves required to reach any position j such that a_j has the opposite parity from a_i (i.e. if a_i is odd then a_j has to be even and vice versa).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the i-th element of a.
Output
Print n integers d_1, d_2, ..., d_n, where d_i is the minimum the number of moves required to reach any position j such that a_j has the opposite parity from a_i (i.e. if a_i is odd then a_j has to be even and vice versa) or -1 if it is impossible to reach such a position.
Example
Input
10
4 5 7 6 7 5 4 4 6 4
Output
1 1 1 2 -1 1 1 3 1 1 | ```python
input()
n=map(int,input().split())
n=list(n)
ans=len(n)*[-1]
a=[]
go=[[] for _ in range(len(n))]
for i,x in enumerate(n):
for y in (x,-x):
y+=i
if y>=0 and y<len(n):
if x%2!=n[y]%2:
ans[i]=1
a.append(i)
else:
go[y].append(i)
while len(a)!=0:
b=[]
for x in a:
for y in go[x]:
if ans[y]==-1:
ans[y]=ans[x]+1
b.append(y)
a=b
for i,x in enumerate(ans):
ans[i]=str(x)
print(' '.join(ans))
``` |
1295_F. Good Contest | An online contest will soon be held on ForceCoders, a large competitive programming platform. The authors have prepared n problems; and since the platform is very popular, 998244351 coder from all over the world is going to solve them.
For each problem, the authors estimated the number of people who would solve it: for the i-th problem, the number of accepted solutions will be between l_i and r_i, inclusive.
The creator of ForceCoders uses different criteria to determine if the contest is good or bad. One of these criteria is the number of inversions in the problem order. An inversion is a pair of problems (x, y) such that x is located earlier in the contest (x < y), but the number of accepted solutions for y is strictly greater.
Obviously, both the creator of ForceCoders and the authors of the contest want the contest to be good. Now they want to calculate the probability that there will be no inversions in the problem order, assuming that for each problem i, any integral number of accepted solutions for it (between l_i and r_i) is equally probable, and all these numbers are independent.
Input
The first line contains one integer n (2 ≤ n ≤ 50) — the number of problems in the contest.
Then n lines follow, the i-th line contains two integers l_i and r_i (0 ≤ l_i ≤ r_i ≤ 998244351) — the minimum and maximum number of accepted solutions for the i-th problem, respectively.
Output
The probability that there will be no inversions in the contest can be expressed as an irreducible fraction x/y, where y is coprime with 998244353. Print one integer — the value of xy^{-1}, taken modulo 998244353, where y^{-1} is an integer such that yy^{-1} ≡ 1 (mod 998244353).
Examples
Input
3
1 2
1 2
1 2
Output
499122177
Input
2
42 1337
13 420
Output
578894053
Input
2
1 1
0 0
Output
1
Input
2
1 1
1 1
Output
1
Note
The real answer in the first test is 1/2. | ```python
import sys
from itertools import chain
readline = sys.stdin.readline
MOD = 998244353
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N = int(readline())
LR = [tuple(map(int, readline().split())) for _ in range(N)]
LR = [(a-1, b) for a, b in LR]
LR2 = LR[:]
ml = LR[-1][0]
res = 0
for i in range(N-2, -1, -1):
l, r = LR[i]
if r <= ml:
break
l = max(ml, l)
ml = l
LR[i] = (l, r)
else:
Z = list(chain(*LR))
Z2, Dc = compress(Z)
NN = len(Z2)
seglen = [0] + [n - p for p, n in zip(Z2, Z2[1:])]
hc = [[0]*(N+3) for _ in range(NN)]
for j in range(NN):
hc[j][0] = 1
for k in range(1, N+3):
hc[j][k] = hc[j][k-1]*pow(k, MOD-2, MOD)*(seglen[j]-1+k)%MOD
mask = [[[True]*NN]]
dp = [[[0]*(N+1) for _ in range(NN+1)] for _ in range(N+1)]
Dp = [[1]*(NN+1)] + [[0]*(NN+1) for _ in range(N)]
for i in range(1, N+1):
mask2 = [False]*NN
l, r = LR[i-1]
dl, dr = Dc[l], Dc[r]
for j in range(dr, dl, -1):
mask2[j] = True
mm = [[m1&m2 for m1, m2 in zip(mask[-1][idx], mask2)] for idx in range(i)] + [mask2]
mask.append(mm)
for j in range(NN):
for k in range(1, i+1):
if mask[i][i-k+1][j]:
dp[i][j][k] = Dp[i-k][j+1]*hc[j][k]%MOD
for j in range(NN-1, -1, -1):
res = Dp[i][j+1]
if dl < j <= dr:
for k in range(1, i+1):
res = (res + dp[i][j][k])%MOD
Dp[i][j] = res
res = Dp[N][0]
for l, r in LR2:
res = res*(pow(r-l, MOD-2, MOD))%MOD
print(res)
``` |
1338_B. Edge Weight Assignment | You have unweighted tree of n vertices. You have to assign a positive weight to each edge so that the following condition would hold:
* For every two different leaves v_{1} and v_{2} of this tree, [bitwise XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) of weights of all edges on the simple path between v_{1} and v_{2} has to be equal to 0.
Note that you can put very large positive integers (like 10^{(10^{10})}).
It's guaranteed that such assignment always exists under given constraints. Now let's define f as the number of distinct weights in assignment.
<image> In this example, assignment is valid, because bitwise XOR of all edge weights between every pair of leaves is 0. f value is 2 here, because there are 2 distinct edge weights(4 and 5).
<image> In this example, assignment is invalid, because bitwise XOR of all edge weights between vertex 1 and vertex 6 (3, 4, 5, 4) is not 0.
What are the minimum and the maximum possible values of f for the given tree? Find and print both.
Input
The first line contains integer n (3 ≤ n ≤ 10^{5}) — the number of vertices in given tree.
The i-th of the next n-1 lines contains two integers a_{i} and b_{i} (1 ≤ a_{i} < b_{i} ≤ n) — it means there is an edge between a_{i} and b_{i}. It is guaranteed that given graph forms tree of n vertices.
Output
Print two integers — the minimum and maximum possible value of f can be made from valid assignment of given tree. Note that it's always possible to make an assignment under given constraints.
Examples
Input
6
1 3
2 3
3 4
4 5
5 6
Output
1 4
Input
6
1 3
2 3
3 4
4 5
4 6
Output
3 3
Input
7
1 2
2 7
3 4
4 7
5 6
6 7
Output
1 6
Note
In the first example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image>
In the second example, possible assignments for each minimum and maximum are described in picture below. The f value of valid assignment of this tree is always 3.
<image>
In the third example, possible assignments for each minimum and maximum are described in picture below. Of course, there are multiple possible assignments for each minimum and maximum.
<image> | ```python
import sys
# try:
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
# except:
# pass
input = sys.stdin.readline
def DFS(i):
visited = {i:True}
stack = [(i,0)]
while len(stack)!=0:
tail,depth = stack.pop(-1)
flag = True
for each in neigh[tail]:
if each not in visited:
visited[each] = True
flag = False
stack.append((each,depth+1))
if flag:
leafDepth.append(depth)
n = int(input())
neigh = [[] for i in range(n)]
l = []
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
neigh[a].append(b)
neigh[b].append(a)
l.append((a,b))
#Max
edges = set()
for a, b in l:
if len(neigh[a]) == 1:
a = -1
if len(neigh[b]) == 1:
b = -1
if a > b:
a, b = b, a
edges.add((a,b))
MAX = len(edges)
#Min
leafDepth = []
DFS(0)
if (len(neigh[0])==1):
MIN = 1 if all([True if i%2==0 else False for i in leafDepth]) else 3
else:
MIN = 1 if all([True if i%2==0 else False for i in leafDepth]) or all([True if i%2==1 else False for i in leafDepth]) else 3
#Out
print(MIN, MAX)
``` |
1360_A. Minimal Square | Find the minimum area of a square land on which you can place two identical rectangular a × b houses. The sides of the houses should be parallel to the sides of the desired square land.
Formally,
* You are given two identical rectangles with side lengths a and b (1 ≤ a, b ≤ 100) — positive integers (you are given just the sizes, but not their positions).
* Find the square of the minimum area that contains both given rectangles. Rectangles can be rotated (both or just one), moved, but the sides of the rectangles should be parallel to the sides of the desired square.
Two rectangles can touch each other (side or corner), but cannot intersect. Rectangles can also touch the sides of the square but must be completely inside it. You can rotate the rectangles. Take a look at the examples for a better understanding.
<image> The picture shows a square that contains red and green rectangles.
Input
The first line contains an integer t (1 ≤ t ≤ 10 000) —the number of test cases in the input. Then t test cases follow.
Each test case is a line containing two integers a, b (1 ≤ a, b ≤ 100) — side lengths of the rectangles.
Output
Print t answers to the test cases. Each answer must be a single integer — minimal area of square land, that contains two rectangles with dimensions a × b.
Example
Input
8
3 2
4 2
1 1
3 1
4 7
1 3
7 4
100 100
Output
16
16
4
9
64
9
64
40000
Note
Below are the answers for the first two test cases:
<image> <image> | ```python
num=int(input(""))
i=0
while i<num:
a,b=(input("")).split()
minimum=min(int(a),int(b))
maximum=max(int(a),int(b))
if minimum*2<maximum:
print(maximum**2)
else:
print((minimum*2)**2)
i+=1
``` |
1380_B. Universal Solution | Recently, you found a bot to play "Rock paper scissors" with. Unfortunately, the bot uses quite a simple algorithm to play: he has a string s = s_1 s_2 ... s_{n} of length n where each letter is either R, S or P.
While initializing, the bot is choosing a starting index pos (1 ≤ pos ≤ n), and then it can play any number of rounds. In the first round, he chooses "Rock", "Scissors" or "Paper" based on the value of s_{pos}:
* if s_{pos} is equal to R the bot chooses "Rock";
* if s_{pos} is equal to S the bot chooses "Scissors";
* if s_{pos} is equal to P the bot chooses "Paper";
In the second round, the bot's choice is based on the value of s_{pos + 1}. In the third round — on s_{pos + 2} and so on. After s_n the bot returns to s_1 and continues his game.
You plan to play n rounds and you've already figured out the string s but still don't know what is the starting index pos. But since the bot's tactic is so boring, you've decided to find n choices to each round to maximize the average number of wins.
In other words, let's suggest your choices are c_1 c_2 ... c_n and if the bot starts from index pos then you'll win in win(pos) rounds. Find c_1 c_2 ... c_n such that (win(1) + win(2) + ... + win(n))/(n) is maximum possible.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
Next t lines contain test cases — one per line. The first and only line of each test case contains string s = s_1 s_2 ... s_{n} (1 ≤ n ≤ 2 ⋅ 10^5; s_i ∈ \{R, S, P\}) — the string of the bot.
It's guaranteed that the total length of all strings in one test doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print n choices c_1 c_2 ... c_n to maximize the average number of wins. Print them in the same manner as the string s.
If there are multiple optimal answers, print any of them.
Example
Input
3
RRRR
RSP
S
Output
PPPP
RSP
R
Note
In the first test case, the bot (wherever it starts) will always choose "Rock", so we can always choose "Paper". So, in any case, we will win all n = 4 rounds, so the average is also equal to 4.
In the second test case:
* if bot will start from pos = 1, then (s_1, c_1) is draw, (s_2, c_2) is draw and (s_3, c_3) is draw, so win(1) = 0;
* if bot will start from pos = 2, then (s_2, c_1) is win, (s_3, c_2) is win and (s_1, c_3) is win, so win(2) = 3;
* if bot will start from pos = 3, then (s_3, c_1) is lose, (s_1, c_2) is lose and (s_2, c_3) is lose, so win(3) = 0;
The average is equal to (0 + 3 + 0)/(3) = 1 and it can be proven that it's the maximum possible average.
A picture from Wikipedia explaining "Rock paper scissors" game:
<image> | ```python
dic={
'R':'P',
'P':'S',
'S':'R'
}
t=int(input())
for _ in range(t):
S=input()
n=len(S)
r,p,s=[0,0,0]
for i in range(len(S)):
if S[i]=='R':
r=r+1
elif S[i]=='P':
p=p+1
else:
s=s+1
m=max(r,p,s)
if r==m:
print(n*dic['R'])
elif p==m:
print(n*dic['P'])
else:
print(n*dic['S'])
``` |
1400_B. RPG Protagonist | You are playing one RPG from the 2010s. You are planning to raise your smithing skill, so you need as many resources as possible. So how to get resources? By stealing, of course.
You decided to rob a town's blacksmith and you take a follower with you. You can carry at most p units and your follower — at most f units.
In the blacksmith shop, you found cnt_s swords and cnt_w war axes. Each sword weights s units and each war axe — w units. You don't care what to take, since each of them will melt into one steel ingot.
What is the maximum number of weapons (both swords and war axes) you and your follower can carry out from the shop?
Input
The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases.
The first line of each test case contains two integers p and f (1 ≤ p, f ≤ 10^9) — yours and your follower's capacities.
The second line of each test case contains two integers cnt_s and cnt_w (1 ≤ cnt_s, cnt_w ≤ 2 ⋅ 10^5) — the number of swords and war axes in the shop.
The third line of each test case contains two integers s and w (1 ≤ s, w ≤ 10^9) — the weights of each sword and each war axe.
It's guaranteed that the total number of swords and the total number of war axes in all test cases don't exceed 2 ⋅ 10^5.
Output
For each test case, print the maximum number of weapons (both swords and war axes) you and your follower can carry.
Example
Input
3
33 27
6 10
5 6
100 200
10 10
5 5
1 19
1 3
19 5
Output
11
20
3
Note
In the first test case:
* you should take 3 swords and 3 war axes: 3 ⋅ 5 + 3 ⋅ 6 = 33 ≤ 33
* and your follower — 3 swords and 2 war axes: 3 ⋅ 5 + 2 ⋅ 6 = 27 ≤ 27.
3 + 3 + 3 + 2 = 11 weapons in total.
In the second test case, you can take all available weapons even without your follower's help, since 5 ⋅ 10 + 5 ⋅ 10 ≤ 100.
In the third test case, you can't take anything, but your follower can take 3 war axes: 3 ⋅ 5 ≤ 19. | ```python
# cook your dish here
# cook your dish here
from sys import stdin,stdout
from collections import Counter
from itertools import permutations
import bisect
import math
I=lambda: map(int,stdin.readline().split())
I1=lambda: stdin.readline()
for _ in range(int(I1())):
p,f=I()
cs,cw=I()
s,w=I()
if s>w:
s,w=w,s
cs,cw=cw,cs
ans=0
i=0
while i<=cs:
if i*s>p:
break
p1=i
p2=min((p-p1*s)//w,cw)
f1=min(cs-i,f//s)
f2=min((f-f1*s)//w,cw-p2)
ans=max(ans,p1+p2+f1+f2)
i+=1
print(ans)
``` |
1424_B. Valuable Paper | The pandemic is upon us, and the world is in shortage of the most important resource: toilet paper. As one of the best prepared nations for this crisis, BubbleLand promised to help all other world nations with this valuable resource. To do that, the country will send airplanes to other countries carrying toilet paper.
In BubbleLand, there are N toilet paper factories, and N airports. Because of how much it takes to build a road, and of course legal issues, every factory must send paper to only one airport, and every airport can only take toilet paper from one factory.
Also, a road can't be built between all airport-factory pairs, again because of legal issues. Every possible road has number d given, number of days it takes to build that road.
Your job is to choose N factory-airport pairs, such that if the country starts building all roads at the same time, it takes the least amount of days to complete them.
Input
The first line contains two integers N (1 ≤ N ≤ 10^4) - number of airports/factories, and M (1 ≤ M ≤ 10^5) - number of available pairs to build a road between.
On next M lines, there are three integers u, v (1 ≤ u,v ≤ N), d (1 ≤ d ≤ 10^9) - meaning that you can build a road between airport u and factory v for d days.
Output
If there are no solutions, output -1. If there exists a solution, output the minimal number of days to complete all roads, equal to maximal d among all chosen roads.
Example
Input
3 5
1 2 1
2 3 2
3 3 3
2 1 4
2 2 5
Output
4 | ```python
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def getInts():
return [int(s) for s in input().split()]
from collections import deque
def maximum_matching(graph):
"""Find a maximum unweighted matching in a bipartite graph. The input
must be a dictionary mapping vertices in one partition to sets of
vertices in the other partition. Return a dictionary mapping
vertices in one partition to their matched vertex in the other.
"""
# The two partitions of the graph.
U = set(graph.keys())
V = set.union(*graph.values())
# A distinguished vertex not belonging to the graph.
nil = object()
# Current pairing for vertices in each partition.
pair_u = dict.fromkeys(U, nil)
pair_v = dict.fromkeys(V, nil)
if len(pair_u) != len(pair_v):
return []
# Distance to each vertex along augmenting paths.
dist = {}
inf = (1 << 28)
def bfs():
# Breadth-first search of the graph starting with unmatched
# vertices in U and following "augmenting paths" alternating
# between edges from U->V not in the matching and edges from
# V->U in the matching. This partitions the vertexes into
# layers according to their distance along augmenting paths.
queue = deque()
for u in U:
if pair_u[u] is nil:
dist[u] = 0
queue.append(u)
else:
dist[u] = inf
dist[nil] = inf
while queue:
u = queue.popleft()
if dist[u] < dist[nil]:
# Follow edges from U->V not in the matching.
for v in graph[u]:
# Follow edge from V->U in the matching, if any.
uu = pair_v[v]
if dist[uu] == inf:
dist[uu] = dist[u] + 1
queue.append(uu)
return dist[nil] is not inf
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
@bootstrap
def dfs(u):
# Depth-first search along "augmenting paths" starting at
# u. If we can find such a path that goes all the way from
# u to nil, then we can swap matched/unmatched edges all
# along the path, getting one additional matched edge
# (since the path must have an odd number of edges).
if u is not nil:
for v in graph[u]:
uu = pair_v[v]
if dist[uu] == dist[u] + 1: # uu in next layer
if (dfs(uu)):
# Found augmenting path all the way to nil. In
# this path v was matched with uu, so after
# swapping v must now be matched with u.
pair_v[v] = u
pair_u[u] = v
yield True
dist[u] = inf
yield False
yield True
while bfs():
for u in U:
if pair_u[u] is nil:
dfs(u)
return {u: v for u, v in pair_u.items() if v is not nil}
N, M = getInts()
max_edge = 0
edges = []
u_set = set()
v_set = set()
while M:
u, v, d = getInts()
u_set.add(u)
v_set.add(v)
edges.append((u,v,d))
max_edge = max(d,max_edge)
M -= 1
l = 0
r = max_edge+1
ans = 2*(10**9)
import collections
if len(u_set) != N or len(v_set) != N:
print(-1)
else:
while (l <= r):
m = (l + r) >> 1
G = collections.defaultdict(set)
for u,v,d in edges:
if d <= m:
G[u].add(v+N)
#print(m,G)
if not G:
l = m + 1
continue
matching = maximum_matching(G)
if (len(matching) == N):
ans = m
r = m - 1
else:
l = m + 1
if (ans == 2*(10**9)):
print(-1)
else:
print(ans)
``` |
1469_D. Ceil Divisions | You have an array a_1, a_2, ..., a_n where a_i = i.
In one step, you can choose two indices x and y (x ≠ y) and set a_x = \left⌈ (a_x)/(a_y) \right⌉ (ceiling function).
Your goal is to make array a consist of n - 1 ones and 1 two in no more than n + 5 steps. Note that you don't have to minimize the number of steps.
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer n (3 ≤ n ≤ 2 ⋅ 10^5) — the length of array a.
It's guaranteed that the sum of n over test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print the sequence of operations that will make a as n - 1 ones and 1 two in the following format: firstly, print one integer m (m ≤ n + 5) — the number of operations; next print m pairs of integers x and y (1 ≤ x, y ≤ n; x ≠ y) (x may be greater or less than y) — the indices of the corresponding operation.
It can be proven that for the given constraints it's always possible to find a correct sequence of operations.
Example
Input
2
3
4
Output
2
3 2
3 2
3
3 4
4 2
4 2
Note
In the first test case, you have array a = [1, 2, 3]. For example, you can do the following:
1. choose 3, 2: a_3 = \left⌈ (a_3)/(a_2) \right⌉ = 2 and array a = [1, 2, 2];
2. choose 3, 2: a_3 = \left⌈ 2/2 \right⌉ = 1 and array a = [1, 2, 1].
You've got array with 2 ones and 1 two in 2 steps.
In the second test case, a = [1, 2, 3, 4]. For example, you can do the following:
1. choose 3, 4: a_3 = \left⌈ 3/4 \right⌉ = 1 and array a = [1, 2, 1, 4];
2. choose 4, 2: a_4 = \left⌈ 4/2 \right⌉ = 2 and array a = [1, 2, 1, 2];
3. choose 4, 2: a_4 = \left⌈ 2/2 \right⌉ = 1 and array a = [1, 2, 1, 1]. | ```python
import math
def solution() :
for tc in range(int(input())) :
n = int(input())
ls = [i for i in range(1, n+1)]
ans = []
for i in range(n-2, 0, -1) :
while math.ceil(ls[n-1] / ls[i]) >= ls[i] :
ans.append([n, i+1])
ls[n-1] = math.ceil(ls[n-1] / ls[i])
ans.append([i+1, n])
ls[i] = math.ceil(ls[i] / ls[n-1])
#print("out")
print(len(ans))
for i in range(len(ans)) :
print(*ans[i])
solution()
``` |
1517_E. Group Photo | In the 2050 Conference, some people from the competitive programming community meet together and are going to take a photo. The n people form a line. They are numbered from 1 to n from left to right. Each of them either holds a cardboard with the letter 'C' or a cardboard with the letter 'P'.
Let C=\\{c_1,c_2,...,c_m\} (c_1<c_2<… <c_m) be the set of people who hold cardboards of 'C'. Let P=\\{p_1,p_2,...,p_k\} (p_1<p_2<… <p_k) be the set of people who hold cardboards of 'P'. The photo is good if and only if it satisfies the following constraints:
1. C∪ P=\{1,2,...,n\}
2. C∩ P =∅ .
3. c_i-c_{i-1}≤ c_{i+1}-c_i(1< i <m).
4. p_i-p_{i-1}≥ p_{i+1}-p_i(1< i <k).
Given an array a_1,…, a_n, please find the number of good photos satisfying the following condition: $$$∑_{x∈ C} a_x < ∑_{y∈ P} a_y.$$$
The answer can be large, so output it modulo 998 244 353. Two photos are different if and only if there exists at least one person who holds a cardboard of 'C' in one photo but holds a cardboard of 'P' in the other.
Input
Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 200 000). Description of the test cases follows.
The first line of each test case contains a single integer n (1≤ n≤ 200 000).
The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9).
It is guaranteed that the sum of n over all test cases does not exceed 200 000.
Output
For each test case, output the answer modulo 998 244 353 in a separate line.
Example
Input
3
5
2 1 2 1 1
4
9 2 2 2
1
998244353
Output
10
7
1
Note
For the first test case, there are 10 possible good photos satisfying the condition: PPPPP, CPPPP, PCPPP, CCPPP, PCCPP, PCPCP, PPPPC, CPPPC, PCPPC, PPPCC.
For the second test case, there are 7 possible good photos satisfying the condition: PPPP, PCPP, PCCP, PPPC, PCPC, PPCC, PCCC. | ```python
import sys,io,os
try:Z=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
except:Z=lambda:sys.stdin.readline().encode()
Y=lambda:map(int,Z().split())
from bisect import bisect
M=998244353
def add(a,b):
v=a+b
if v>=M:v-=M
if v<0:v+=M
return v
def sol(n,a,disp=0):
if n<2:return 1
if n<3:return 2-(a[0]==a[1])
x0=[0];x1=[0];z=1;y=a[-1];s=sum(a)
for i in range(n):
if i&1:x1.append(x1[-1]+a[i])
else:x0.append(x0[-1]+a[i])
c=(s+1)//2
while y<c:z+=1;y+=a[-z]
if disp:print(c)
for i in range(n-1):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if(n&1)<1:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c-=a[-1]
if disp:print(c)
for i in range(n-2):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if n&1:
if j==n//2+1:j-=1
else:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
else:
if j==n//2+1:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c+=a[0]
if disp:print(c)
for i in range(1,n-2):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if n&1:
if j==n//2+1:j-=1
else:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
else:
if j==n//2+1:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
c+=a[-1]
if disp:print(c)
for i in range(1,n-1):
if i&1:
aps=x0[i//2+1]
if aps+x1[i//2+1]>=c:break
j=bisect(x1,c-aps-1)
if(n&1)<1:
if j==n//2+1:j-=1
else:
aps=x1[i//2]
if aps+x0[i//2+1]>=c:break
j=bisect(x0,c-aps-1)
if n&1:
if j==n//2+2:j-=1
z=add(z,j-i//2-1)
if disp:print(i,j-i//2-1)
if disp:print(z)
return z
O=[]
for _ in range(int(Z())):O.append(str(sol(int(Z()),[*Y()])))
print('\n'.join(O))
``` |
172_C. Bus | There is a bus stop near the university. The lessons are over, and n students come to the stop. The i-th student will appear at the bus stop at time ti (all ti's are distinct).
We shall assume that the stop is located on the coordinate axis Ox, at point x = 0, and the bus goes along the ray Ox, that is, towards the positive direction of the coordinate axis, and back. The i-th student needs to get to the point with coordinate xi (xi > 0).
The bus moves by the following algorithm. Initially it is at point 0. The students consistently come to the stop and get on it. The bus has a seating capacity which is equal to m passengers. At the moment when m students get on the bus, it starts moving in the positive direction of the coordinate axis. Also it starts moving when the last (n-th) student gets on the bus. The bus is moving at a speed of 1 unit of distance per 1 unit of time, i.e. it covers distance y in time y.
Every time the bus passes the point at which at least one student needs to get off, it stops and these students get off the bus. The students need 1 + [k / 2] units of time to get off the bus, where k is the number of students who leave at this point. Expression [k / 2] denotes rounded down k / 2. As soon as the last student leaves the bus, the bus turns around and goes back to the point x = 0. It doesn't make any stops until it reaches the point. At the given point the bus fills with students once more, and everything is repeated.
If students come to the stop when there's no bus, they form a line (queue) and get on the bus in the order in which they came. Any number of students get on the bus in negligible time, you should assume that it doesn't take any time. Any other actions also take no time. The bus has no other passengers apart from the students.
Write a program that will determine for each student the time when he got off the bus. The moment a student got off the bus is the moment the bus stopped at the student's destination stop (despite the fact that the group of students need some time to get off).
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105) — the number of students and the number of passengers the bus can transport, correspondingly. Next n lines contain descriptions of the students, one per line. Each line contains a pair of integers ti, xi (1 ≤ ti ≤ 105, 1 ≤ xi ≤ 104). The lines are given in the order of strict increasing of ti. Values of xi can coincide.
Output
Print n numbers w1, w2, ..., wn, wi — the moment of time when the i-th student got off the bus. Print the numbers on one line and separate them with single spaces.
Examples
Input
1 10
3 5
Output
8
Input
2 1
3 5
4 5
Output
8 19
Input
5 4
3 5
4 5
5 5
6 5
7 1
Output
11 11 11 11 20
Input
20 4
28 13
31 13
35 6
36 4
52 6
53 4
83 2
84 4
87 1
93 6
108 4
113 6
116 1
125 2
130 2
136 13
162 2
166 4
184 1
192 2
Output
51 51 43 40 93 89 86 89 114 121 118 121 137 139 139 152 195 199 193 195
Note
In the first sample the bus waits for the first student for 3 units of time and drives him to his destination in additional 5 units of time. So the student leaves the bus at the moment of time 3 + 5 = 8.
In the second sample the capacity of the bus equals 1, that's why it will drive the first student alone. This student is the same as the student from the first sample. So the bus arrives to his destination at the moment of time 8, spends 1 + [1 / 2] = 1 units of time on getting him off, and returns back to 0 in additional 5 units of time. That is, the bus returns to the bus stop at the moment of time 14. By this moment the second student has already came to the bus stop. So he immediately gets in the bus, and is driven to his destination in additional 5 units of time. He gets there at the moment 14 + 5 = 19.
In the third sample the bus waits for the fourth student for 6 units of time, then drives for 5 units of time, then gets the passengers off for 1 + [4 / 2] = 3 units of time, then returns for 5 units of time, and then drives the fifth student for 1 unit of time. | ```python
from collections import defaultdict
n, m = map(int, input().split())
r, p = [0] * n, defaultdict(list)
i = d = 0
while i < n - m:
for j in range(i, i + m):
t, x = map(int, input().split())
p[x].append(j)
d = max(t, d)
y = sorted(p.keys())
for x in y:
for j in p[x]: r[j] = d + x
d += 1 + len(p[x]) // 2
d += 2 * y[-1]
p.clear()
i += m
for j in range(i, n):
t, x = map(int, input().split())
p[x].append(j)
if p:
d = max(t, d)
y = sorted(p.keys())
for x in y:
for j in p[x]: r[j] = d + x
d += 1 + len(p[x]) // 2
print(' '.join(map(str, r)))
``` |
192_D. Demonstration | In the capital city of Berland, Bertown, demonstrations are against the recent election of the King of Berland. Berland opposition, led by Mr. Ovalny, believes that the elections were not fair enough and wants to organize a demonstration at one of the squares.
Bertown has n squares, numbered from 1 to n, they are numbered in the order of increasing distance between them and the city center. That is, square number 1 is central, and square number n is the farthest from the center. Naturally, the opposition wants to hold a meeting as close to the city center as possible (that is, they want an square with the minimum number).
There are exactly k (k < n) days left before the demonstration. Now all squares are free. But the Bertown city administration never sleeps, and the approval of an application for the demonstration threatens to become a very complex process. The process of approval lasts several days, but every day the following procedure takes place:
* The opposition shall apply to hold a demonstration at a free square (the one which isn't used by the administration).
* The administration tries to move the demonstration to the worst free square left. To do this, the administration organizes some long-term activities on the square, which is specified in the application of opposition. In other words, the administration starts using the square and it is no longer free. Then the administration proposes to move the opposition demonstration to the worst free square. If the opposition has applied for the worst free square then request is accepted and administration doesn't spend money. If the administration does not have enough money to organize an event on the square in question, the opposition's application is accepted. If administration doesn't have enough money to organize activity, then rest of administration's money spends and application is accepted
* If the application is not accepted, then the opposition can agree to the administration's proposal (that is, take the worst free square), or withdraw the current application and submit another one the next day. If there are no more days left before the meeting, the opposition has no choice but to agree to the proposal of City Hall. If application is accepted opposition can reject it. It means than opposition still can submit more applications later, but square remains free.
In order to organize an event on the square i, the administration needs to spend ai bourles. Because of the crisis the administration has only b bourles to confront the opposition. What is the best square that the opposition can take, if the administration will keep trying to occupy the square in question each time? Note that the administration's actions always depend only on the actions of the opposition.
Input
The first line contains two integers n and k — the number of squares and days left before the meeting, correspondingly (1 ≤ k < n ≤ 105).
The second line contains a single integer b — the number of bourles the administration has (1 ≤ b ≤ 1018).
The third line contains n space-separated integers ai — the sum of money, needed to organise an event on square i (1 ≤ ai ≤ 109).
Please, do not use the %lld specifier to read or write 64-bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.
Output
Print a single number — the minimum number of the square where the opposition can organize the demonstration.
Examples
Input
5 2
8
2 4 5 3 1
Output
2
Input
5 2
8
3 2 4 1 5
Output
5
Input
5 4
1000000000000000
5 4 3 2 1
Output
5
Note
In the first sample the opposition can act like this. On day one it applies for square 3. The administration has to organize an event there and end up with 3 bourles. If on the second day the opposition applies for square 2, the administration won't have the money to intervene.
In the second sample the opposition has only the chance for the last square. If its first move occupies one of the first four squares, the administration is left with at least 4 bourles, which means that next day it can use its next move to move the opposition from any square to the last one.
In the third sample administration has a lot of money, so opposition can occupy only last square. | ```python
from sys import stdin, stdout
n, k = map(int, stdin.readline().split())
value = int(stdin.readline())
prices = list(map(int, stdin.readline().split()))
used = {}
challengers = prices[:-1]
for i in range(n - 1):
challengers[i] = (challengers[i], i)
challengers.sort(reverse = True)
ind = challengers[k - 1][1]
cnt = 0
for i in range(k):
used[challengers[i][1]] = challengers[i][0]
cnt += challengers[i][0]
for i in range(n - 1):
if not i in used and value < cnt - used[ind] + prices[i]:
stdout.write(str(i + 1))
break
elif i in used and value < cnt:
stdout.write(str(i + 1))
break
else:
stdout.write(str(n))
``` |
216_D. Spider's Web | Paw the Spider is making a web. Web-making is a real art, Paw has been learning to do it his whole life. Let's consider the structure of the web.
<image>
There are n main threads going from the center of the web. All main threads are located in one plane and divide it into n equal infinite sectors. The sectors are indexed from 1 to n in the clockwise direction. Sectors i and i + 1 are adjacent for every i, 1 ≤ i < n. In addition, sectors 1 and n are also adjacent.
Some sectors have bridge threads. Each bridge connects the two main threads that make up this sector. The points at which the bridge is attached to the main threads will be called attachment points. Both attachment points of a bridge are at the same distance from the center of the web. At each attachment point exactly one bridge is attached. The bridges are adjacent if they are in the same sector, and there are no other bridges between them.
A cell of the web is a trapezoid, which is located in one of the sectors and is bounded by two main threads and two adjacent bridges. You can see that the sides of the cell may have the attachment points of bridges from adjacent sectors. If the number of attachment points on one side of the cell is not equal to the number of attachment points on the other side, it creates an imbalance of pulling forces on this cell and this may eventually destroy the entire web. We'll call such a cell unstable. The perfect web does not contain unstable cells.
Unstable cells are marked red in the figure. Stable cells are marked green.
Paw the Spider isn't a skillful webmaker yet, he is only learning to make perfect webs. Help Paw to determine the number of unstable cells in the web he has just spun.
Input
The first line contains integer n (3 ≤ n ≤ 1000) — the number of main threads.
The i-th of following n lines describe the bridges located in the i-th sector: first it contains integer ki (1 ≤ ki ≤ 105) equal to the number of bridges in the given sector. Then follow ki different integers pij (1 ≤ pij ≤ 105; 1 ≤ j ≤ ki). Number pij equals the distance from the attachment points of the j-th bridge of the i-th sector to the center of the web.
It is guaranteed that any two bridges between adjacent sectors are attached at a different distance from the center of the web. It is guaranteed that the total number of the bridges doesn't exceed 105.
Output
Print a single integer — the number of unstable cells in Paw the Spider's web.
Examples
Input
7
3 1 6 7
4 3 5 2 9
2 8 1
4 3 7 6 4
3 2 5 9
3 6 3 8
3 4 2 9
Output
6 | ```python
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
# from fractions import *
# from heapq import*
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz/'
M=1000000007
EPS=1e-6
def Ceil(a,b): return a//b+int(a%b>0)
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
n=Int()
sector=[]
for i in range(n):
sector.append(sorted(array()[1:]))
# for i in sector: print(*i)
# print()
ans=0
for cur in range(n):
aage=(cur+1)%n
peeche=(cur-1+n)%n
for i in range(1,len(sector[cur])):
l=sector[cur][i-1]
r=sector[cur][i]
left_count= bisect_left(sector[peeche],r) - bisect_right(sector[peeche],l)
right_count= bisect_left(sector[aage],r) - bisect_right(sector[aage],l)
# print(left_count,right_count)
ans+=(left_count!=right_count)
print(ans)
``` |
265_B. Roadside Trees (Simplified Edition) | Squirrel Liss loves nuts. There are n trees (numbered 1 to n from west to east) along a street and there is a delicious nut on the top of each tree. The height of the tree i is hi. Liss wants to eat all nuts.
Now Liss is on the root of the tree with the number 1. In one second Liss can perform one of the following actions:
* Walk up or down one unit on a tree.
* Eat a nut on the top of the current tree.
* Jump to the next tree. In this action the height of Liss doesn't change. More formally, when Liss is at height h of the tree i (1 ≤ i ≤ n - 1), she jumps to height h of the tree i + 1. This action can't be performed if h > hi + 1.
Compute the minimal time (in seconds) required to eat all nuts.
Input
The first line contains an integer n (1 ≤ n ≤ 105) — the number of trees.
Next n lines contains the height of trees: i-th line contains an integer hi (1 ≤ hi ≤ 104) — the height of the tree with the number i.
Output
Print a single integer — the minimal time required to eat all nuts in seconds.
Examples
Input
2
1
2
Output
5
Input
5
2
1
2
1
1
Output
14 | ```python
n = int(input())
l = []
for _ in range(n):
l.append(int(input()))
t = len(l)
current = 0
t+=l[0]-current
current = l[0]
for i in range(1,n):
if current<=l[i]:
t+=1+l[i]-current
current = l[i]
else:
t += 1+current-l[i]
current = l[i]
print(t)
``` |
289_B. Polo the Penguin and Matrix | Little penguin Polo has an n × m matrix, consisting of integers. Let's index the matrix rows from 1 to n from top to bottom and let's index the columns from 1 to m from left to right. Let's represent the matrix element on the intersection of row i and column j as aij.
In one move the penguin can add or subtract number d from some matrix element. Find the minimum number of moves needed to make all matrix elements equal. If the described plan is impossible to carry out, say so.
Input
The first line contains three integers n, m and d (1 ≤ n, m ≤ 100, 1 ≤ d ≤ 104) — the matrix sizes and the d parameter. Next n lines contain the matrix: the j-th integer in the i-th row is the matrix element aij (1 ≤ aij ≤ 104).
Output
In a single line print a single integer — the minimum number of moves the penguin needs to make all matrix elements equal. If that is impossible, print "-1" (without the quotes).
Examples
Input
2 2 2
2 4
6 8
Output
4
Input
1 2 7
6 7
Output
-1 | ```python
n,m,d=map(int,input().split())
x=[]
y=[]
for i in range(n):
a=list(map(int,input().split()))
y+=a
x.append(a)
y.sort()
e=y[(0+n*m-1)//2]
a=x[0][0]%d
count=0
ans=0
for i in x:
for j in range(len(i)):
if(i[j]%d!=a):
pass
else:
count+=1
ans+=(max(i[j],e)-min(i[j],e))//d
if(count==n*m):
print(ans)
else:
print(-1)
``` |
314_B. Sereja and Periods | Let's introduce the designation <image>, where x is a string, n is a positive integer and operation " + " is the string concatenation operation. For example, [abc, 2] = abcabc.
We'll say that string s can be obtained from string t, if we can remove some characters from string t and obtain string s. For example, strings ab and aсba can be obtained from string xacbac, and strings bx and aaa cannot be obtained from it.
Sereja has two strings, w = [a, b] and q = [c, d]. He wants to find such maximum integer p (p > 0), that [q, p] can be obtained from string w.
Input
The first line contains two integers b, d (1 ≤ b, d ≤ 107). The second line contains string a. The third line contains string c. The given strings are not empty and consist of lowercase English letters. Their lengths do not exceed 100.
Output
In a single line print an integer — the largest number p. If the required value of p doesn't exist, print 0.
Examples
Input
10 3
abab
bab
Output
3 | ```python
b, p = map(int, input().split())
s1 = input()
s2 = input()
cnt = [0] * len(s2)
nxt = [0] * len(s2)
for i in range(len(s2)):
pos = i
for j in range(len(s1)):
if s1[j] == s2[pos]:
pos += 1
if pos == len(s2):
cnt[i] += 1
pos = 0
nxt[i] = pos
ans = 0
poss = 0
for i in range(b):
ans += cnt[poss]
poss = nxt[poss]
print(ans // p)
``` |
430_D. Working out | Summer is coming! It's time for Iahub and Iahubina to work out, as they both want to look hot at the beach. The gym where they go is a matrix a with n lines and m columns. Let number a[i][j] represents the calories burned by performing workout at the cell of gym in the i-th line and the j-th column.
Iahub starts with workout located at line 1 and column 1. He needs to finish with workout a[n][m]. After finishing workout a[i][j], he can go to workout a[i + 1][j] or a[i][j + 1]. Similarly, Iahubina starts with workout a[n][1] and she needs to finish with workout a[1][m]. After finishing workout from cell a[i][j], she goes to either a[i][j + 1] or a[i - 1][j].
There is one additional condition for their training. They have to meet in exactly one cell of gym. At that cell, none of them will work out. They will talk about fast exponentiation (pretty odd small talk) and then both of them will move to the next workout.
If a workout was done by either Iahub or Iahubina, it counts as total gain. Please plan a workout for Iahub and Iahubina such as total gain to be as big as possible. Note, that Iahub and Iahubina can perform workouts with different speed, so the number of cells that they use to reach meet cell may differs.
Input
The first line of the input contains two integers n and m (3 ≤ n, m ≤ 1000). Each of the next n lines contains m integers: j-th number from i-th line denotes element a[i][j] (0 ≤ a[i][j] ≤ 105).
Output
The output contains a single number — the maximum total gain possible.
Examples
Input
3 3
100 100 100
100 1 100
100 100 100
Output
800
Note
Iahub will choose exercises a[1][1] → a[1][2] → a[2][2] → a[3][2] → a[3][3]. Iahubina will choose exercises a[3][1] → a[2][1] → a[2][2] → a[2][3] → a[1][3]. | ```python
n,m=map(int,input().split())
a=[]
for i in range(n):a.append(list(map(int,input().split())))
dpa=[[[0,0] for i in range(m+2)] for i in range(n+2)]
dpb=[[[0,0] for i in range(m+2)] for i in range(n+2)]
ans=0
for i in range(1,n+1):
for j in range(1,m+1):
dpa[i][j][0]=max(dpa[i-1][j][0],dpa[i][j-1][0])+a[i-1][j-1]
dpa[n+1-i][m+1-j][1]=max(dpa[n+2-i][m+1-j][1],dpa[n+1-i][m+2-j][1])+a[n-i][m-j]
for i in range(n,0,-1):
for j in range(1,m+1):
dpb[i][j][0]=max(dpb[i+1][j][0],dpb[i][j-1][0])+a[i-1][j-1]
dpb[n+1-i][m+1-j][1]=max(dpb[n-i][m+1-j][1],dpb[n+1-i][m+2-j][1])+a[n-i][m-j]
for i in range(2,n):
for j in range(2,m):
x=dpa[i-1][j][0]+dpa[i+1][j][1]+dpb[i][j-1][0]+dpb[i][j+1][1]
y=dpb[i+1][j][0]+dpb[i-1][j][1]+dpa[i][j-1][0]+dpa[i][j+1][1]
ans=max(ans,x,y)
print(ans)
``` |
453_A. Little Pony and Expected Maximum | Twilight Sparkle was playing Ludo with her friends Rainbow Dash, Apple Jack and Flutter Shy. But she kept losing. Having returned to the castle, Twilight Sparkle became interested in the dice that were used in the game.
The dice has m faces: the first face of the dice contains a dot, the second one contains two dots, and so on, the m-th face contains m dots. Twilight Sparkle is sure that when the dice is tossed, each face appears with probability <image>. Also she knows that each toss is independent from others. Help her to calculate the expected maximum number of dots she could get after tossing the dice n times.
Input
A single line contains two integers m and n (1 ≤ m, n ≤ 105).
Output
Output a single real number corresponding to the expected maximum. The answer will be considered correct if its relative or absolute error doesn't exceed 10 - 4.
Examples
Input
6 1
Output
3.500000000000
Input
6 3
Output
4.958333333333
Input
2 2
Output
1.750000000000
Note
Consider the third test example. If you've made two tosses:
1. You can get 1 in the first toss, and 2 in the second. Maximum equals to 2.
2. You can get 1 in the first toss, and 1 in the second. Maximum equals to 1.
3. You can get 2 in the first toss, and 1 in the second. Maximum equals to 2.
4. You can get 2 in the first toss, and 2 in the second. Maximum equals to 2.
The probability of each outcome is 0.25, that is expectation equals to:
<image>
You can read about expectation using the following link: http://en.wikipedia.org/wiki/Expected_value | ```python
def main():
m, n = map(int, input().split())
print(sum((i + 1) * (((i + 1) / m) ** n - (i / m) ** n) for i in range(m)))
if __name__ == '__main__':
main()
``` |
523_B. Mean Requests | In this problem you will have to deal with a real algorithm that is used in the VK social network.
As in any other company that creates high-loaded websites, the VK developers have to deal with request statistics regularly. An important indicator reflecting the load of the site is the mean number of requests for a certain period of time of T seconds (for example, T = 60 seconds = 1 min and T = 86400 seconds = 1 day). For example, if this value drops dramatically, that shows that the site has access problem. If this value grows, that may be a reason to analyze the cause for the growth and add more servers to the website if it is really needed.
However, even such a natural problem as counting the mean number of queries for some period of time can be a challenge when you process the amount of data of a huge social network. That's why the developers have to use original techniques to solve problems approximately, but more effectively at the same time.
Let's consider the following formal model. We have a service that works for n seconds. We know the number of queries to this resource at at each moment of time t (1 ≤ t ≤ n). Let's formulate the following algorithm of calculating the mean with exponential decay. Let c be some real number, strictly larger than one.
// setting this constant value correctly can adjust
// the time range for which statistics will be calculated
double c = some constant value;
// as the result of the algorithm's performance this variable will contain
// the mean number of queries for the last
// T seconds by the current moment of time
double mean = 0.0;
for t = 1..n: // at each second, we do the following:
// at is the number of queries that came at the last second;
mean = (mean + at / T) / c;
Thus, the mean variable is recalculated each second using the number of queries that came at that second. We can make some mathematical calculations and prove that choosing the value of constant c correctly will make the value of mean not very different from the real mean value ax at t - T + 1 ≤ x ≤ t.
The advantage of such approach is that it only uses the number of requests at the current moment of time and doesn't require storing the history of requests for a large time range. Also, it considers the recent values with the weight larger than the weight of the old ones, which helps to react to dramatic change in values quicker.
However before using the new theoretical approach in industrial programming, there is an obligatory step to make, that is, to test its credibility practically on given test data sets. Your task is to compare the data obtained as a result of the work of an approximate algorithm to the real data.
You are given n values at, integer T and real number c. Also, you are given m moments pj (1 ≤ j ≤ m), where we are interested in the mean value of the number of queries for the last T seconds. Implement two algorithms. The first one should calculate the required value by definition, i.e. by the formula <image>. The second algorithm should calculate the mean value as is described above. Print both values and calculate the relative error of the second algorithm by the formula <image>, where approx is the approximate value, obtained by the second algorithm, and real is the exact value obtained by the first algorithm.
Input
The first line contains integer n (1 ≤ n ≤ 2·105), integer T (1 ≤ T ≤ n) and real number c (1 < c ≤ 100) — the time range when the resource should work, the length of the time range during which we need the mean number of requests and the coefficient c of the work of approximate algorithm. Number c is given with exactly six digits after the decimal point.
The next line contains n integers at (1 ≤ at ≤ 106) — the number of queries to the service at each moment of time.
The next line contains integer m (1 ≤ m ≤ n) — the number of moments of time when we are interested in the mean number of queries for the last T seconds.
The next line contains m integers pj (T ≤ pj ≤ n), representing another moment of time for which we need statistics. Moments pj are strictly increasing.
Output
Print m lines. The j-th line must contain three numbers real, approx and error, where:
* <image> is the real mean number of queries for the last T seconds;
* approx is calculated by the given algorithm and equals mean at the moment of time t = pj (that is, after implementing the pj-th iteration of the cycle);
* <image> is the relative error of the approximate algorithm.
The numbers you printed will be compared to the correct numbers with the relative or absolute error 10 - 4. It is recommended to print the numbers with at least five digits after the decimal point.
Examples
Input
1 1 2.000000
1
1
1
Output
1.000000 0.500000 0.500000
Input
11 4 1.250000
9 11 7 5 15 6 6 6 6 6 6
8
4 5 6 7 8 9 10 11
Output
8.000000 4.449600 0.443800
9.500000 6.559680 0.309507
8.250000 6.447744 0.218455
8.000000 6.358195 0.205226
8.250000 6.286556 0.237993
6.000000 6.229245 0.038207
6.000000 6.183396 0.030566
6.000000 6.146717 0.024453
Input
13 4 1.250000
3 3 3 3 3 20 3 3 3 3 3 3 3
10
4 5 6 7 8 9 10 11 12 13
Output
3.000000 1.771200 0.409600
3.000000 2.016960 0.327680
7.250000 5.613568 0.225715
7.250000 5.090854 0.297813
7.250000 4.672684 0.355492
7.250000 4.338147 0.401635
3.000000 4.070517 0.356839
3.000000 3.856414 0.285471
3.000000 3.685131 0.228377
3.000000 3.548105 0.182702 | ```python
__author__ = 'ruckus'
n, T, c = input().split()
n = int(n)
T = int(T)
c = float(c)
a = list(map(int, input().split()))
m = int(input())
q = list(map(int, input().split()))
res_a = 0
real = 0
maxi_q = max(q)
q_n = 0
for i in range(q[-1]):
res_a = (res_a + a[i] / T) / c
real += a[i]
if i >= T:
real -= a[i-T]
if q[q_n] == i+1:
q_n += 1
r = real/T
print(r, res_a, abs(r-res_a)/r)
# Made By Mostafa_Khaled
``` |
549_H. Degenerate Matrix | The determinant of a matrix 2 × 2 is defined as follows:
<image>
A matrix is called degenerate if its determinant is equal to zero.
The norm ||A|| of a matrix A is defined as a maximum of absolute values of its elements.
You are given a matrix <image>. Consider any degenerate matrix B such that norm ||A - B|| is minimum possible. Determine ||A - B||.
Input
The first line contains two integers a and b (|a|, |b| ≤ 109), the elements of the first row of matrix A.
The second line contains two integers c and d (|c|, |d| ≤ 109) the elements of the second row of matrix A.
Output
Output a single real number, the minimum possible value of ||A - B||. Your answer is considered to be correct if its absolute or relative error does not exceed 10 - 9.
Examples
Input
1 2
3 4
Output
0.2000000000
Input
1 0
0 1
Output
0.5000000000
Note
In the first sample matrix B is <image>
In the second sample matrix B is <image> | ```python
A,B,C,D=map(int,(input()+' '+input()).split());k=max(map(abs,[A+B+C+D,A+B-C-D,A-B+C-D,A-B-C+D]))+1e-9;print(abs(A*D-B*C)/k)
``` |
576_A. Vasya and Petya's Game | Vasya and Petya are playing a simple game. Vasya thought of number x between 1 and n, and Petya tries to guess the number.
Petya can ask questions like: "Is the unknown number divisible by number y?".
The game is played by the following rules: first Petya asks all the questions that interest him (also, he can ask no questions), and then Vasya responds to each question with a 'yes' or a 'no'. After receiving all the answers Petya should determine the number that Vasya thought of.
Unfortunately, Petya is not familiar with the number theory. Help him find the minimum number of questions he should ask to make a guaranteed guess of Vasya's number, and the numbers yi, he should ask the questions about.
Input
A single line contains number n (1 ≤ n ≤ 103).
Output
Print the length of the sequence of questions k (0 ≤ k ≤ n), followed by k numbers — the questions yi (1 ≤ yi ≤ n).
If there are several correct sequences of questions of the minimum length, you are allowed to print any of them.
Examples
Input
4
Output
3
2 4 3
Input
6
Output
4
2 4 3 5
Note
The sequence from the answer to the first sample test is actually correct.
If the unknown number is not divisible by one of the sequence numbers, it is equal to 1.
If the unknown number is divisible by 4, it is 4.
If the unknown number is divisible by 3, then the unknown number is 3.
Otherwise, it is equal to 2. Therefore, the sequence of questions allows you to guess the unknown number. It can be shown that there is no correct sequence of questions of length 2 or shorter. | ```python
def input_ints():
return list(map(int, input().split()))
def main():
n = int(input())
ans = []
for x in range(2, n + 1):
s = set()
xx = x
for y in range(2, n + 1):
while xx % y == 0:
xx /= y
s.add(y)
if len(s) == 1:
ans.append(x)
print(len(ans))
print(' '.join(str(x) for x in ans))
if __name__ == '__main__':
main()
``` |
598_E. Chocolate Bar | You have a rectangular chocolate bar consisting of n × m single squares. You want to eat exactly k squares, so you may need to break the chocolate bar.
In one move you can break any single rectangular piece of chocolate in two rectangular pieces. You can break only by lines between squares: horizontally or vertically. The cost of breaking is equal to square of the break length.
For example, if you have a chocolate bar consisting of 2 × 3 unit squares then you can break it horizontally and get two 1 × 3 pieces (the cost of such breaking is 32 = 9), or you can break it vertically in two ways and get two pieces: 2 × 1 and 2 × 2 (the cost of such breaking is 22 = 4).
For several given values n, m and k find the minimum total cost of breaking. You can eat exactly k squares of chocolate if after all operations of breaking there is a set of rectangular pieces of chocolate with the total size equal to k squares. The remaining n·m - k squares are not necessarily form a single rectangular piece.
Input
The first line of the input contains a single integer t (1 ≤ t ≤ 40910) — the number of values n, m and k to process.
Each of the next t lines contains three integers n, m and k (1 ≤ n, m ≤ 30, 1 ≤ k ≤ min(n·m, 50)) — the dimensions of the chocolate bar and the number of squares you want to eat respectively.
Output
For each n, m and k print the minimum total cost needed to break the chocolate bar, in order to make it possible to eat exactly k squares.
Examples
Input
4
2 2 1
2 2 3
2 2 2
2 2 4
Output
5
5
4
0
Note
In the first query of the sample one needs to perform two breaks:
* to split 2 × 2 bar into two pieces of 2 × 1 (cost is 22 = 4),
* to split the resulting 2 × 1 into two 1 × 1 pieces (cost is 12 = 1).
In the second query of the sample one wants to eat 3 unit squares. One can use exactly the same strategy as in the first query of the sample. | ```python
d = [0] * 49011
def g(n, m, k):
t = 1e9
for i in range(1, m // 2 + 1):
for j in range(k + 1):
t = min(t, f(n, m - i, k - j) + f(n, i, j))
return n * n + t
def f(n, m, k):
if n > m: n, m = m, n
k = min(k, n * m - k)
if k == 0: return 0
if k < 0: return 1e9
q = n + 31 * m + 961 * k
if d[q] == 0: d[q] = min(g(n, m, k), g(m, n, k))
return d[q]
for q in range(int(input())):
n, m, k = map(int, input().split())
print(f(n, m, k))
``` |
61_C. Capture Valerian | It's now 260 AD. Shapur, being extremely smart, became the King of Persia. He is now called Shapur, His majesty King of kings of Iran and Aniran.
Recently the Romans declared war on Persia. They dreamed to occupy Armenia. In the recent war, the Romans were badly defeated. Now their senior army general, Philip is captured by Shapur and Shapur is now going to capture Valerian, the Roman emperor.
Being defeated, the cowardly Valerian hid in a room at the top of one of his castles. To capture him, Shapur has to open many doors. Fortunately Valerian was too scared to make impenetrable locks for the doors.
Each door has 4 parts. The first part is an integer number a. The second part is either an integer number b or some really odd sign which looks like R. The third one is an integer c and the fourth part is empty! As if it was laid for writing something. Being extremely gifted, after opening the first few doors, Shapur found out the secret behind the locks.
c is an integer written in base a, to open the door we should write it in base b. The only bad news is that this R is some sort of special numbering system that is used only in Roman empire, so opening the doors is not just a piece of cake!
Here's an explanation of this really weird number system that even doesn't have zero:
Roman numerals are based on seven symbols: a stroke (identified with the letter I) for a unit, a chevron (identified with the letter V) for a five, a cross-stroke (identified with the letter X) for a ten, a C (identified as an abbreviation of Centum) for a hundred, etc.:
* I=1
* V=5
* X=10
* L=50
* C=100
* D=500
* M=1000
Symbols are iterated to produce multiples of the decimal (1, 10, 100, 1, 000) values, with V, L, D substituted for a multiple of five, and the iteration continuing: I 1, II 2, III 3, V 5, VI 6, VII 7, etc., and the same for other bases: X 10, XX 20, XXX 30, L 50, LXXX 80; CC 200, DCC 700, etc. At the fourth and ninth iteration, a subtractive principle must be employed, with the base placed before the higher base: IV 4, IX 9, XL 40, XC 90, CD 400, CM 900.
Also in bases greater than 10 we use A for 10, B for 11, etc.
Help Shapur capture Valerian and bring peace back to Persia, especially Armenia.
Input
The first line contains two integers a and b (2 ≤ a, b ≤ 25). Only b may be replaced by an R which indicates Roman numbering system.
The next line contains a single non-negative integer c in base a which may contain leading zeros but its length doesn't exceed 103.
It is guaranteed that if we have Roman numerals included the number would be less than or equal to 300010 and it won't be 0. In any other case the number won't be greater than 101510.
Output
Write a single line that contains integer c in base b. You must omit leading zeros.
Examples
Input
10 2
1
Output
1
Input
16 R
5
Output
V
Input
5 R
4
Output
IV
Input
2 2
1111001
Output
1111001
Input
12 13
A
Output
A
Note
You can find more information about roman numerals here: http://en.wikipedia.org/wiki/Roman_numerals | ```python
n, m = input().split()
b = input()
if b.isdigit() and int(b) == 0:
print(int(b))
elif n == m:
print(b)
else:
n= int(n)
st1 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]
st2 =['0', '1','2','3','4','5','6','7','8','9','A','B','C','D', 'E', 'F','G','H','I','J','K','L','M','N','O','P','Q']
s = str(b)
l = len(s)
deci = 0
j = 0
for i in range(l-1, -1, -1):
ind = st2.index(s[j])
deci += n**i * (ind)
j += 1
if m == 'R':
arr1 = [1,4,5,9,10, 40, 50, 90, 100, 400, 500, 900, 1000]
arr2 = ['I', 'IV','V', 'IX', 'X','XL', 'L', 'XC','C', 'CD','D', 'CM', 'M']
Roman = ''
for i in range(len(arr1)-1, -1, -1):
if deci >= arr1[i]:
Roman += (deci // arr1[i]) * arr2[i]
deci = deci % arr1[i]
print(Roman)
else:
m = int(m)
convert = ''
while deci > 0:
t = deci % m
convert += st2[t]
deci = deci // m
convert = convert[::-1]
print(convert)
``` |
63_B. Settlers' Training | In a strategic computer game "Settlers II" one has to build defense structures to expand and protect the territory. Let's take one of these buildings. At the moment the defense structure accommodates exactly n soldiers. Within this task we can assume that the number of soldiers in the defense structure won't either increase or decrease.
Every soldier has a rank — some natural number from 1 to k. 1 stands for a private and k stands for a general. The higher the rank of the soldier is, the better he fights. Therefore, the player profits from having the soldiers of the highest possible rank.
To increase the ranks of soldiers they need to train. But the soldiers won't train for free, and each training session requires one golden coin. On each training session all the n soldiers are present.
At the end of each training session the soldiers' ranks increase as follows. First all the soldiers are divided into groups with the same rank, so that the least possible number of groups is formed. Then, within each of the groups where the soldiers below the rank k are present, exactly one soldier increases his rank by one.
You know the ranks of all n soldiers at the moment. Determine the number of golden coins that are needed to increase the ranks of all the soldiers to the rank k.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 100). They represent the number of soldiers and the number of different ranks correspondingly. The second line contains n numbers in the non-decreasing order. The i-th of them, ai, represents the rank of the i-th soldier in the defense building (1 ≤ i ≤ n, 1 ≤ ai ≤ k).
Output
Print a single integer — the number of golden coins needed to raise all the soldiers to the maximal rank.
Examples
Input
4 4
1 2 2 3
Output
4
Input
4 3
1 1 1 1
Output
5
Note
In the first example the ranks will be raised in the following manner:
1 2 2 3 → 2 2 3 4 → 2 3 4 4 → 3 4 4 4 → 4 4 4 4
Thus totals to 4 training sessions that require 4 golden coins. | ```python
"""
Oh, Grantors of Dark Disgrace,
Do Not Wake Me Again.
"""
from collections import Counter
n, k = map(int, input().split())
cc = Counter(map(int, input().split()))
coins = 0
while cc[k] != n:
t = 0
for i in range(1, k):
if t+1 <= cc[i]:
cc[i] -= 1
cc[i+1] += 1
t = 1
else:
t = 0
coins += 1
print(coins)
``` |
667_E. Chain Reaction | Group of Berland scientists, with whom you have a close business relationship, makes a research in the area of peaceful nuclear energy. In particular, they found that a group of four nanobots, placed on a surface of a plate, can run a powerful chain reaction under certain conditions.
To be precise, researchers introduced a rectangular Cartesian coordinate system on a flat plate and selected four distinct points with integer coordinates where bots will be placed initially. Next each bot will be assigned with one of the four directions (up, down, left or right) parallel to the coordinate axes. After that, each bot is shifted by an integer distance (which may be different for different bots) along its direction. The chain reaction starts, if the bots are in the corners of a square with positive area with sides parallel to the coordinate axes. Each corner of the square must contain one nanobot. This reaction will be stronger, if bots spend less time to move. We can assume that bots move with unit speed. In other words, the lesser is the maximum length traveled by bot, the stronger is reaction.
Scientists have prepared a set of plates and selected starting position for the bots for each plate. Now they ask you to assign the direction for each bot to move after landing such that the maximum length traveled by bot is as small as possible.
Input
The first line contains an integer number t (1 ≤ t ≤ 50) — the number of plates.
t descriptions of plates follow. A description of each plate consists of four lines. Each line consists of a pair of integers numbers xi, yi ( - 108 ≤ xi, yi ≤ 108) — coordinates of the next bot. All bots are in different locations.
Note, though, the problem can include several records in one test, you can hack other people's submissions only with the test of one plate, i.e. parameter t in a hack test should be equal to 1.
Output
Print answers for all plates separately. First goes a single integer number in a separate line. If scientists have made an unfortunate mistake and nanobots are not able to form the desired square, print -1. Otherwise, print the minimum possible length of the longest bot's path.
If a solution exists, in the next four lines print two integer numbers — positions of each bot after moving. Print bots' positions in the order they are specified in the input data.
If there are multiple solution, you can print any of them.
Examples
Input
2
1 1
1 -1
-1 1
-1 -1
1 1
2 2
4 4
6 6
Output
0
1 1
1 -1
-1 1
-1 -1
-1 | ```python
import sys
sys.stderr = sys.stdout
from collections import namedtuple
Bot = namedtuple('Bot', ('x', 'y', 'i'))
def yxi(bot):
return bot.y, bot.x, bot.i
def reaction1(B, V):
Bv = sorted(B[i] for i in range(4) if V[i])
Bh = sorted((B[i] for i in range(4) if not V[i]), key=yxi)
S = [None] * 4
if len(Bv) == 0:
if not (Bh[0].y == Bh[1].y < Bh[2].y == Bh[3].y):
return None, None
y0 = Bh[0].y
y1 = Bh[2].y
d = y1 - y0
X = [Bh[0].x, Bh[1].x - d, Bh[2].x, Bh[3].x - d]
Xmin = min(X)
Xmax = max(X)
x0 = (Xmin + Xmax) // 2
l = Xmax - x0
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x0 + d, y0
S[Bh[2].i] = x0, y1
S[Bh[3].i] = x0 + d, y1
return l, S
elif len(Bv) == 1:
if Bh[0].y == Bh[1].y < Bh[2].y:
y0 = Bh[0].y
y1 = Bh[2].y
x0 = Bv[0].x
d = y1 - y0
l0 = abs(Bv[0].y - y1)
l1 = max(abs(x0 - Bh[0].x), abs(x0 + d - Bh[1].x),
l0, abs(x0 + d - Bh[2].x))
l2 = max(abs(x0 - d - Bh[0].x), abs(x0 - Bh[1].x),
abs(x0 - d - Bh[2].x), l0)
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x0 + d, y0
S[Bv[0].i] = x0, y1
S[Bh[2].i] = x0 + d, y1
else:
l = l2
S[Bh[0].i] = x0 - d, y0
S[Bh[1].i] = x0, y0
S[Bh[2].i] = x0 - d, y1
S[Bv[0].i] = x0, y1
return l, S
elif Bh[0].y < Bh[1].y == Bh[2].y:
y0 = Bh[0].y
y1 = Bh[2].y
x0 = Bv[0].x
d = y1 - y0
l0 = abs(Bv[0].y - y0)
l1 = max(l0, abs(x0 + d - Bh[0].x),
abs(x0 - Bh[1].x), abs(x0 + d - Bh[2].x))
l2 = max(abs(x0 - d - Bh[0].x), l0,
abs(x0 - d - Bh[1].x), abs(x0 - Bh[2].x))
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bh[0].i] = x0 + d, y0
S[Bh[1].i] = x0, y1
S[Bh[2].i] = x0 + d, y1
else:
l = l2
S[Bh[0].i] = x0 - d, y0
S[Bv[0].i] = x0, y0
S[Bh[1].i] = x0 - d, y1
S[Bh[2].i] = x0, y1
return l, S
else:
return None, None
elif len(Bv) == 2:
if Bv[0].x < Bv[1].x and Bh[0].y < Bh[1].y:
x0 = Bv[0].x
x1 = Bv[1].x
y0 = Bh[0].y
y1 = Bh[1].y
if x1 - x0 != y1 - y0:
return None, None
l1 = max(abs(Bh[0].x - x0), abs(Bv[0].y - y1),
abs(Bh[1].x - x1), abs(Bv[1].y - y0))
l2 = max(abs(Bh[0].x - x1), abs(Bv[0].y - y0),
abs(Bh[1].x - x0), abs(Bv[1].y - y1))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y1
S[Bv[0].i] = x0, y1
S[Bv[1].i] = x1, y0
else:
l = l2
S[Bh[0].i] = x1, y0
S[Bh[1].i] = x0, y1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x1, y1
return l, S
elif Bv[0].x != Bv[1].x:
x0 = Bv[0].x
x1 = Bv[1].x
y0 = Bh[0].y
d = x1 - x0
lh = max(abs(Bh[0].x - x0), abs(Bh[1].x - x1))
l1 = max(lh, abs(y0 - d - Bv[0].y), abs(y0 - d - Bv[1].y))
l2 = max(lh, abs(y0 + d - Bv[0].y), abs(y0 + d - Bv[1].y))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y0
S[Bv[0].i] = x0, y0 - d
S[Bv[1].i] = x1, y0 - d
else:
l = l2
S[Bh[0].i] = x0, y0
S[Bh[1].i] = x1, y0
S[Bv[0].i] = x0, y0 + d
S[Bv[1].i] = x1, y0 + d
return l, S
elif Bh[0].y != Bh[1].y:
y0 = Bh[0].y
y1 = Bh[1].y
x0 = Bv[0].x
d = y1 - y0
lh = max(abs(Bv[0].y - y0), abs(Bv[1].y - y1))
l1 = max(lh, abs(x0 - d - Bh[0].x), abs(x0 - d - Bh[1].x))
l2 = max(lh, abs(x0 + d - Bh[0].x), abs(x0 + d - Bh[1].x))
S = [None] * 4
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y1
S[Bh[0].i] = x0 - d, y0
S[Bh[1].i] = x0 - d, y1
else:
l = l2
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y1
S[Bh[0].i] = x0 + d, y0
S[Bh[1].i] = x0 + d, y1
return l, S
else:
return None, None
elif len(Bv) == 3:
if Bv[0].x == Bv[1].x < Bv[2].x:
x0 = Bv[0].x
x1 = Bv[2].x
y0 = Bh[0].y
d = x1 - x0
l0 = abs(Bh[0].x - x1)
l1 = max(abs(y0 - Bv[0].y), abs(y0 + d - Bv[1].y),
l0, abs(y0 + d - Bv[2].y))
l2 = max(abs(y0 - d - Bv[0].y), abs(y0 - Bv[1].y),
abs(y0 - d - Bv[2].y), l0)
if l1 <= l2:
l = l1
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y0 + d
S[Bh[0].i] = x1, y0
S[Bv[2].i] = x1, y0 + d
else:
l = l2
S[Bv[0].i] = x0, y0 - d
S[Bv[1].i] = x0, y0
S[Bv[2].i] = x1, y0 - d
S[Bh[0].i] = x1, y0
return l, S
elif Bv[0].x < Bv[1].x == Bv[2].x:
x0 = Bv[0].x
x1 = Bv[2].x
y0 = Bh[0].y
d = x1 - x0
l0 = abs(Bh[0].x - x0)
l1 = max(l0, abs(y0 + d - Bv[0].y),
abs(y0 - Bv[1].y), abs(y0 + d - Bv[2].y))
l2 = max(abs(y0 - d - Bv[0].y), l0,
abs(y0 - d - Bv[1].y), abs(y0 - Bv[2].y))
if l1 <= l2:
l = l1
S[Bh[0].i] = x0, y0
S[Bv[0].i] = x0, y0 + d
S[Bv[1].i] = x1, y0
S[Bv[2].i] = x1, y0 + d
else:
l = l2
S[Bv[0].i] = x0, y0 - d
S[Bh[0].i] = x0, y0
S[Bv[1].i] = x1, y0 - d
S[Bv[2].i] = x1, y0
return l, S
else:
return None, None
elif len(Bv) == 4:
if not (Bv[0].x == Bv[1].x < Bv[2].x == Bv[3].x):
return None, None
x0 = Bv[0].x
x1 = Bv[2].x
d = x1 - x0
Y = [Bv[0].y, Bv[1].y - d, Bv[2].y, Bv[3].y - d]
Ymin = min(Y)
Ymax = max(Y)
y0 = (Ymin + Ymax) // 2
l = Ymax - y0
S[Bv[0].i] = x0, y0
S[Bv[1].i] = x0, y0 + d
S[Bv[2].i] = x1, y0
S[Bv[3].i] = x1, y0 + d
return l, S
def reaction(B):
l = None
S = None
for v0 in (True, False):
for v1 in (True, False):
for v2 in (True, False):
for v3 in (True, False):
l1, S1 = reaction1(B, (v0, v1, v2, v3))
if l1 is not None and (l is None or l1 < l):
l = l1
S = S1
return l, S
def readb(i):
x, y = readinti()
return Bot(x, y, i)
def main():
t = readint()
L = []
for _ in range(t):
B = [readb(i) for i in range(4)]
l, S = reaction(B)
if l is None:
L.append('-1')
else:
L.append(str(l))
L.extend(f'{b1} {b2}' for b1, b2 in S)
print('\n'.join(L))
##########
def readint():
return int(input())
def readinti():
return map(int, input().split())
def readintt():
return tuple(readinti())
def readintl():
return list(readinti())
def readinttl(k):
return [readintt() for _ in range(k)]
def readintll(k):
return [readintl() for _ in range(k)]
def log(*args, **kwargs):
print(*args, **kwargs, file=sys.__stderr__)
if __name__ == '__main__':
main()
``` |
714_B. Filya and Homework | Today, hedgehog Filya went to school for the very first time! Teacher gave him a homework which Filya was unable to complete without your help.
Filya is given an array of non-negative integers a1, a2, ..., an. First, he pick an integer x and then he adds x to some elements of the array (no more than once), subtract x from some other elements (also, no more than once) and do no change other elements. He wants all elements of the array to be equal.
Now he wonders if it's possible to pick such integer x and change some elements of the array using this x in order to make all elements equal.
Input
The first line of the input contains an integer n (1 ≤ n ≤ 100 000) — the number of integers in the Filya's array. The second line contains n integers a1, a2, ..., an (0 ≤ ai ≤ 109) — elements of the array.
Output
If it's impossible to make all elements of the array equal using the process given in the problem statement, then print "NO" (without quotes) in the only line of the output. Otherwise print "YES" (without quotes).
Examples
Input
5
1 3 3 2 1
Output
YES
Input
5
1 2 3 4 5
Output
NO
Note
In the first sample Filya should select x = 1, then add it to the first and the last elements of the array and subtract from the second and the third elements. | ```python
n=int(input())
s=set()
L=[ int(x) for x in input().split() ]
for i in L :
s.add(i)
if ( len(s) > 3 ) :
print("NO")
elif (len(s) == 1 or len(s) == 2 ) :
print("YES")
else :
L=[]
for i in s :
L.append(i)
L.sort()
a,b,c = L[0], L[1], L[2]
if ( b-a == c-b ):
print("YES")
else :
print("NO")
``` |
734_E. Anton and Tree | Anton is growing a tree in his garden. In case you forgot, the tree is a connected acyclic undirected graph.
There are n vertices in the tree, each of them is painted black or white. Anton doesn't like multicolored trees, so he wants to change the tree such that all vertices have the same color (black or white).
To change the colors Anton can use only operations of one type. We denote it as paint(v), where v is some vertex of the tree. This operation changes the color of all vertices u such that all vertices on the shortest path from v to u have the same color (including v and u). For example, consider the tree
<image>
and apply operation paint(3) to get the following:
<image>
Anton is interested in the minimum number of operation he needs to perform in order to make the colors of all vertices equal.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 200 000) — the number of vertices in the tree.
The second line contains n integers colori (0 ≤ colori ≤ 1) — colors of the vertices. colori = 0 means that the i-th vertex is initially painted white, while colori = 1 means it's initially painted black.
Then follow n - 1 line, each of them contains a pair of integers ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi) — indices of vertices connected by the corresponding edge. It's guaranteed that all pairs (ui, vi) are distinct, i.e. there are no multiple edges.
Output
Print one integer — the minimum number of operations Anton has to apply in order to make all vertices of the tree black or all vertices of the tree white.
Examples
Input
11
0 0 0 1 1 0 1 0 0 1 1
1 2
1 3
2 4
2 5
5 6
5 7
3 8
3 9
3 10
9 11
Output
2
Input
4
0 0 0 0
1 2
2 3
3 4
Output
0
Note
In the first sample, the tree is the same as on the picture. If we first apply operation paint(3) and then apply paint(6), the tree will become completely black, so the answer is 2.
In the second sample, the tree is already white, so there is no need to apply any operations and the answer is 0. | ```python
def main():
n = int(input())
colors = input()[::2]
dsu = list(range(n))
edges = [[] for _ in range(n)]
for _ in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
if colors[u] == colors[v]:
a, b = dsu[u], dsu[v]
while a != dsu[a]:
a = dsu[a]
while b != dsu[b]:
b = dsu[b]
if a < b:
dsu[b] = dsu[v] = a
else:
dsu[a] = dsu[u] = b
else:
edges[u].append(v)
for u, v in enumerate(dsu):
dsu[u] = dsu[v]
d = {u: [] for u, v in enumerate(dsu) if u == v}
for u, e in enumerate(edges):
for v in e:
d[dsu[u]].append(dsu[v])
d[dsu[v]].append(dsu[u])
def bfs(x):
nxt, visited, t = [x], set(), 0
while nxt:
t += 1
cur, nxt = nxt, []
for x in cur:
visited.add(x)
for y in d[x]:
if y not in visited:
nxt.append(y)
return t, cur[0]
print(bfs(bfs(0)[1])[0] // 2)
if __name__ == '__main__':
main()
``` |
803_B. Distances to Zero | You are given the array of integer numbers a0, a1, ..., an - 1. For each element find the distance to the nearest zero (to the element which equals to zero). There is at least one zero element in the given array.
Input
The first line contains integer n (1 ≤ n ≤ 2·105) — length of the array a. The second line contains integer elements of the array separated by single spaces ( - 109 ≤ ai ≤ 109).
Output
Print the sequence d0, d1, ..., dn - 1, where di is the difference of indices between i and nearest j such that aj = 0. It is possible that i = j.
Examples
Input
9
2 1 0 3 0 0 3 2 4
Output
2 1 0 1 0 0 1 2 3
Input
5
0 1 2 3 4
Output
0 1 2 3 4
Input
7
5 6 0 1 -2 3 4
Output
2 1 0 1 2 3 4 | ```python
import sys
n = int(sys.stdin.readline())
a = sys.stdin.readline().strip().split()
def findDistancesToZero(n,a):
pos_zero_left = a.index('0')
pos_zero_right = a.index('0')
pos = 0
positions = ''
while pos<n:
worked = False
while pos<=pos_zero_right:
print(str(min(abs(pos-pos_zero_left),abs(pos-pos_zero_right))),end=' ')
pos+=1
worked = True
pos_zero_left = pos_zero_right
try:
pos_zero_right = a.index('0',pos)
except:
pos_zero_right = pos_zero_left
False
if worked:
pos-=1
if pos_zero_left == pos_zero_right:
pos+=1
while pos<n:
print(str(abs(pos-pos_zero_left)),end=' ')
pos+=1
pos-=1
pos+=1
return positions
findDistancesToZero(n,a)
``` |
84_A. Toy Army | The hero of our story, Valera, and his best friend Arcady are still in school, and therefore they spend all the free time playing turn-based strategy "GAGA: Go And Go Again". The gameplay is as follows.
There are two armies on the playing field each of which consists of n men (n is always even). The current player specifies for each of her soldiers an enemy's soldier he will shoot (a target) and then all the player's soldiers shot simultaneously. This is a game world, and so each soldier shoots perfectly, that is he absolutely always hits the specified target. If an enemy soldier is hit, he will surely die. It may happen that several soldiers had been indicated the same target. Killed soldiers do not participate in the game anymore.
The game "GAGA" consists of three steps: first Valera makes a move, then Arcady, then Valera again and the game ends.
You are asked to calculate the maximum total number of soldiers that may be killed during the game.
Input
The input data consist of a single integer n (2 ≤ n ≤ 108, n is even). Please note that before the game starts there are 2n soldiers on the fields.
Output
Print a single number — a maximum total number of soldiers that could be killed in the course of the game in three turns.
Examples
Input
2
Output
3
Input
4
Output
6
Note
The first sample test:
1) Valera's soldiers 1 and 2 shoot at Arcady's soldier 1.
2) Arcady's soldier 2 shoots at Valera's soldier 1.
3) Valera's soldier 1 shoots at Arcady's soldier 2.
There are 3 soldiers killed in total: Valera's soldier 1 and Arcady's soldiers 1 and 2. | ```python
n=int(input())
print((n*3)//2)
``` |
898_C. Phone Numbers | Vasya has several phone books, in which he recorded the telephone numbers of his friends. Each of his friends can have one or several phone numbers.
Vasya decided to organize information about the phone numbers of friends. You will be given n strings — all entries from Vasya's phone books. Each entry starts with a friend's name. Then follows the number of phone numbers in the current entry, and then the phone numbers themselves. It is possible that several identical phones are recorded in the same record.
Vasya also believes that if the phone number a is a suffix of the phone number b (that is, the number b ends up with a), and both numbers are written by Vasya as the phone numbers of the same person, then a is recorded without the city code and it should not be taken into account.
The task is to print organized information about the phone numbers of Vasya's friends. It is possible that two different people have the same number. If one person has two numbers x and y, and x is a suffix of y (that is, y ends in x), then you shouldn't print number x. If the number of a friend in the Vasya's phone books is recorded several times in the same format, it is necessary to take it into account exactly once.
Read the examples to understand statement and format of the output better.
Input
First line contains the integer n (1 ≤ n ≤ 20) — number of entries in Vasya's phone books.
The following n lines are followed by descriptions of the records in the format described in statement. Names of Vasya's friends are non-empty strings whose length does not exceed 10. They consists only of lowercase English letters. Number of phone numbers in one entry is not less than 1 is not more than 10. The telephone numbers consist of digits only. If you represent a phone number as a string, then its length will be in range from 1 to 10. Phone numbers can contain leading zeros.
Output
Print out the ordered information about the phone numbers of Vasya's friends. First output m — number of friends that are found in Vasya's phone books.
The following m lines must contain entries in the following format "name number_of_phone_numbers phone_numbers". Phone numbers should be separated by a space. Each record must contain all the phone numbers of current friend.
Entries can be displayed in arbitrary order, phone numbers for one record can also be printed in arbitrary order.
Examples
Input
2
ivan 1 00123
masha 1 00123
Output
2
masha 1 00123
ivan 1 00123
Input
3
karl 2 612 12
petr 1 12
katya 1 612
Output
3
katya 1 612
petr 1 12
karl 1 612
Input
4
ivan 3 123 123 456
ivan 2 456 456
ivan 8 789 3 23 6 56 9 89 2
dasha 2 23 789
Output
2
dasha 2 23 789
ivan 4 789 123 2 456 | ```python
n=int(input())
dic={}
for i in range(n):
l=list(map(str,input().split()))
s1=l[0]
if s1 in dic.keys():
dic[l[0]]+=list(set(l[2:]))
else:
dic[l[0]]=list(set(l[2:]))
print(len(dic.keys()))
for ix in dic.keys():
l=dic[ix][:]
ll=len(l)
lln=[1 for i in range(ll)]
for i in range(ll):
for j in range(i+1,ll):
s1=l[i]
s2=l[j]
if len(s1)>len(s2):
for k in range( len(s1)):
if s2==s1[k:]:
lln[j]=0
else:
for k in range( len(s2)):
if s1==s2[k:]:
lln[i]=0
ls=[]
for i in range(ll):
if lln[i]==1:
ls.append(l[i])
print(ix,lln.count(1),*ls)
``` |
919_D. Substring | You are given a graph with n nodes and m directed edges. One lowercase letter is assigned to each node. We define a path's value as the number of the most frequently occurring letter. For example, if letters on a path are "abaca", then the value of that path is 3. Your task is find a path whose value is the largest.
Input
The first line contains two positive integers n, m (1 ≤ n, m ≤ 300 000), denoting that the graph has n nodes and m directed edges.
The second line contains a string s with only lowercase English letters. The i-th character is the letter assigned to the i-th node.
Then m lines follow. Each line contains two integers x, y (1 ≤ x, y ≤ n), describing a directed edge from x to y. Note that x can be equal to y and there can be multiple edges between x and y. Also the graph can be not connected.
Output
Output a single line with a single integer denoting the largest value. If the value can be arbitrarily large, output -1 instead.
Examples
Input
5 4
abaca
1 2
1 3
3 4
4 5
Output
3
Input
6 6
xzyabc
1 2
3 1
2 3
5 4
4 3
6 4
Output
-1
Input
10 14
xzyzyzyzqx
1 2
2 4
3 5
4 5
2 6
6 8
6 5
2 10
3 9
10 9
4 6
1 10
2 8
3 7
Output
4
Note
In the first sample, the path with largest value is 1 → 3 → 4 → 5. The value is 3 because the letter 'a' appears 3 times. | ```python
from collections import defaultdict
import sys
from sys import stdin
def check(a):
for i in a:
if i:
return True
return False
def change(x):
return ord(x)-ord('a')
def solve():
n, m = map(int, stdin.readline().split())
s = input()
d = {}
for i in range(n):
d[i+1] = s[i]
g = defaultdict(list)#[[] for _ in range(n+1)]
ind = [0 for _ in range(n+1)]
for _ in range(m):
x, y = map(int, stdin.readline().split())
g[x].append(y)
ind[y]+=1
q = []
dp = [[0 for _ in range(27)]for _ in range(n + 1)]
for i in range(1, n+1):
if ind[i]==0:
q.append(i)
dp[i][change(d[i])] = 1
for i in q:
for j in g[i]:
for k in range(26):
if change(d[j])==k:
dp[j][k] = max(dp[i][k]+1, dp[j][k])
else:
dp[j][k] = max(dp[i][k], dp[j][k])
ind[j]-=1
if ind[j]==0: q.append(j)
if check(ind):
print(-1)
else:
ans = 0
for i in dp:
for j in i:
ans = max(ans, j)
print(ans)
t = 1
#t = inp()
for _ in range(t):
solve()
``` |
946_C. String Transformation | You are given a string s consisting of |s| small english letters.
In one move you can replace any character of this string to the next character in alphabetical order (a will be replaced with b, s will be replaced with t, etc.). You cannot replace letter z with any other letter.
Your target is to make some number of moves (not necessary minimal) to get string abcdefghijklmnopqrstuvwxyz (english alphabet) as a subsequence. Subsequence of the string is the string that is obtained by deleting characters at some positions. You need to print the string that will be obtained from the given string and will be contain english alphabet as a subsequence or say that it is impossible.
Input
The only one line of the input consisting of the string s consisting of |s| (1 ≤ |s| ≤ 105) small english letters.
Output
If you can get a string that can be obtained from the given string and will contain english alphabet as a subsequence, print it. Otherwise print «-1» (without quotes).
Examples
Input
aacceeggiikkmmooqqssuuwwyy
Output
abcdefghijklmnopqrstuvwxyz
Input
thereisnoanswer
Output
-1 | ```python
i = 97
j = 0
s = [x for x in input()]
for item in s:
if item <= chr(i):
s[j] = chr(i)
i += 1
if i>122:
print("".join(s))
break
j += 1
else:
print(-1)
``` |
975_A. Aramic script | In Aramic language words can only represent objects.
Words in Aramic have special properties:
* A word is a root if it does not contain the same letter more than once.
* A root and all its permutations represent the same object.
* The root x of a word y is the word that contains all letters that appear in y in a way that each letter appears once. For example, the root of "aaaa", "aa", "aaa" is "a", the root of "aabb", "bab", "baabb", "ab" is "ab".
* Any word in Aramic represents the same object as its root.
You have an ancient script in Aramic. What is the number of different objects mentioned in the script?
Input
The first line contains one integer n (1 ≤ n ≤ 10^3) — the number of words in the script.
The second line contains n words s_1, s_2, …, s_n — the script itself. The length of each string does not exceed 10^3.
It is guaranteed that all characters of the strings are small latin letters.
Output
Output one integer — the number of different objects mentioned in the given ancient Aramic script.
Examples
Input
5
a aa aaa ab abb
Output
2
Input
3
amer arem mrea
Output
1
Note
In the first test, there are two objects mentioned. The roots that represent them are "a","ab".
In the second test, there is only one object, its root is "amer", the other strings are just permutations of "amer". | ```python
n=int(input())
s=input()
a=s.split(" ")
visited=[]
for i in range(len(a)):
visited.append(0)
arr=[]
for g in range(len(a)):
aux=[]
for h in range(26):
aux.append(0)
arr.append(aux)
for x in range(len(a)):
for y in range(len(a[x])):
if(arr[x][ord(a[x][y])-97]==0):
arr[x][ord(a[x][y])-97]+=1
count_arr=[]
for c in range(len(a)):
count=1
for d in range(c+1,len(a)):
no=1
if(visited[c]==0):
for e in range(26):
if(arr[c][e]!=arr[d][e]):
no=0
break
if(no==1):
count+=1
visited[d]=1
if(visited[c]==0):
count_arr.append(count)
visited[c]=1
print(len(count_arr))
``` |
994_F. Compute Power | You need to execute several tasks, each associated with number of processors it needs, and the compute power it will consume.
You have sufficient number of analog computers, each with enough processors for any task. Each computer can execute up to one task at a time, and no more than two tasks total. The first task can be any, the second task on each computer must use strictly less power than the first. You will assign between 1 and 2 tasks to each computer. You will then first execute the first task on each computer, wait for all of them to complete, and then execute the second task on each computer that has two tasks assigned.
If the average compute power per utilized processor (the sum of all consumed powers for all tasks presently running divided by the number of utilized processors) across all computers exceeds some unknown threshold during the execution of the first tasks, the entire system will blow up. There is no restriction on the second tasks execution. Find the lowest threshold for which it is possible.
Due to the specifics of the task, you need to print the answer multiplied by 1000 and rounded up.
Input
The first line contains a single integer n (1 ≤ n ≤ 50) — the number of tasks.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 108), where ai represents the amount of power required for the i-th task.
The third line contains n integers b1, b2, ..., bn (1 ≤ bi ≤ 100), where bi is the number of processors that i-th task will utilize.
Output
Print a single integer value — the lowest threshold for which it is possible to assign all tasks in such a way that the system will not blow up after the first round of computation, multiplied by 1000 and rounded up.
Examples
Input
6
8 10 9 9 8 10
1 1 1 1 1 1
Output
9000
Input
6
8 10 9 9 8 10
1 10 5 5 1 10
Output
1160
Note
In the first example the best strategy is to run each task on a separate computer, getting average compute per processor during the first round equal to 9.
In the second task it is best to run tasks with compute 10 and 9 on one computer, tasks with compute 10 and 8 on another, and tasks with compute 9 and 8 on the last, averaging (10 + 10 + 9) / (10 + 10 + 5) = 1.16 compute power per processor during the first round. | ```python
# Codeforces Round #488 by NEAR (Div. 2)
import collections
from functools import cmp_to_key
#key=cmp_to_key(lambda x,y: 1 if x not in y else -1 )
import math
import sys
def getIntList():
return list(map(int, input().split()))
import bisect
def makePair(z):
return [(z[i], z[i+1]) for i in range(0,len(z),2) ]
N, = getIntList()
za = getIntList()
zb = getIntList()
sa = set(za)
xa = list(sa)
xa.sort(reverse = True)
zz = [(t, sorted([zb[i] for i in range(N) if za[i] == t]) ) for t in xa ]
#print(zz)
lastdp = [[] for i in range(52)]
lastdp[0] = [(0,0)]
def addres(z, t):
if len(z) ==0:
z.append(t)
return
i = bisect.bisect_right(z,t)
if i>0 and z[i-1][1] >= t[1]: return
if i<len(z) and t[1] >= z[i][1]:
z[i] = t
return
z.insert(i,t)
for x in zz:
nowdp = [[] for i in range(52)]
for i in range(len(lastdp)):
tz = lastdp[i]
if len( tz ) ==0 : continue
num = len(x[1])
hide = min(i, num )
tb = sum(x[1])
acc =0;
for j in range(hide + 1):
la = x[0] * (num-j)
lb = tb - acc
if j<num: acc += x[1][j]
for t in tz:
# t = (0,0)
tr = (t[0] + la, t[1] + lb)
addres(nowdp[ i -j + num -j] ,tr)
lastdp = nowdp
#print(lastdp)
res = 10 ** 20
for x in lastdp:
for y in x:
t = math.ceil(y[0] *1000 / y[1] )
res = min( res,t)
print(res)
``` |
p02769 AtCoder Beginner Contest 156 - Roaming | There is a building with n rooms, numbered 1 to n.
We can move from any room to any other room in the building.
Let us call the following event a move: a person in some room i goes to another room j~ (i \neq j).
Initially, there was one person in each room in the building.
After that, we know that there were exactly k moves happened up to now.
We are interested in the number of people in each of the n rooms now. How many combinations of numbers of people in the n rooms are possible?
Find the count modulo (10^9 + 7).
Constraints
* All values in input are integers.
* 3 \leq n \leq 2 \times 10^5
* 2 \leq k \leq 10^9
Input
Input is given from Standard Input in the following format:
n k
Output
Print the number of possible combinations of numbers of people in the n rooms now, modulo (10^9 + 7).
Examples
Input
3 2
Output
10
Input
200000 1000000000
Output
607923868
Input
15 6
Output
22583772 | ```python
n,k=map(int,input().split())
mod=10**9+7
lim=n
fcl=[1]*(lim+1)
for i in range(1,lim+1):
fcl[i]=(fcl[i-1]*i)%mod
def comb(x,y,p):
return ((fcl[x]*pow(fcl[y],p-2,p))%p*pow(fcl[x-y],p-2,p))%p
ans=0
for i in range(min(n,k+1)):
ans+=comb(n-1,n-i-1,mod)*comb(n,i,mod)
ans%=mod
print(ans)
``` |
p02904 AtCoder Grand Contest 038 - Sorting a Segment | Snuke has a permutation (P_0,P_1,\cdots,P_{N-1}) of (0,1,\cdots,N-1).
Now, he will perform the following operation exactly once:
* Choose K consecutive elements in P and sort them in ascending order.
Find the number of permutations that can be produced as P after the operation.
Constraints
* 2 \leq N \leq 200000
* 2 \leq K \leq N
* 0 \leq P_i \leq N-1
* P_0,P_1,\cdots,P_{N-1} are all different.
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N K
P_0 P_1 \cdots P_{N-1}
Output
Print the number of permutations that can be produced as P after the operation.
Examples
Input
5 3
0 2 1 4 3
Output
2
Input
4 4
0 1 2 3
Output
1
Input
10 4
2 0 1 3 7 5 4 6 8 9
Output
6 | ```python
n, k = map(int,input().split())
P = list(map(int,input().split()))
# for i in range(n-k+1):
# pp = P[i:i+k]
# pp.sort()
# print(P[:i] + pp + P[i+k:])
A = []
B = []
VA = [0] * n
VB = [0] * n
import heapq
for i in range(k):
heapq.heappush(A, P[i]) # 最小値用
heapq.heappush(B, -P[i]) # 最大値用
ans = 1
for i in range(n-k):
b = -heapq.heappop(B)
while VB[b] == 1:
b = -heapq.heappop(B)
a = heapq.heappop(A)
while VA[a] == 1:
a = heapq.heappop(A)
# print(i,a,b,A,B)
# print(P[k+i] ,b ,P[i] , a)
if not(P[k+i] > b and P[i] == a):
ans += 1
# print(i)
heapq.heappush(A, a)
heapq.heappush(B, -b)
heapq.heappush(A, P[k+i])
heapq.heappush(B, -P[k+i])
VA[P[i]] = 1
VB[P[i]] = 1
# print("ans",ans)
AA = []
for i in range(n-1):
if P[i+1] - P[i] >= 0:
AA.append(1)
else:
AA.append(0)
s = sum(AA[:k-1])
t = 0
r = 0
if s == k-1:
t += 1
r = 1
for i in range(n-k):
# print(AA)
s += AA[k-1+i]
s -= AA[i]
if s == k-1:
t += 1
r += 1
else:
ans += max(0, r-1)
r = 0
ans += max(0, r-1)
# print("t",t)
print(ans - max(0, t-1))
``` |
p03039 AtCoder Beginner Contest 127 - Cell Distance | We have a grid of squares with N rows and M columns. Let (i, j) denote the square at the i-th row from the top and j-th column from the left. We will choose K of the squares and put a piece on each of them.
If we place the K pieces on squares (x_1, y_1), (x_2, y_2), ..., and (x_K, y_K), the cost of this arrangement is computed as:
\sum_{i=1}^{K-1} \sum_{j=i+1}^K (|x_i - x_j| + |y_i - y_j|)
Find the sum of the costs of all possible arrangements of the pieces. Since this value can be tremendous, print it modulo 10^9+7.
We consider two arrangements of the pieces different if and only if there is a square that contains a piece in one of the arrangements but not in the other.
Constraints
* 2 \leq N \times M \leq 2 \times 10^5
* 2 \leq K \leq N \times M
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N M K
Output
Print the sum of the costs of all possible arrangements of the pieces, modulo 10^9+7.
Examples
Input
2 2 2
Output
8
Input
4 5 4
Output
87210
Input
100 100 5000
Output
817260251 | ```python
n,m,k=map(int,input().split())
mod=10**9+7
f=[1]
for i in range(2*10**5+7):f+=[f[-1]*(i+1)%mod]
def comb(a,b):return f[a]*pow(f[b],mod-2,mod)*pow(f[a-b],mod-2,mod)%mod
ans=0
for i in range(1,n):
ans+=(i*(n-i)*m**2)*(comb(n*m-2,k-2))
ans%=mod
for i in range(1,m):
ans+=(i*(m-i)*n**2)*(comb(n*m-2,k-2))
ans%=mod
print(ans)
``` |
p03180 Educational DP Contest - Grouping | There are N rabbits, numbered 1, 2, \ldots, N.
For each i, j (1 \leq i, j \leq N), the compatibility of Rabbit i and j is described by an integer a_{i, j}. Here, a_{i, i} = 0 for each i (1 \leq i \leq N), and a_{i, j} = a_{j, i} for each i and j (1 \leq i, j \leq N).
Taro is dividing the N rabbits into some number of groups. Here, each rabbit must belong to exactly one group. After grouping, for each i and j (1 \leq i < j \leq N), Taro earns a_{i, j} points if Rabbit i and j belong to the same group.
Find Taro's maximum possible total score.
Constraints
* All values in input are integers.
* 1 \leq N \leq 16
* |a_{i, j}| \leq 10^9
* a_{i, i} = 0
* a_{i, j} = a_{j, i}
Input
Input is given from Standard Input in the following format:
N
a_{1, 1} \ldots a_{1, N}
:
a_{N, 1} \ldots a_{N, N}
Output
Print Taro's maximum possible total score.
Examples
Input
3
0 10 20
10 0 -100
20 -100 0
Output
20
Input
2
0 -10
-10 0
Output
0
Input
4
0 1000000000 1000000000 1000000000
1000000000 0 1000000000 1000000000
1000000000 1000000000 0 -1
1000000000 1000000000 -1 0
Output
4999999999
Input
16
0 5 -4 -5 -8 -4 7 2 -4 0 7 0 2 -3 7 7
5 0 8 -9 3 5 2 -7 2 -7 0 -1 -4 1 -1 9
-4 8 0 -9 8 9 3 1 4 9 6 6 -6 1 8 9
-5 -9 -9 0 -7 6 4 -1 9 -3 -5 0 1 2 -4 1
-8 3 8 -7 0 -5 -9 9 1 -9 -6 -3 -8 3 4 3
-4 5 9 6 -5 0 -6 1 -2 2 0 -5 -2 3 1 2
7 2 3 4 -9 -6 0 -2 -2 -9 -3 9 -2 9 2 -5
2 -7 1 -1 9 1 -2 0 -6 0 -6 6 4 -1 -7 8
-4 2 4 9 1 -2 -2 -6 0 8 -6 -2 -4 8 7 7
0 -7 9 -3 -9 2 -9 0 8 0 0 1 -3 3 -6 -6
7 0 6 -5 -6 0 -3 -6 -6 0 0 5 7 -1 -5 3
0 -1 6 0 -3 -5 9 6 -2 1 5 0 -2 7 -8 0
2 -4 -6 1 -8 -2 -2 4 -4 -3 7 -2 0 -9 7 1
-3 1 1 2 3 3 9 -1 8 3 -1 7 -9 0 -6 -8
7 -1 8 -4 4 1 2 -7 7 -6 -5 -8 7 -6 0 -9
7 9 9 1 3 2 -5 8 7 -6 3 0 1 -8 -9 0
Output
132 | ```python
N = int(input())
a = [list(map(int, input().split())) for _ in range(N)]
score = [0]*(1<<N)
for S in range(1<<N):
for i in range(N):
if (S>>i)&1:
for j in range(i+1, N):
if (S>>j)&1:
score[S] += a[i][j]
dp = [-10**18]*(1<<N)
dp[0] = 0
for S in range(1<<N):
T = S
while True:
dp[S] = max(dp[S], dp[T]+score[S-T])
T = (T-1)&S
if T==S:
break
print(dp[-1])
``` |
p03328 AtCoder Beginner Contest 099 - Stone Monument | In some village, there are 999 towers that are 1,(1+2),(1+2+3),...,(1+2+3+...+999) meters high from west to east, at intervals of 1 meter.
It had been snowing for a while before it finally stopped. For some two adjacent towers located 1 meter apart, we measured the lengths of the parts of those towers that are not covered with snow, and the results are a meters for the west tower, and b meters for the east tower.
Assuming that the depth of snow cover and the altitude are the same everywhere in the village, find the amount of the snow cover.
Assume also that the depth of the snow cover is always at least 1 meter.
Constraints
* 1 \leq a < b < 499500(=1+2+3+...+999)
* All values in input are integers.
* There is no input that contradicts the assumption.
Input
Input is given from Standard Input in the following format:
a b
Output
If the depth of the snow cover is x meters, print x as an integer.
Examples
Input
8 13
Output
2
Input
54 65
Output
1 | ```python
a, b = map(int, input().split())
print(((b-a)*((b-a)+1))//2 - b)
``` |
p03484 AtCoder Regular Contest 088 - Christmas Tree | Takahashi has decided to make a Christmas Tree for the Christmas party in AtCoder, Inc.
A Christmas Tree is a tree with N vertices numbered 1 through N and N-1 edges, whose i-th edge (1\leq i\leq N-1) connects Vertex a_i and b_i.
He would like to make one as follows:
* Specify two non-negative integers A and B.
* Prepare A Christmas Paths whose lengths are at most B. Here, a Christmas Path of length X is a graph with X+1 vertices and X edges such that, if we properly number the vertices 1 through X+1, the i-th edge (1\leq i\leq X) will connect Vertex i and i+1.
* Repeat the following operation until he has one connected tree:
* Select two vertices x and y that belong to different connected components. Combine x and y into one vertex. More precisely, for each edge (p,y) incident to the vertex y, add the edge (p,x). Then, delete the vertex y and all the edges incident to y.
* Properly number the vertices in the tree.
Takahashi would like to find the lexicographically smallest pair (A,B) such that he can make a Christmas Tree, that is, find the smallest A, and find the smallest B under the condition that A is minimized.
Solve this problem for him.
Constraints
* 2 \leq N \leq 10^5
* 1 \leq a_i,b_i \leq N
* The given graph is a tree.
Input
Input is given from Standard Input in the following format:
N
a_1 b_1
:
a_{N-1} b_{N-1}
Output
For the lexicographically smallest (A,B), print A and B with a space in between.
Examples
Input
7
1 2
2 3
2 4
4 5
4 6
6 7
Output
3 2
Input
8
1 2
2 3
3 4
4 5
5 6
5 7
5 8
Output
2 5
Input
10
1 2
2 3
3 4
2 5
6 5
6 7
7 8
5 9
10 5
Output
3 4 | ```python
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from bisect import bisect_left, bisect_right
N = int(readline())
m = map(int,read().split())
AB = zip(m,m)
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
root = 1
parent = [0] * (N+1)
order = []
stack = [root]
while stack:
x = stack.pop()
order.append(x)
for y in graph[x]:
if y == parent[x]:
continue
parent[y] = x
stack.append(y)
def make_pairs(S,x):
# a + b <= x となるペアをなるべくたくさん作る
# nペア（なるべくたくさん）作ったあと、1つ短い長さが残る
seg = 0
while S and S[-1] == x:
S.pop()
seg += 1
i = bisect_right(S,x//2)
lower = S[:i][::-1]; upper = S[i:]
cand = []
rest = []
for b in upper[::-1]:
while lower and lower[-1] + b <= x:
cand.append(lower.pop())
if cand:
cand.pop()
seg += 1
else:
rest.append(b)
cand += lower[::-1]
L = len(cand)
q,r = divmod(L,2)
if r:
return seg + len(rest) + q, cand[0]
else:
seg += q
if rest:
return seg + len(rest) - 1, rest[-1]
else:
# 全部ペアになった
return seg, 0
def solve(x):
# 長さ x までの線分を許容した場合に、必要となる本数を返す
dp = [0] * (N+1)
temp = [[] for _ in range(N+1)] # 下から出てくる長さ
for v in order[::-1]:
p = parent[v]
S = temp[v]
S.sort()
s, l = make_pairs(S,x)
dp[v] += s
dp[p] += dp[v]
temp[p].append(l + 1)
if v == 1:
return dp[1] if not l else dp[1] + 1
seg = solve(N + 10)
left = 0 # むり
right = N # できる
while left + 1 < right:
x = (left + right) // 2
if solve(x) == seg:
right = x
else:
left = x
print(seg, right)
``` |
p03649 AtCoder Regular Contest 079 - Decrease (Judge ver.) | We have a sequence of length N consisting of non-negative integers. Consider performing the following operation on this sequence until the largest element in this sequence becomes N-1 or smaller. (The operation is the same as the one in Problem D.)
* Determine the largest element in the sequence (if there is more than one, choose one). Decrease the value of this element by N, and increase each of the other elements by 1.
It can be proved that the largest element in the sequence becomes N-1 or smaller after a finite number of operations.
You are given the sequence a_i. Find the number of times we will perform the above operation.
Constraints
* 2 ≤ N ≤ 50
* 0 ≤ a_i ≤ 10^{16} + 1000
Input
Input is given from Standard Input in the following format:
N
a_1 a_2 ... a_N
Output
Print the number of times the operation will be performed.
Examples
Input
4
3 3 3 3
Output
0
Input
3
1 0 3
Output
1
Input
2
2 2
Output
2
Input
7
27 0 0 0 0 0 0
Output
3
Input
10
1000 193 256 777 0 1 1192 1234567891011 48 425
Output
1234567894848 | ```python
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
count = 0
B = [A[0]]
for i in range(N-1):
a = A[i+1]+count
C = []
for b in B:
x = (b-a)//(N+1)
C.append(x)
s = sum(C)
count += s
new_B = []
for i, b in enumerate(B):
new_B.append(b+s-(N+1)*C[i])
new_B.append(a+s)
B = new_B
delta = max(min(B) - N, 0)
count += delta*N
for i in range(N):
B[i] -= delta
while max(B) > N-1:
tmp = -1
for i in range(N):
if B[i] > tmp:
tmp = B[i]
ind = i
for i in range(N):
if i == ind:
B[i] -= N
else:
B[i] += 1
count += 1
print(count)
``` |
p03805 AtCoder Beginner Contest 054 - One-stroke Path | You are given an undirected unweighted graph with N vertices and M edges that contains neither self-loops nor double edges.
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).
How many different paths start from vertex 1 and visit all the vertices exactly once?
Here, the endpoints of a path are considered visited.
For example, let us assume that the following undirected graph shown in Figure 1 is given.
<image>
Figure 1: an example of an undirected graph
The following path shown in Figure 2 satisfies the condition.
<image>
Figure 2: an example of a path that satisfies the condition
However, the following path shown in Figure 3 does not satisfy the condition, because it does not visit all the vertices.
<image>
Figure 3: an example of a path that does not satisfy the condition
Neither the following path shown in Figure 4, because it does not start from vertex 1.
<image>
Figure 4: another example of a path that does not satisfy the condition
Constraints
* 2≦N≦8
* 0≦M≦N(N-1)/2
* 1≦a_i<b_i≦N
* The given graph contains neither self-loops nor double edges.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
a_2 b_2
:
a_M b_M
Output
Print the number of the different paths that start from vertex 1 and visit all the vertices exactly once.
Examples
Input
3 3
1 2
1 3
2 3
Output
2
Input
7 7
1 3
2 7
3 4
4 5
4 6
5 6
6 7
Output
1 | ```python
import itertools
n,m = map(int,input().split())
ab = []
count = 0
for i in range(m):
ab.append(set(map(int,input().split())))
ns = [i for i in range(1,n+1)]
ptn = [i for i in list(itertools.permutations(ns)) if i[0]==1]
for i in ptn:
first = i[0]
for s in range(1,n):
if {first,i[s]} not in ab:
break
first=i[s]
else:
count +=1
print(count)
``` |
p03973 CODE FESTIVAL 2016 qual B - Greedy customers | N people are waiting in a single line in front of the Takahashi Store. The cash on hand of the i-th person from the front of the line is a positive integer A_i.
Mr. Takahashi, the shop owner, has decided on the following scheme: He picks a product, sets a positive integer P indicating its price, and shows this product to customers in order, starting from the front of the line. This step is repeated as described below.
At each step, when a product is shown to a customer, if price P is equal to or less than the cash held by that customer at the time, the customer buys the product and Mr. Takahashi ends the current step. That is, the cash held by the first customer in line with cash equal to or greater than P decreases by P, and the next step begins.
Mr. Takahashi can set the value of positive integer P independently at each step.
He would like to sell as many products as possible. However, if a customer were to end up with 0 cash on hand after a purchase, that person would not have the fare to go home. Customers not being able to go home would be a problem for Mr. Takahashi, so he does not want anyone to end up with 0 cash.
Help out Mr. Takahashi by writing a program that determines the maximum number of products he can sell, when the initial cash in possession of each customer is given.
Constraints
* 1 ≦ | N | ≦ 100000
* 1 ≦ A_i ≦ 10^9(1 ≦ i ≦ N)
* All inputs are integers.
Input
Inputs are provided from Standard Inputs in the following form.
N
A_1
:
A_N
Output
Output an integer representing the maximum number of products Mr. Takahashi can sell.
Examples
Input
3
3
2
5
Output
3
Input
15
3
1
4
1
5
9
2
6
5
3
5
8
9
7
9
Output
18 | ```python
n = int(input())
a = []
for i in range(n):
a0 = int(input())
a.append(a0)
ans = 0
key = "b"
count = 1
m = 0
for i in range(n):
if key == "a":
if a[i] == count:
count += 1
elif a[i] > count:
if a[i]%count == 0:
ans += a[i]//count - 1
else:
ans += a[i]//count
else:
if i == 0:
ans += a[i]-1
count += 1
else:
if a[i] == 2:
key = "a"
count = 3
m = 2
else:
if a[i]%2 == 0:
ans += a[i]//2-1
else:
ans += a[i]//2
#print(ans,count)
print(ans)
``` |
p00062 What is the Bottommost? | Consider creating the following number pattern.
4 8 2 3 1 0 8 3 7 6
2 0 5 4 1 8 1 0 3
2 5 9 5 9 9 1 3
7 4 4 4 8 0 4
1 8 8 2 8 4
9 6 0 0 2
5 6 0 2
1 6 2
7 8
Five
This pattern follows the rules below.
A B
C
In the sequence of numbers, C is the ones digit of A + B. For example
9 5
Four
Now, the ones digit of 9 + 5 = 14, or 4 is placed diagonally below 9 and 5. Also,
twenty three
Five
Now, the ones digit of 2 + 3 = 5, that is, 5 is placed diagonally below 2 and 3.
Write a program that reads the 10 integers in the top line and outputs one number in the bottom line.
Input
The input consists of multiple datasets. For each dataset, the top 10 numbers are given as strings on one line.
The number of datasets does not exceed 20.
Output
Outputs the numbers in the bottom line to one line for each dataset.
Example
Input
4823108376
1234567890
0123456789
Output
5
6
4 | ```python
while True:
try:
L = [int(x) for x in list(input())]
except:
break
T =[]
while len(L) > 1:
for i in range(len(L)-1):
T.append( (L[i] + L[i+1])%10 )
L = T[:]
T = []
print(L[0])
``` |
p00193 Convenience Store | Convenience store Deven Eleven is planning to open its first store in Aizuwakamatsu City to expand its business. There are already many other convenience stores in Aizuwakamatsu, so the place to open a new store is likely to be the key to success. Under the premise that "customers use the convenience store closest to the area where they live," Seven Eleven has decided to open a store at "a point that many customers will use."
| <image>
--- | ---
Seven Eleven has divided the map of Aizuwakamatsu City using a congruent regular hexagon (hereinafter referred to as "block") in order to grasp the range covered by each existing convenience store. At this time, each block was divided so that there was at most one existing convenience store. On this map, the distance to the convenience store is calculated based on the number of blocks that go through from each block to the convenience store. We believe that each block is covered by the convenience store with the shortest distance. The problem is to look for "a block without an existing convenience store that covers as many blocks as possible" based on this map.
As a Deven-Eleven programmer, you have decided to develop a program that calculates the number of blocks that can be covered most widely from the block-divided map information and the information on the candidate sites for new stores.
The map divided into m x n is shown as shown in Fig. 1. There are m hexagonal blocks horizontally and n vertically, each represented by one coordinate (x, y). The left edge of the odd row is located at the bottom left of the left edge of the row above it, and the left edge of the even row is located at the bottom right of the left edge of the row above it. For example, the coordinates (1, 1) indicate the upper left block in Figure 1. Also, the coordinates (1, 2) are located at the lower right of the coordinates (1, 1), and the coordinates (1, 3) are located at the lower left of the coordinates (1, 2).
<image>
Figure 2 shows an example of the case where there are 6 existing convenience stores, which are divided into 6 x 6. Each convenience store is numbered in order from 1. At this time, if the blocks covered by each convenience store are painted separately for each number, it will be as shown in Fig. 3. Unpainted blocks such as coordinates (1, 4) and (2, 5) have two or more closest convenience stores, and neither is a block that can be judged. For example, in the case of a block with coordinates (1, 4), the distance to the convenience store number 4 and the convenience store number 5 are equal, and it is assumed that no convenience store covers this block. The number of blocks covered by the convenience store number 4 is 5.
<image>
Now suppose that Seven Eleven considers coordinates (1, 3) and coordinates (5, 3) as potential sites for a new store. If you set up a store at coordinates (1, 3), the number of blocks that can be covered is 3 (Fig. 4). On the other hand, if you set up a store at coordinates (5, 3), the number of blocks that can be covered is 4 (Fig. 5). Therefore, the number of blocks that can be covered most widely is 4.
<image>
Enter map information m x n, number of existing convenience stores s and their coordinates (x, y), number of candidate sites t and their coordinates (p, q), and the number of blocks that can be covered most widely among all candidate sites. Create a program that outputs.
Input
A sequence of multiple datasets is given as input. The end of the input is indicated by two lines of zeros. Each dataset is given in the following format:
m n
s
x1 y1
x2 y2
::
xs ys ys
t
p1 q1
p2 q2
::
pt qt
The integers m, n (2 ≤ m, n ≤ 100) are given to represent the size (horizontal, vertical) of the divided map on the first line.
The second line gives the number of existing convenience stores s (1 ≤ s ≤ 10). The following s line is given the coordinates xi, y1 of the ith existing convenience store.
The next line is given the number of potential new store sites t (1 ≤ t ≤ 10). The following t line is given the coordinates pi, qi of the i-th candidate site.
The number of datasets does not exceed 20.
Output
For each data set, the number of blocks that can cover the widest of all candidate sites is output on one line.
Example
Input
6 6
6
1 1
6 1
3 2
3 5
1 6
5 6
2
1 3
5 3
6 6
6
3 2
3 5
6 1
1 1
1 6
5 6
2
2 3
5 3
0 0
Output
4
4 | ```python
import sys
def generate_next_hexes(x, y):
hexes = [(x, y - 1), (x, y + 1), (x - 1, y), (x + 1, y)]
if y % 2:
hexes += [(x - 1, y - 1), (x - 1, y + 1)]
else:
hexes += [(x + 1, y - 1), (x + 1, y + 1)]
return hexes
def update_map(hex_map, hexes):
num_updated_hexes = 0
distance = 0
while hexes:
next_hexes = []
for pos in hexes:
x = pos[0]
y = pos[1]
if (1 <= x <= m and 1 <= y <= n
and (pos not in hex_map or distance < hex_map[pos])):
hex_map[pos] = distance
num_updated_hexes += 1
next_hexes += generate_next_hexes(x, y)
distance += 1
hexes = next_hexes
return num_updated_hexes
while True:
(m, n) = [int(i) for i in sys.stdin.readline().split()]
if m == n == 0:
break
s = int(sys.stdin.readline())
stores = []
for i in range(s):
pos = [int(j) for j in sys.stdin.readline().split()]
stores.append(tuple(pos))
hex_map = {}
update_map(hex_map, stores)
t = int(sys.stdin.readline())
candidates = []
for i in range(t):
pos = [int(j) for j in sys.stdin.readline().split()]
candidates.append(tuple(pos))
max_num_blocks = 0
for candidate in candidates:
new_hex_map = hex_map.copy()
num_blocks = update_map(new_hex_map, [candidate])
max_num_blocks = max(max_num_blocks, num_blocks)
print(max_num_blocks)
``` |
p00544 Russian Flag | problem
President K decided to make a flag for IOI 2016 in Russia. Chairman K first took out the old flag from the warehouse. This flag is divided into squares of N rows and M columns, and each square is painted in one of white, blue, and red.
Chairman K is trying to repaint some of the squares on this flag to make it the Russian flag. However, the Russian flag in this problem is as follows.
* Several lines (one or more lines) from the top are all painted in white.
* The next few lines (one or more lines) are all painted in blue.
* All the cells in the other lines (one or more lines) are painted in red.
Find the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
input
The input consists of 1 + N lines.
On the first line, two integers N and M (3 ≤ N ≤ 50, 3 ≤ M ≤ 50) are written separated by a blank. This means that the flags are separated by N rows and M columns.
The following N lines each contain a string of M characters, which represents the color information painted in the squares of the old flag. The jth character (1 ≤ i ≤ N, 1 ≤ j ≤ M) on the i-th line of the N-line represents the color of the cell on the i-th line and j-th column of the old flag. It is either B'or'R'. 'W' stands for white,'B' stands for blue, and'R' stands for red.
output
Output in one line the minimum number of squares that President K needs to repaint to turn the old flag into a Russian flag.
Input / output example
Input example 1
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output example 1
11
Input example 2
6 14
WWWWWWWWWWWWWW
WBBBWWRRWWBBBW
WWBWWRRRRWWBWW
BWBWWRRRRWWBWW
WBBWWWRRWWBBBW
WWWWWWWWWWWWWW
Output example 2
44
In I / O example 1, the old flag is colored as shown in the figure below.
fig01
In the figure below, repaint the 11 squares with an'X'.
fig02
This makes it possible to make the Russian flag as shown in the figure below.
fig03
Since it is not possible to make a Russian flag by repainting less than 11 squares, 11 is output.
In I / O example 2, the old flag is colored as shown in the figure below.
fig04
Creative Commons License
Information Olympics Japan Committee work "15th Japan Information Olympics JOI 2015/2016 Qualifying Competition Tasks"
Example
Input
4 5
WRWRW
BWRWB
WRWRW
RWBWR
Output
11 | ```python
#C
inf = float("inf")
N,M = map(int,input().split())
flag = [list(str(input())) for i in range(N)]
WBR = []
for i in range(N):
w = flag[i].count("W")
b = flag[i].count("B")
r = flag[i].count("R")
WBR.append([w,b,r])
ans = inf
for w in range(N-2):
for b in range(N-1):
if w >= b:
pass
else:
kari = 0
for i in range(N):
if i <= w:
kari+=(M-WBR[i][0])
elif i <= b:
kari+=(M-WBR[i][1])
else:
kari+=(M-WBR[i][2])
ans = min(ans,kari)
print(ans)
``` |
p00708 Building a Space Station | You are a member of the space station engineering team, and are assigned a task in the construction process of the station. You are expected to write a computer program to complete the task.
The space station is made up with a number of units, called cells. All cells are sphere-shaped, but their sizes are not necessarily uniform. Each cell is fixed at its predetermined position shortly after the station is successfully put into its orbit. It is quite strange that two cells may be touching each other, or even may be overlapping. In an extreme case, a cell may be totally enclosing another one. I do not know how such arrangements are possible.
All the cells must be connected, since crew members should be able to walk from any cell to any other cell. They can walk from a cell A to another cell B, if, (1) A and B are touching each other or overlapping, (2) A and B are connected by a `corridor', or (3) there is a cell C such that walking from A to C, and also from B to C are both possible. Note that the condition (3) should be interpreted transitively.
You are expected to design a configuration, namely, which pairs of cells are to be connected with corridors. There is some freedom in the corridor configuration. For example, if there are three cells A, B and C, not touching nor overlapping each other, at least three plans are possible in order to connect all three cells. The first is to build corridors A-B and A-C, the second B-C and B-A, the third C-A and C-B. The cost of building a corridor is proportional to its length. Therefore, you should choose a plan with the shortest total length of the corridors.
You can ignore the width of a corridor. A corridor is built between points on two cells' surfaces. It can be made arbitrarily long, but of course the shortest one is chosen. Even if two corridors A-B and C-D intersect in space, they are not considered to form a connection path between (for example) A and C. In other words, you may consider that two corridors never intersect.
Input
The input consists of multiple data sets. Each data set is given in the following format.
> n
> x1 y1 z1 r1
> x2 y2 z2 r2
> ...
> xn yn zn rn
>
The first line of a data set contains an integer n, which is the number of cells. n is positive, and does not exceed 100.
The following n lines are descriptions of cells. Four values in a line are x-, y- and z-coordinates of the center, and radius (called r in the rest of the problem) of the sphere, in this order. Each value is given by a decimal fraction, with 3 digits after the decimal point. Values are separated by a space character.
Each of x, y, z and r is positive and is less than 100.0.
The end of the input is indicated by a line containing a zero.
Output
For each data set, the shortest total length of the corridors should be printed, each in a separate line. The printed values should have 3 digits after the decimal point. They may not have an error greater than 0.001.
Note that if no corridors are necessary, that is, if all the cells are connected without corridors, the shortest total length of the corridors is 0.000.
Example
Input
3
10.000 10.000 50.000 10.000
40.000 10.000 50.000 10.000
40.000 40.000 50.000 10.000
2
30.000 30.000 30.000 20.000
40.000 40.000 40.000 20.000
5
5.729 15.143 3.996 25.837
6.013 14.372 4.818 10.671
80.115 63.292 84.477 15.120
64.095 80.924 70.029 14.881
39.472 85.116 71.369 5.553
0
Output
20.000
0.000
73.834 | ```python
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1127
# クラスカル or プリム法
import math
class UnionFind:
def __init__(self, n):
self.n = n
# 各要素の親要素の番号を格納するリスト
# 根がルートの時は、グループの要素数を格納 最初は全て根で要素数1
self.parents = [-1] * n
# 再帰 groupの根を返す
# 経路圧縮あり
def find(self, x):
# 0より小さい場合は根
if self.parents[x] < 0:
# indexを返す
return x
else:
# 根になるまで親を辿る
# 経路圧縮 根のindexが全ての親に再帰的につく
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# groupを併合
def union(self, x, y):
# 根を探す
x = self.find(x)
y = self.find(y)
# 最初から統合されている
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
# 根のグループ数を追加 xの方グループの要素数が多い前提なので多い方に寄せる
self.parents[x] += self.parents[y]
# 親(根)のindexを入れる
self.parents[y] = x
# xのgroupのサイズ
def size(self, x):
return - self.parents[self.find(x)]
# 根が同じか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# ルートが同じ要素を返す
def members(self, x):
root = self.find(x)
# 根が同じ要素
return [i for i, in range(self.n) if self.find(i) == root]
# 全ての根の要素を返す
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
# グループの数を数える 遅い
def group_count(self):
return len(self.roots())
# {root: [要素]}
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
while True:
n = int(input())
uf = UnionFind(n)
if n == 0:
break
cell = []
for _ in range(n):
x, y, z, r = map(float, input().split())
cell.append((x, y, z, r))
edge = []
for i in range(n):
for j in range(i + 1, n):
dis = math.sqrt(
(cell[i][0] - cell[j][0]) ** 2 + (cell[i][1] - cell[j][1]) ** 2 + (cell[i][2] - cell[j][2]) ** 2)
#print(dis)
if dis < (cell[i][3] + cell[j][3]):
uf.union(i, j)
else:
edge.append((dis - (cell[i][3] + cell[j][3]), i, j))
edge.sort()
ans = 0
num = n
for c, a, b in edge:
# 同じグループでなかったら統合
if not uf.same(a, b):
uf.union(a, b)
ans += c
num -= 1
# グループ数は開催する都市の数になったら終了
if num == 1:
break
print('{:.3f}'.format(ans))
``` |
p00979 Fast Forwarding | Fast Forwarding
Mr. Anderson frequently rents video tapes of his favorite classic films. Watching the films so many times, he has learned the precise start times of his favorite scenes in all such films. He now wants to find how to wind the tape to watch his favorite scene as quickly as possible on his video player.
When the [play] button is pressed, the film starts at the normal playback speed. The video player has two buttons to control the playback speed: The [3x] button triples the speed, while the [1/3x] button reduces the speed to one third. These speed control buttons, however, do not take effect on the instance they are pressed. Exactly one second after playback starts and every second thereafter, the states of these speed control buttons are checked. If the [3x] button is pressed on the timing of the check, the playback speed becomes three times the current speed. If the [1/3x] button is pressed, the playback speed becomes one third of the current speed, unless it is already the normal speed.
For instance, assume that his favorite scene starts at 19 seconds from the start of the film. When the [3x] button is on at one second and at two seconds after the playback starts, and the [1/3x] button is on at three seconds and at five seconds after the start, the desired scene can be watched in the normal speed five seconds after starting the playback, as depicted in the following chart.
<image>
Your task is to compute the shortest possible time period after the playback starts until the desired scene starts. The playback of the scene, of course, should be in the normal speed.
Input
The input consists of a single test case of the following format.
$t$
The given single integer $t$ ($0 \leq t < 2^{50}$) is the start time of the target scene.
Output
Print an integer that is the minimum possible time in seconds before he can start watching the target scene in the normal speed.
Sample Input 1
19
Sample Output 1
5
Sample Input 2
13
Sample Output 2
5
Sample Input 3
123456789098765
Sample Output 3
85
Sample Input 4
51
Sample Output 4
11
Sample Input 5
0
Sample Output 5
0
Sample Input 6
3
Sample Output 6
3
Sample Input 7
4
Sample Output 7
2
Example
Input
19
Output
5 | ```python
#!/usr/bin/python3
import os
import sys
def main():
T = read_int()
print(solve(T))
def solve(T):
if T <= 3:
return T
sec = 1
T -= 1
f = 3
while T >= 2 * f:
T -= 2 * f
f *= 3
sec += 2
if T >= f:
T -= f
sec += 1
else:
f //= 3
while T > 0:
t = T // f
T -= t * f
sec += t
f //= 3
return sec
###############################################################################
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
if __name__ == '__main__':
main()
``` |
p01111 Skyscraper MinatoHarukas | Skyscraper "MinatoHarukas"
Mr. Port plans to start a new business renting one or more floors of the new skyscraper with one giga floors, MinatoHarukas. He wants to rent as many vertically adjacent floors as possible, because he wants to show advertisement on as many vertically adjacent windows as possible. The rent for one floor is proportional to the floor number, that is, the rent per month for the n-th floor is n times that of the first floor. Here, the ground floor is called the first floor in the American style, and basement floors are out of consideration for the renting. In order to help Mr. Port, you should write a program that computes the vertically adjacent floors satisfying his requirement and whose total rental cost per month is exactly equal to his budget.
For example, when his budget is 15 units, with one unit being the rent of the first floor, there are four possible rent plans, 1+2+3+4+5, 4+5+6, 7+8, and 15. For all of them, the sums are equal to 15. Of course in this example the rent of maximal number of the floors is that of 1+2+3+4+5, that is, the rent from the first floor to the fifth floor.
Input
The input consists of multiple datasets, each in the following format.
> b
>
A dataset consists of one line, the budget of Mr. Port b as multiples of the rent of the first floor. b is a positive integer satisfying 1 < b < 109.
The end of the input is indicated by a line containing a zero. The number of datasets does not exceed 1000.
Output
For each dataset, output a single line containing two positive integers representing the plan with the maximal number of vertically adjacent floors with its rent price exactly equal to the budget of Mr. Port. The first should be the lowest floor number and the second should be the number of floors.
Sample Input
15
16
2
3
9699690
223092870
847288609
900660121
987698769
999999999
0
Output for the Sample Input
1 5
16 1
2 1
1 2
16 4389
129 20995
4112949 206
15006 30011
46887 17718
163837 5994
Example
Input
15
16
2
3
9699690
223092870
847288609
900660121
987698769
999999999
0
Output
1 5
16 1
2 1
1 2
16 4389
129 20995
4112949 206
15006 30011
46887 17718
163837 5994 | ```python
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
def f(n):
t = int((n * 2) ** 0.5) + 1
for i in range(t,1,-1):
if i % 2 == 1:
if n % i == 0 and n // i > i // 2:
return '{} {}'.format(n//i-i//2, i)
else:
if n%i != 0 and n*2 % i == 0 and n // i + 1 > i // 2:
return '{} {}'.format(n//i-i//2+1, i)
return '{} {}'.format(n, 1)
while 1:
n = I()
if n == 0:
break
rr.append(f(n))
# print('nrr',n,rr[-1])
return '\n'.join(map(str, rr))
print(main())
``` |
p01410 Dangerous Tower | Training is indispensable for achieving good results at ICPC. Rabbit wants to win at ICPC, so he decided to practice today as well.
Today's training is to gain dexterity that never mistypes by carefully stacking blocks. Since there are many building blocks, let's build a tall tower.
There are N blocks, and the i-th (1 ≤ i ≤ N) building blocks are in the shape of a rectangular parallelepiped of 1 x Ai x Bi. The side of length 1 is used in the depth direction, and the sides of lengths Ai and Bi are assigned one by one in the horizontal direction and one in the height direction. When building blocks, the upper building blocks must be exactly shorter in width than the lower building blocks. The blocks can be used in any order, and some blocks may not be used. Under these restrictions, I want to make the tallest tower that can be built.
Input
N
A1 B1
...
AN BN
Satisfy 1 ≤ N ≤ 1,000, 1 ≤ Ai, Bi ≤ 1,000,000. All input values are integers.
Output
Output the maximum height of the tower on one line.
Examples
Input
3
10 40
10 40
20 30
Output
80
Input
4
1 2
2 3
3 4
4 1
Output
11 | ```python
import sys
readline = sys.stdin.readline
write = sys.stdout.write
from heapq import heappush, heappop
class MinCostFlow:
INF = 10**18
def __init__(self, N):
self.N = N
self.G = [[] for i in range(N)]
def add_edge(self, fr, to, cap, cost):
forward = [to, cap, cost, None]
backward = forward[3] = [fr, 0, -cost, forward]
self.G[fr].append(forward)
self.G[to].append(backward)
def flow(self, s, t, f):
N = self.N; G = self.G
INF = MinCostFlow.INF
res = 0
H = [0]*N
prv_v = [0]*N
prv_e = [None]*N
d0 = [INF]*N
dist = [INF]*N
while f:
dist[:] = d0
dist[s] = 0
que = [(0, s)]
while que:
c, v = heappop(que)
if dist[v] < c:
continue
r0 = dist[v] + H[v]
for e in G[v]:
w, cap, cost, _ = e
if cap > 0 and r0 + cost - H[w] < dist[w]:
dist[w] = r = r0 + cost - H[w]
prv_v[w] = v; prv_e[w] = e
heappush(que, (r, w))
if dist[t] == INF:
return None
for i in range(N):
H[i] += dist[i]
d = f; v = t
while v != s:
d = min(d, prv_e[v][1])
v = prv_v[v]
f -= d
res += d * H[t]
v = t
while v != s:
e = prv_e[v]
e[1] -= d
e[3][1] += d
v = prv_v[v]
return res
def solve():
N = int(readline())
P = [list(map(int, readline().split())) for i in range(N)]
s = set()
for a, b in P:
s.add(a); s.add(b)
S = sorted(s)
M = len(S)
mp = {e: i for i, e in enumerate(S)}
mcf = MinCostFlow(N+M+2)
for i in range(M):
mcf.add_edge(N+i, N+M+1, 1, 0)
for i, (a, b) in enumerate(P):
mcf.add_edge(N+M, i, 1, 0)
mcf.add_edge(i, N+M+1, 1, 0)
mcf.add_edge(i, N+mp[a], 1, -b)
mcf.add_edge(i, N+mp[b], 1, -a)
write("%d\n" % -mcf.flow(N+M, N+M+1, N))
solve()
``` |
p01726 Almost Same Substring | The unlucky Ikta-kun has rewritten the important character string T that he had to a different character string T'by the virus. It is known that the virus has rewritten one letter of T to a different letter. That is, T and T'are different by exactly one character. In order to restore T, Ikta prepared a document S in which T appears. As a preparation for restoring T, I would like to find out the number of substrings of S that may match T.
Given the string T'and the document S. S = a1 a2 a3 .. .a | S | length | T'| substring ak ak + 1 ... ak + | T'| −1 (1 ≤ k ≤ | S | − | T'| Find the number of things that differ by one character from T'in +1).
Input
The input is given in the following format.
S
T'
* S is given in the first line.
* T'is given in the second line.
* S and T'consist only of uppercase and lowercase alphabets, respectively.
Constraints
Each variable being input satisfies the following constraints.
* 1 ≤ | S | ≤ 300,000
* 1 ≤ | T'| ≤ | S |
Output
Output the number of substrings that satisfy the conditions on one line.
Examples
Input
abcbcdbc
abc
Output
2
Input
aaaaaa
aaaaaa
Output
0
Input
baaaaaaaa
b
Output
8 | ```python
import string
import sys
readline = sys.stdin.readline
write = sys.stdout.write
def solve():
s0 = "^" + string.ascii_uppercase + string.ascii_lowercase
*S, = map(s0.index, readline().strip()); N = len(S)
*T, = map(s0.index, readline().strip()); M = len(T)
base = 59; mod = 10**9 + 9
pw = [1]*(N+1)
r = 1
for i in range(N):
pw[i+1] = r = r * base % mod
h0 = [0]*(M+1)
r = 0
for i in range(M):
h0[i+1] = r = (r * base + T[i]) % mod
h1 = [0]*(N+1)
r = 0
for i in range(N):
h1[i+1] = r = (r * base + S[i]) % mod
ans = 0
for i in range(N-M+1):
left = 0; right = M+1
while left+1 < right:
mid = (left + right) >> 1
if h0[mid] == (h1[mid+i] - h1[i] * pw[mid]) % mod:
left = mid
else:
right = mid
if left < M:
if (h0[M] - h0[left+1] * pw[M - (left+1)]) % mod == (h1[M+i] - h1[i+left+1] * pw[M - (left+1)]) % mod:
ans += 1
write("%d\n" % ans)
solve()
``` |
p02000 Bumpy Array | problem
Given the sequence $ A $ of length $ N $. The $ i $ item in $ A $ is $ A_i $. You can do the following for this sequence:
* $ 1 \ leq i \ leq N --Choose the integer i that is 1 $. Swap the value of $ A_i $ with the value of $ A_ {i + 1} $.
Find the minimum number of operations required to make $ A $ a sequence of bumps.
A sequence of length $ N $ that satisfies the following conditions is defined as a sequence of irregularities.
* For any $ i $ that satisfies $ 1 <i <N $, $ A_ {i + 1}, A_ {i --1}> A_i $ or $ A_ {i + 1}, A_ {i --1} <A_i Satisfy $.
Intuitively, increase, decrease, increase ... (decrease, like $ 1, \ 10, \ 2, \ 30, \ \ dots (10, \ 1, \ 30, \ 2, \ \ dots) $ It is a sequence that repeats increase, decrease ...).
output
Output the minimum number of operations required to make a sequence of bumps. Also, output a line break at the end.
Example
Input
5
1 2 3 4 5
Output
2 | ```python
n = int(input())
a = list(map(int, input().split()))
ans = n
s = 0
b = [0 for i in range(n)]
for i in range(n):
b[i] = a[i]
for i in range(1,n):
if i%2 == 1:
if b[i] > b[i-1]:
flag = True
if i < n-1:
if b[i-1] > b[i+1] and b[i+1] < b[i]:
v = b[i+1]
b[i+1] = b[i]
b[i] = v
flag = False
if flag:
v = b[i-1]
b[i-1] = b[i]
b[i] = v
s += 1
else:
if b[i] < b[i-1]:
flag = True
if i < n-1:
if b[i-1] < b[i+1] and b[i+1] > b[i]:
v = b[i+1]
b[i+1] = b[i]
b[i] = v
flag = False
if flag:
v = b[i-1]
b[i-1] = b[i]
b[i] = v
s += 1
ans = min(ans, s)
s = 0
for i in range(n):
b[i] = a[i]
for i in range(1,n):
if i%2 == 0:
if b[i] > b[i-1]:
flag = True
if i < n-1:
if b[i-1] > b[i+1] and b[i+1] < b[i]:
v = b[i+1]
b[i+1] = b[i]
b[i] = v
flag = False
if flag:
v = b[i-1]
b[i-1] = b[i]
b[i] = v
s += 1
else:
if b[i] < b[i-1]:
flag = True
if i < n-1:
if b[i-1] < b[i+1] and b[i+1] > b[i]:
v = b[i+1]
b[i+1] = b[i]
b[i] = v
flag = False
if flag:
v = b[i-1]
b[i-1] = b[i]
b[i] = v
s += 1
ans = min(ans, s)
print(ans)
``` |
p02145 Shiritori | Problem
Here is a list of strings. Let's take a break and play with shiritori. Shiritori is performed according to the following rules.
1. First of all, select one of your favorite strings from the list and exclude that string from the list.
2. Next, select one character string from the list in which the last character of the previously selected character string is the first character.
3. Exclude the selected string from the list.
After this, steps 2 and 3 will be repeated alternately.
Now, let's assume that this shiritori is continued until there are no more strings to select from the list in 2. At this time, I want to list all the characters that can be the "last character" of the last selected character string.
Constraints
The input satisfies the following conditions.
* $ 1 \ le N \ lt 10 ^ 4 $
* $ 1 \ le | s_i | \ lt 100 $
* $ s_i \ neq s_j (i \ neq j) $
* The string contains only lowercase letters
Input
$ N $
$ s_1 $
$ s_2 $
$ s_3 $
::
$ s_N $
The number of strings $ N $ is given on the first line.
The following $ N $ line is given a list of strings.
Output
Output the characters that can be the "last character" of the last selected character string in ascending order from a to z in lexicographical order.
Examples
Input
5
you
ate
my
hum
toast
Output
e
t
u
Input
7
she
sells
sea
shells
by
the
seashore
Output
a
e
y | ```python
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby, combinations_with_replacement
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**10
mod = 10 ** 9 + 7
class Dinic:
def __init__(self, v, inf=10**10):
self.v = v
self.inf = inf
self.G = [[] for _ in range(v)]
self.level = [-1]*v # 深さ
self.ite = [0]*v # DFSでの探索が済んでいるか
def add_edge(self, fr, to, cap):
self.G[fr].append([to, cap, len(self.G[to])])
self.G[to].append([fr, 0, len(self.G[fr])-1])
def bfs(self, s): # BFSで深さ決定,sがstart
self.level = [-1]*self.v # 必要
self.level[s] = 0
Q = deque()
Q.append(s)
while Q:
v = Q.popleft()
for i in range(len(self.G[v])):
e = self.G[v][i]
if e[1]>0 and self.level[e[0]]<0: ###capacity>0かつtoの深さ未定
self.level[e[0]] = self.level[v]+1
Q.append(e[0])
def dfs(self, v, t, f): # DFSで増加パス探索,v開始、t終点、総フローf
if v==t:
return f
for i in range(self.ite[v], len(self.G[v])):
self.ite[v] = i
e = self.G[v][i]
if e[1]>0 and self.level[v]<self.level[e[0]]:
d = self.dfs(e[0], t, min(f, e[1]))
if d>0:
e[1] -= d # cap減少
self.G[e[0]][e[2]][1] += d # 逆辺のcap増加
return d
return 0
def max_flow(self, s, t):
flow = 0
while True:
self.bfs(s)
if self.level[t]<0:
return flow
self.ite = [0]*self.v # DFSでの探索が済んでいるか否か
f = self.dfs(s,t,self.inf)
while f>0:
flow += f
f = self.dfs(s,t,self.inf)
def ctoi(c):
return ord(c) - ord('a')
N = INT()
S = [input() for _ in range(N)]
ans = []
for i in range(len(ascii_lowercase)):
D = Dinic(len(ascii_lowercase)+2)
s = 26
t = s+1
deg_in = 0
deg_out = 0
for x in S:
u = ctoi(x[0])
v = ctoi(x[-1])
if u == i:
u = s
deg_out += 1
if v == i:
v = t
deg_in += 1
D.add_edge(u, v, 1)
f = D.max_flow(s, t)
if f >= deg_out and deg_in > 0:
ans.append(ascii_lowercase[i])
print(*ans, sep="\n")
``` |
p02286 Treap | A binary search tree can be unbalanced depending on features of data. For example, if we insert $n$ elements into a binary search tree in ascending order, the tree become a list, leading to long search times. One of strategies is to randomly shuffle the elements to be inserted. However, we should consider to maintain the balanced binary tree where different operations can be performed one by one depending on requirement.
We can maintain the balanced binary search tree by assigning a priority randomly selected to each node and by ordering nodes based on the following properties. Here, we assume that all priorities are distinct and also that all keys are distinct.
* binary-search-tree property. If $v$ is a left child of $u$, then $v.key < u.key$ and if $v$ is a right child of $u$, then $u.key < v.key$
* heap property. If $v$ is a child of $u$, then $v.priority < u.priority$
This combination of properties is why the tree is called Treap (tree + heap).
An example of Treap is shown in the following figure.
<image>
Insert
To insert a new element into a Treap, first of all, insert a node which a randomly selected priority value is assigned in the same way for ordinal binary search tree. For example, the following figure shows the Treap after a node with key = 6 and priority = 90 is inserted.
<image>
It is clear that this Treap violates the heap property, so we need to modify the structure of the tree by rotate operations. The rotate operation is to change parent-child relation while maintaing the binary-search-tree property.
<image>
The rotate operations can be implemented as follows.
rightRotate(Node t)
Node s = t.left
t.left = s.right
s.right = t
return s // the new root of subtree
|
leftRotate(Node t)
Node s = t.right
t.right = s.left
s.left = t
return s // the new root of subtree
---|---
The following figure shows processes of the rotate operations after the insert operation to maintain the properties.
<image>
The insert operation with rotate operations can be implemented as follows.
insert(Node t, int key, int priority) // search the corresponding place recursively
if t == NIL
return Node(key, priority) // create a new node when you reach a leaf
if key == t.key
return t // ignore duplicated keys
if key < t.key // move to the left child
t.left = insert(t.left, key, priority) // update the pointer to the left child
if t.priority < t.left.priority // rotate right if the left child has higher priority
t = rightRotate(t)
else // move to the right child
t.right = insert(t.right, key, priority) // update the pointer to the right child
if t.priority < t.right.priority // rotate left if the right child has higher priority
t = leftRotate(t)
return t
Delete
To delete a node from the Treap, first of all, the target node should be moved until it becomes a leaf by rotate operations. Then, you can remove the node (the leaf). These processes can be implemented as follows.
delete(Node t, int key) // seach the target recursively
if t == NIL
return NIL
if key < t.key // search the target recursively
t.left = delete(t.left, key)
else if key > t.key
t.right = delete(t.right, key)
else
return _delete(t, key)
return t
_delete(Node t, int key) // if t is the target node
if t.left == NIL && t.right == NIL // if t is a leaf
return NIL
else if t.left == NIL // if t has only the right child, then perform left rotate
t = leftRotate(t)
else if t.right == NIL // if t has only the left child, then perform right rotate
t = rightRotate(t)
else // if t has both the left and right child
if t.left.priority > t.right.priority // pull up the child with higher priority
t = rightRotate(t)
else
t = leftRotate(t)
return delete(t, key)
Write a program which performs the following operations to a Treap $T$ based on the above described algorithm.
* insert ($k$, $p$): Insert a node containing $k$ as key and $p$ as priority to $T$.
* find ($k$): Report whether $T$ has a node containing $k$.
* delete ($k$): Delete a node containing $k$.
* print(): Print the keys of the binary search tree by inorder tree walk and preorder tree walk respectively.
Constraints
* The number of operations $ \leq 200,000$
* $0 \leq k, p \leq 2,000,000,000$
* The height of the binary tree does not exceed 50 if you employ the above algorithm
* The keys in the binary search tree are all different.
* The priorities in the binary search tree are all different.
* The size of output $\leq 10$ MB
Input
In the first line, the number of operations $m$ is given. In the following $m$ lines, operations represented by insert $k \; p$, find $k$, delete $k$ or print are given.
Output
For each find($k$) operation, print "yes" if $T$ has a node containing $k$, "no" if not.
In addition, for each print operation, print a list of keys obtained by inorder tree walk and preorder tree walk in a line respectively. Put a space character before each key.
Example
Input
16
insert 35 99
insert 3 80
insert 1 53
insert 14 25
insert 80 76
insert 42 3
insert 86 47
insert 21 12
insert 7 10
insert 6 90
print
find 21
find 22
delete 35
delete 99
print
Output
1 3 6 7 14 21 35 42 80 86
35 6 3 1 14 7 21 80 42 86
yes
no
1 3 6 7 14 21 42 80 86
6 3 1 80 14 7 21 42 86 | ```python
from random import random
from collections import deque
from copy import deepcopy
import sys
input = sys.stdin.readline
class Treap:
def __init__(self, iterable=None):
# vertex = [left, right, key, priority, #descendants, sum of descendants]
self.root = None
if iterable: self._construct(iterable)
def _construct(self, iterable):
for it in iterable: self.insert(it)
def __len__(self): return self._count(self.root)
@staticmethod
def _count(v): return v[4] if v is not None else 0
def _rotate(self, v, direction): # rotate the vertex v to the given direction
c = v[1 - direction] # direction == 1: right rotation
v[1 - direction], t = c[direction], c[1 - direction]
c[direction] = v
# update vertex's information
n_desc, sum_desc = c[4:] = v[4:]
v[4:] = n_desc - 1 - self._count(t), sum_desc - (c[2] if c[2] else 0) - (t[5] if t else 0)
return c # new parent
def __contains__(self, key): # check whether the given key is in the treap
if self.root is None: return False
v = self.root
while v:
k = v[2]
if k == key: return True
v = v[key > k] # key > v[2] -> v = v[1] (right child)
return False
def __getitem__(self, i): # get the i-th smallest element in the treap
count = self._count
if i < 0: i = count(self.root) + i
if i >= count(self.root) or i < 0: raise IndexError
v = self.root
while True:
n_left = count(v[0])
if i == n_left: return v[2]
elif i > n_left: i -= n_left + 1; v = v[1]
else: v = v[0]
def __repr__(self): # visualize the treap
if not self.root: return 'Treap([])'
elements = []
q = deque([self.root])
while q:
v = q.popleft()
if v is None: elements.append(v); continue
elements.append((v[2], v[3]))
q.append(v[0]); q.append(v[1])
return 'Treap({})'.format(str(elements))
@classmethod
def _treap(cls, treapnode):
tp = cls(); tp.root = deepcopy(treapnode)
return tp
def sort(self):
if not self.root: return []
elements = []
stack = [(self.root, 0)]
while stack:
v, st = stack.pop()
[left, right, k, _, _, _] = v
if st == 0:
if right: stack.append((right, 0))
stack.append((v, 1))
if left: stack.append((left, 0))
if st == 1: elements.append(k)
return elements
def bisect(self, key): # bisect_right
if self.root is None: return 0
v = self.root; idx = 0
count = self._count
while v:
left, right, k, _, _, _ = v
if key >= k: idx += count(left) + 1; v = right
else: v = left
return idx
def insert(self, key, priority=None):
if priority is None: priority = random()
rotate = self._rotate
v = self.root; p = None; direction = None
stack = []
while v:
direction = (key >= v[2])
stack.append((v, direction))
v, p = v[direction], v
v = [None, None, key, priority, 1, key]
while stack:
p, direction = stack.pop()
p[direction] = v
p[4] += 1; p[5] += key # update vertex's information
if p[3] >= v[3]: break
v = rotate(p, 1 - direction)
else: self.root = v
for p, _ in stack: p[4] += 1; p[5] += key # update vertex's information
return self.root
def delete(self, key):
v = self.root; p = None; direction = None
stack = []
while v:
if key == v[2]: break # vertex to be deleted has been found
direction = (key > v[2])
stack.append((v, direction))
v, p = v[direction], v
else: return self.root # the given key is not in the treap
rotate = self._rotate
while v[0] or v[1]: # while v is not a leaf
left, right, _, _, _, _ = v
direction = (left[3] > right[3]) if left and right else (right is None)
p = rotate(v, direction)
stack.append((p, direction)); v = p[direction]
v = None # delete
while stack:
p, direction = stack.pop()
p[direction] = v
p[4] -= 1; p[5] -= (key if key else 0) # update vertex's information
v = p
self.root = v
return self.root
def merge(self, other):
r, o = self.root, other.root
temp_v = [r, o, None, float('inf'), 1 + r[4] + o[4], r[5] + o[5]]
virtual = self._treap(temp_v)
self.root = virtual.delete(None)
return self.root
def split(self, i):
count = self._count
if i < 0: i = count(self.root) + i
if i >= count(self.root) or i < 0: raise IndexError
rotate = self._rotate
v = self.root; p = None; direction = None
stack = []
while v:
n_left = count(v[0])
direction = (i > n_left)
stack.append((v, direction))
if direction: i -= n_left + 1
v, p = v[direction], v
v = [None, None, None, float('inf'), 1, 0]
while stack:
p, direction = stack.pop()
p[direction] = v
p[4] += 1; p[5] += 0 # update vertex's information
v = rotate(p, 1 - direction)
l, r = v[:2]
self.root = l
return self._treap(r)
def print_treap(tr):
preorder = ['']
inorder = ['']
def dfs(vtx):
v = str(vtx[2])
preorder.append(v)
if vtx[0]: dfs(vtx[0])
inorder.append(v)
if vtx[1]: dfs(vtx[1])
dfs(tr.root)
print(' '.join(inorder))
print(' '.join(preorder))
return
m = int(input())
tr = Treap()
for _ in range(m):
query, *args, = input().split()
if query == 'insert':
k, p = map(int, args)
tr.insert(k, p)
elif query == 'find':
k = int(args[0])
print('yes' if k in tr else 'no')
elif query == 'delete':
k = int(args[0])
tr.delete(k)
else:
print_treap(tr)
``` |
p02433 List | For a dynamic list $L$ of integers, perform a sequence of the following operations. $L$ has a special element called END at the end of the list and an element of $L$ is indicated by a cursor.
* insert($x$): Insert $x$ before the element indicated by the cursor. After this operation, the cursor points the inserted element.
* move($d$): Move the cursor to the end by $d$, if $d$ is positive. Move the cursor to the front by $d$, if $d$ is negative.
* erase(): Delete the element indicated by the cursor. After this operation, the cursor points the element next to the deleted element. In case there is no such element, the cursor should point END.
In the initial state, $L$ is empty and the cursor points END.
Constraints
* $1 \leq q \leq 500,000$
* The cursor indicates an element of $L$ or END during the operations
* Erase operation will not given when the cursor points END
* $-1,000,000,000 \leq x \leq 1,000,000,000$
* Moving distance of the cursor ($\sum{|d|}$) does not exceed 1,000,000
* $L$ is not empty after performing all operations
Input
The input is given in the following format.
$q$
$query_1$
$query_2$
:
$query_q$
Each query $query_i$ is given by
0 $x$
or
1 $d$
or
2
where the first digits 0, 1 and 2 represent insert, move and erase operations respectively.
Output
Print all elements of the list in order after performing given operations. Print an element in a line.
Example
Input
5
0 1
0 2
0 3
1 1
2
Output
3
1 | ```python
q = int(input())
A = [0 for i in range(1500000)]
A[0] = 'end'
cursor = 0
head = [0 for i in range(1500000)]
head_len = 0
def insert(x):
global cursor
cursor += 1
A[cursor] = x
def move(d):
global cursor, head, head_len
if d >= 0:
head[head_len-1+d+(1): head_len-1+(1):-1] = A[cursor-d+1:cursor+1]
else:
A[cursor+1:cursor+1+(-d)] = head[head_len-1+(1):head_len-(-d)-1+(1):-1]
cursor -= d
head_len += d
def erase():
global cursor
cursor -= 1
for i in range(q):
a = input()
if a != "2":
b = [int(i) for i in a.split()]
if b[0] == 0:
insert(b[1])
elif b[0] == 1:
move(b[1])
else:
erase()
#print(A[:cursor+1],head[1:1+head_len][::-1])
A[cursor+1:cursor+1+head_len] = head[head_len-1+(1):-1+(1):-1]
length = cursor + head_len
for i in range(1,length+1)[::-1]:
print(A[i])
``` |
1006_C. Three Parts of the Array | You are given an array d_1, d_2, ..., d_n consisting of n integer numbers.
Your task is to split this array into three parts (some of which may be empty) in such a way that each element of the array belongs to exactly one of the three parts, and each of the parts forms a consecutive contiguous subsegment (possibly, empty) of the original array.
Let the sum of elements of the first part be sum_1, the sum of elements of the second part be sum_2 and the sum of elements of the third part be sum_3. Among all possible ways to split the array you have to choose a way such that sum_1 = sum_3 and sum_1 is maximum possible.
More formally, if the first part of the array contains a elements, the second part of the array contains b elements and the third part contains c elements, then:
$$$sum_1 = ∑_{1 ≤ i ≤ a}d_i, sum_2 = ∑_{a + 1 ≤ i ≤ a + b}d_i, sum_3 = ∑_{a + b + 1 ≤ i ≤ a + b + c}d_i.$$$
The sum of an empty array is 0.
Your task is to find a way to split the array such that sum_1 = sum_3 and sum_1 is maximum possible.
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in the array d.
The second line of the input contains n integers d_1, d_2, ..., d_n (1 ≤ d_i ≤ 10^9) — the elements of the array d.
Output
Print a single integer — the maximum possible value of sum_1, considering that the condition sum_1 = sum_3 must be met.
Obviously, at least one valid way to split the array exists (use a=c=0 and b=n).
Examples
Input
5
1 3 1 1 4
Output
5
Input
5
1 3 2 1 4
Output
4
Input
3
4 1 2
Output
0
Note
In the first example there is only one possible splitting which maximizes sum_1: [1, 3, 1], [~], [1, 4].
In the second example the only way to have sum_1=4 is: [1, 3], [2, 1], [4].
In the third example there is only one way to split the array: [~], [4, 1, 2], [~]. | ```python
x = int(input())
v = list(map(int,input().strip().split()))[:x]
i = 0
j = x-1
s1 = 0
s2 = 0
ans = 0
while(i<=j):
if(s2<s1):
s2+=v[j]
j=j-1
else:
s1+=v[i]
i=i+1
if(s1==s2):
ans=s1
print(ans)
``` |
102_B. Sum of Digits | Having watched the last Harry Potter film, little Gerald also decided to practice magic. He found in his father's magical book a spell that turns any number in the sum of its digits. At the moment Gerald learned that, he came across a number n. How many times can Gerald put a spell on it until the number becomes one-digit?
Input
The first line contains the only integer n (0 ≤ n ≤ 10100000). It is guaranteed that n doesn't contain any leading zeroes.
Output
Print the number of times a number can be replaced by the sum of its digits until it only contains one digit.
Examples
Input
0
Output
0
Input
10
Output
1
Input
991
Output
3
Note
In the first sample the number already is one-digit — Herald can't cast a spell.
The second test contains number 10. After one casting of a spell it becomes 1, and here the process is completed. Thus, Gerald can only cast the spell once.
The third test contains number 991. As one casts a spell the following transformations take place: 991 → 19 → 10 → 1. After three transformations the number becomes one-digit. | ```python
num = input()
c = 0
while(len(num) != 1):
num = str(sum(int(i) for i in num))
c += 1
print(c)
``` |
1051_B. Relatively Prime Pairs | You are given a set of all integers from l to r inclusive, l < r, (r - l + 1) ≤ 3 ⋅ 10^5 and (r - l) is always odd.
You want to split these numbers into exactly (r - l + 1)/(2) pairs in such a way that for each pair (i, j) the greatest common divisor of i and j is equal to 1. Each number should appear in exactly one of the pairs.
Print the resulting pairs or output that no solution exists. If there are multiple solutions, print any of them.
Input
The only line contains two integers l and r (1 ≤ l < r ≤ 10^{18}, r - l + 1 ≤ 3 ⋅ 10^5, (r - l) is odd).
Output
If any solution exists, print "YES" in the first line. Each of the next (r - l + 1)/(2) lines should contain some pair of integers. GCD of numbers in each pair should be equal to 1. All (r - l + 1) numbers should be pairwise distinct and should have values from l to r inclusive.
If there are multiple solutions, print any of them.
If there exists no solution, print "NO".
Example
Input
1 8
Output
YES
2 7
4 1
3 8
6 5 | ```python
l,r=map(int,input().split())
print('YES')
for i in range((r-l+1)//2):
print(l+i*2,l+i*2+1)
``` |
1073_C. Vasya and Robot | Vasya has got a robot which is situated on an infinite Cartesian plane, initially in the cell (0, 0). Robot can perform the following four kinds of operations:
* U — move from (x, y) to (x, y + 1);
* D — move from (x, y) to (x, y - 1);
* L — move from (x, y) to (x - 1, y);
* R — move from (x, y) to (x + 1, y).
Vasya also has got a sequence of n operations. Vasya wants to modify this sequence so after performing it the robot will end up in (x, y).
Vasya wants to change the sequence so the length of changed subsegment is minimum possible. This length can be calculated as follows: maxID - minID + 1, where maxID is the maximum index of a changed operation, and minID is the minimum index of a changed operation. For example, if Vasya changes RRRRRRR to RLRRLRL, then the operations with indices 2, 5 and 7 are changed, so the length of changed subsegment is 7 - 2 + 1 = 6. Another example: if Vasya changes DDDD to DDRD, then the length of changed subsegment is 1.
If there are no changes, then the length of changed subsegment is 0. Changing an operation means replacing it with some operation (possibly the same); Vasya can't insert new operations into the sequence or remove them.
Help Vasya! Tell him the minimum length of subsegment that he needs to change so that the robot will go from (0, 0) to (x, y), or tell him that it's impossible.
Input
The first line contains one integer number n~(1 ≤ n ≤ 2 ⋅ 10^5) — the number of operations.
The second line contains the sequence of operations — a string of n characters. Each character is either U, D, L or R.
The third line contains two integers x, y~(-10^9 ≤ x, y ≤ 10^9) — the coordinates of the cell where the robot should end its path.
Output
Print one integer — the minimum possible length of subsegment that can be changed so the resulting sequence of operations moves the robot from (0, 0) to (x, y). If this change is impossible, print -1.
Examples
Input
5
RURUU
-2 3
Output
3
Input
4
RULR
1 1
Output
0
Input
3
UUU
100 100
Output
-1
Note
In the first example the sequence can be changed to LULUU. So the length of the changed subsegment is 3 - 1 + 1 = 3.
In the second example the given sequence already leads the robot to (x, y), so the length of the changed subsegment is 0.
In the third example the robot can't end his path in the cell (x, y). | ```python
# -*- coding: utf-8 -*-
"""
created by shhuan at 2018/11/3 11:30
search for minimum steps, consider binary search
"""
N = int(input())
ops = [x for x in input()]
X, Y = map(int, input().split())
dd = abs(X) + abs(Y)
lops = len(ops)
if dd > lops or (lops - dd) % 2 != 0:
print(-1)
exit(0)
[ll, lr, lu, ld, rl, rr, ru, rd] = [[0 for _ in range(lops + 2)] for _ in range(8)]
l, r, u, d = 0, 0, 0, 0
for i in range(lops):
op = ops[i]
if op == 'L':
l += 1
elif op == 'R':
r += 1
elif op == 'U':
u += 1
else:
d += 1
ll[i+1] = l
lr[i+1] = r
ld[i+1] = d
lu[i+1] = u
l, r, u, d = 0, 0, 0, 0
for i in range(lops-1, -1, -1):
op = ops[i]
if op == 'L':
l += 1
elif op == 'R':
r += 1
elif op == 'U':
u += 1
else:
d += 1
rl[i] = l
rr[i] = r
rd[i] = d
ru[i] = u
def check(lsub):
for i in range(lops-lsub+1):
# j-i+1 == lsub, j < lops => i+lsub-1 <lops => i < lops-lsub+1
j = i + lsub - 1
# l, r, u, d of lops [0, i-1], ll[i]={'L' of 0,...,i-1}
l0, r0, u0, d0 = ll[i], lr[i], lu[i], ld[i]
# l, r, u, d of ops [j+1, N-1], rr[j]={'R' of lops-1,...,j}
l1, r1, u1, d1 = rl[j+1], rr[j+1], ru[j+1], rd[j+1]
x = (r0+r1) - (l0+l1)
y = (u0+u1) - (d0+d1)
dx = abs(X-x)
dy = abs(Y-y)
if dx + dy <= lsub and (lsub-dx-dy) % 2 == 0:
return True
return False
sl, sr = 0, lops + 1
while sl < sr:
m = (sl + sr) // 2
if check(m):
sr = m
else:
sl = m + 1
sl = -1 if sl > lops else sl
print(sl)
``` |
1095_C. Powers Of Two | A positive integer x is called a power of two if it can be represented as x = 2^y, where y is a non-negative integer. So, the powers of two are 1, 2, 4, 8, 16, ....
You are given two positive integers n and k. Your task is to represent n as the sum of exactly k powers of two.
Input
The only line of the input contains two integers n and k (1 ≤ n ≤ 10^9, 1 ≤ k ≤ 2 ⋅ 10^5).
Output
If it is impossible to represent n as the sum of k powers of two, print NO.
Otherwise, print YES, and then print k positive integers b_1, b_2, ..., b_k such that each of b_i is a power of two, and ∑ _{i = 1}^{k} b_i = n. If there are multiple answers, you may print any of them.
Examples
Input
9 4
Output
YES
1 2 2 4
Input
8 1
Output
YES
8
Input
5 1
Output
NO
Input
3 7
Output
NO | ```python
import math
n,k=[int(x) for x in input().split()]
s=k
arr= [1 for i in range(k)]
i = k - 1
while(i >= 0):
while (s+ arr[i] <= n):
s += arr[i]
arr[i] *= 2
i -= 1
if (s != n):
print("NO")
else:
print("YES")
for i in range(0, k, 1):
print(arr[i], end = ' ')
'''n=int(input())
s=input()
i=0
j=1
ans=""
while(i<len(s)):
ans+=s[i]
j+=1
i+=j
print(ans)'''
'''n=int(input())
arr=[int(x) for x in input().split()]
m=max(arr)
i=arr.index(m)
del(arr[i])
m=max(arr)
min_=min(arr)
print(m-min_)'''
``` |
1114_D. Flood Fill | You are given a line of n colored squares in a row, numbered from 1 to n from left to right. The i-th square initially has the color c_i.
Let's say, that two squares i and j belong to the same connected component if c_i = c_j, and c_i = c_k for all k satisfying i < k < j. In other words, all squares on the segment from i to j should have the same color.
For example, the line [3, 3, 3] has 1 connected component, while the line [5, 2, 4, 4] has 3 connected components.
The game "flood fill" is played on the given line as follows:
* At the start of the game you pick any starting square (this is not counted as a turn).
* Then, in each game turn, change the color of the connected component containing the starting square to any other color.
Find the minimum number of turns needed for the entire line to be changed into a single color.
Input
The first line contains a single integer n (1 ≤ n ≤ 5000) — the number of squares.
The second line contains integers c_1, c_2, …, c_n (1 ≤ c_i ≤ 5000) — the initial colors of the squares.
Output
Print a single integer — the minimum number of the turns needed.
Examples
Input
4
5 2 2 1
Output
2
Input
8
4 5 2 2 1 3 5 5
Output
4
Input
1
4
Output
0
Note
In the first example, a possible way to achieve an optimal answer is to pick square with index 2 as the starting square and then play as follows:
* [5, 2, 2, 1]
* [5, 5, 5, 1]
* [1, 1, 1, 1]
In the second example, a possible way to achieve an optimal answer is to pick square with index 5 as the starting square and then perform recoloring into colors 2, 3, 5, 4 in that order.
In the third example, the line already consists of one color only. | ```python
def run_length_compress(string):
string = string + ["."]
n = len(string)
begin = 0
end = 1
cnt = 1
ans = []
while True:
if end >= n:
break
if string[begin] == string[end]:
end += 1
cnt += 1
else:
ans.append(string[begin])
begin = end
end = begin + 1
cnt = 1
return ans
def lps(string):
n = len(string)
dp = [[0]*n for _ in range(n)]
for i in range(n):
dp[i][i] = 1
for cl in range(2, n+1):
for i in range(n-cl+1):
j = i + cl - 1
if string[i] == string[j] and cl == 2:
dp[i][j] = 2
elif string[i] == string[j]:
dp[i][j] = dp[i+1][j-1] + 2
else:
dp[i][j] = max(dp[i][j-1], dp[i+1][j])
return dp[0][n-1]
n = int(input())
a = list(map(int, input().split()))
a = run_length_compress(a)
len_pal = lps(a)
print(len(a) - 1 - len_pal//2)
``` |
1163_A. Eating Soup | The three friends, Kuro, Shiro, and Katie, met up again! It's time for a party...
What the cats do when they unite? Right, they have a party. Since they wanted to have as much fun as possible, they invited all their friends. Now n cats are at the party, sitting in a circle and eating soup. The rules are simple: anyone having finished their soup leaves the circle.
Katie suddenly notices that whenever a cat leaves, the place where she was sitting becomes an empty space, which means the circle is divided into smaller continuous groups of cats sitting next to each other. At the moment Katie observes, there are m cats who left the circle. This raises a question for Katie: what is the maximum possible number of groups the circle is divided into at the moment?
Could you help her with this curiosity?
You can see the examples and their descriptions with pictures in the "Note" section.
Input
The only line contains two integers n and m (2 ≤ n ≤ 1000, 0 ≤ m ≤ n) — the initial number of cats at the party and the number of cats who left the circle at the moment Katie observes, respectively.
Output
Print a single integer — the maximum number of groups of cats at the moment Katie observes.
Examples
Input
7 4
Output
3
Input
6 2
Output
2
Input
3 0
Output
1
Input
2 2
Output
0
Note
In the first example, originally there are 7 cats sitting as shown below, creating a single group:
<image>
At the observed moment, 4 cats have left the table. Suppose the cats 2, 3, 5 and 7 have left, then there are 3 groups remaining. It is possible to show that it is the maximum possible number of groups remaining.
<image>
In the second example, there are 6 cats sitting as shown below:
<image>
At the observed moment, 2 cats have left the table. Suppose the cats numbered 3 and 6 left, then there will be 2 groups remaining (\{1, 2\} and \{4, 5\}). It is impossible to have more than 2 groups of cats remaining.
<image>
In the third example, no cats have left, so there is 1 group consisting of all cats.
In the fourth example, all cats have left the circle, so there are 0 groups. | ```python
n , m = map(int,input().split())
import math
if n==m:
print(0)
elif m==0:
print(1)
elif m==1:
print(1)
else:
if n%2==0:
if n//2==m:
print(n//2)
elif m>n//2:
print(n-m)
else:
print(m)
else:
if math.ceil(n//2)==m or math.floor(n//2)==m:
print(math.floor(n//2))
elif math.floor(n//2)>m:
print(m)
else:
print(n-m)
``` |
1183_F. Topforces Strikes Back | One important contest will take place on the most famous programming platform (Topforces) very soon!
The authors have a pool of n problems and should choose at most three of them into this contest. The prettiness of the i-th problem is a_i. The authors have to compose the most pretty contest (in other words, the cumulative prettinesses of chosen problems should be maximum possible).
But there is one important thing in the contest preparation: because of some superstitions of authors, the prettinesses of problems cannot divide each other. In other words, if the prettinesses of chosen problems are x, y, z, then x should be divisible by neither y, nor z, y should be divisible by neither x, nor z and z should be divisible by neither x, nor y. If the prettinesses of chosen problems are x and y then neither x should be divisible by y nor y should be divisible by x. Any contest composed from one problem is considered good.
Your task is to find out the maximum possible total prettiness of the contest composed of at most three problems from the given pool.
You have to answer q independent queries.
If you are Python programmer, consider using PyPy instead of Python when you submit your code.
Input
The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries.
The first line of the query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of problems.
The second line of the query contains n integers a_1, a_2, ..., a_n (2 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the prettiness of the i-th problem.
It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.
Output
For each query print one integer — the maximum possible cumulative prettiness of the contest composed of at most three problems from the given pool of problems in the query.
Example
Input
3
4
5 6 15 30
4
10 6 30 15
3
3 4 6
Output
30
31
10 | ```python
from sys import stdin
from itertools import tee
def input():
return stdin.readline()
def remove_divisors(x, xs):
return [y for y in xs if y%xs != 0]
q = int(input())
for _ in range(q):
n = int(input())
aas = list(set(map(int,input().split())))
aas.sort(reverse=True)
# if len(aas) > 2 and aas[1]*2 > aas[0] and aas[2]*2 > aas[0]:
# print(sum(aas[0:3]))
# continue
ulim2 = list(map(sum, zip(aas[:-1], aas[1:]))) + [0]
ulim3 = list(map(sum, zip(aas[:-2], ulim2[1:]))) + [0,0]
it1 = iter(zip(aas, ulim3, ulim2))
answer = 0
try:
while True:
a, u3, _ = next(it1)
if u3 < answer:
break
it1, it2 = tee(it1)
def f1(i):
b, _, _ = i
return a%b != 0
it2 = filter(f1, it2)
tsum = 0
try:
while True:
b, _, u2 = next(it2)
if u2 < tsum:
break
it2, it3 = tee(it2)
def f2(i):
c, _, _ = i
return b%c != 0
it3 = filter (f2 , it3)
c,_,_ = next(it3, (0,0,0))
tsum = max(tsum, b+c)
except StopIteration:
pass
answer = max(answer, a + tsum)
except StopIteration:
pass
print(answer)
``` |
1201_A. Important Exam | A class of students wrote a multiple-choice test.
There are n students in the class. The test had m questions, each of them had 5 possible answers (A, B, C, D or E). There is exactly one correct answer for each question. The correct answer for question i worth a_i points. Incorrect answers are graded with zero points.
The students remember what answers they gave on the exam, but they don't know what are the correct answers. They are very optimistic, so they want to know what is the maximum possible total score of all students in the class.
Input
The first line contains integers n and m (1 ≤ n, m ≤ 1000) — the number of students in the class and the number of questions in the test.
Each of the next n lines contains string s_i (|s_i| = m), describing an answer of the i-th student. The j-th character represents the student answer (A, B, C, D or E) on the j-th question.
The last line contains m integers a_1, a_2, …, a_m (1 ≤ a_i ≤ 1000) — the number of points for the correct answer for every question.
Output
Print a single integer — the maximum possible total score of the class.
Examples
Input
2 4
ABCD
ABCE
1 2 3 4
Output
16
Input
3 3
ABC
BCD
CDE
5 4 12
Output
21
Note
In the first example, one of the most optimal test answers is "ABCD", this way the total number of points will be 16.
In the second example, one of the most optimal test answers is "CCC", this way each question will be answered by exactly one student and the total number of points is 5 + 4 + 12 = 21. | ```python
def get_ints():
return list(map(int, input().split()))
N, M = get_ints()
a = [input() for i in range(N)]
s = get_ints()
ans=0
for i in range(M):
d = {}
for row in a:
c = ord(row[i])-65
if c in d:
d[c]+=1
else:
d[c]=1
ans += max(d.values())*s[i]
print(ans)
``` |
1243_A. Maximum Square | Ujan decided to make a new wooden roof for the house. He has n rectangular planks numbered from 1 to n. The i-th plank has size a_i × 1 (that is, the width is 1 and the height is a_i).
Now, Ujan wants to make a square roof. He will first choose some of the planks and place them side by side in some order. Then he will glue together all of these planks by their vertical sides. Finally, he will cut out a square from the resulting shape in such a way that the sides of the square are horizontal and vertical.
For example, if Ujan had planks with lengths 4, 3, 1, 4 and 5, he could choose planks with lengths 4, 3 and 5. Then he can cut out a 3 × 3 square, which is the maximum possible. Note that this is not the only way he can obtain a 3 × 3 square.
<image>
What is the maximum side length of the square Ujan can get?
Input
The first line of input contains a single integer k (1 ≤ k ≤ 10), the number of test cases in the input.
For each test case, the first line contains a single integer n (1 ≤ n ≤ 1 000), the number of planks Ujan has in store. The next line contains n integers a_1, …, a_n (1 ≤ a_i ≤ n), the lengths of the planks.
Output
For each of the test cases, output a single integer, the maximum possible side length of the square.
Example
Input
4
5
4 3 1 4 5
4
4 4 4 4
3
1 1 1
5
5 5 1 1 5
Output
3
4
1
3
Note
The first sample corresponds to the example in the statement.
In the second sample, gluing all 4 planks will result in a 4 × 4 square.
In the third sample, the maximum possible square is 1 × 1 and can be taken simply as any of the planks. | ```python
n=int(input())
for _ in range(n):
i=int(input())
ar=sorted(list(map(int,input().split())))[::-1]
mx=0
for e in range(i):
mx=max(mx,min(e+1,ar[e]))
print(mx)
``` |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.