text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After Fox Ciel got off a bus, she found that the bus she was on was a wrong bus and she lost her way in a strange town. However, she fortunately met her friend Beaver Taro and asked which way to go to her castle. Taro's response to her was a string s, and she tried to remember the string s correctly.
However, Ciel feels n strings b1, b2, ... , bn are really boring, and unfortunately she dislikes to remember a string that contains a boring substring. To make the thing worse, what she can remember is only the contiguous substring of s.
Determine the longest contiguous substring of s that does not contain any boring string, so that she can remember the longest part of Taro's response.
Input
In the first line there is a string s. The length of s will be between 1 and 105, inclusive.
In the second line there is a single integer n (1 ≤ n ≤ 10). Next n lines, there is a string bi (1 ≤ i ≤ n). Each length of bi will be between 1 and 10, inclusive.
Each character of the given strings will be either a English alphabet (both lowercase and uppercase) or a underscore ('_') or a digit. Assume that these strings are case-sensitive.
Output
Output in the first line two space-separated integers len and pos: the length of the longest contiguous substring of s that does not contain any bi, and the first position of the substring (0-indexed). The position pos must be between 0 and |s| - len inclusive, where |s| is the length of string s.
If there are several solutions, output any.
Examples
Input
Go_straight_along_this_street
5
str
long
tree
biginteger
ellipse
Output
12 4
Input
IhaveNoIdea
9
I
h
a
v
e
N
o
I
d
Output
0 0
Input
unagioisii
2
ioi
unagi
Output
5 5
Note
In the first sample, the solution is traight_alon.
In the second sample, the solution is an empty string, so the output can be «0 0», «0 1», «0 2», and so on.
In the third sample, the solution is either nagio or oisii.
Submitted Solution:
```
a=input()
n=int(input())
b=[]
for i in range(n):
c=input()
d=a.find(c)
while d!=-1:
b.append([d,len(c)])
d=a.find(c,d+1)
b.sort()
b.append([b[-1][0]+1,len(a)-b[-1][0]])
c=[]
for i in range(len(b)-1):
c.append([b[i+1][0]+b[i+1][1]-b[i][0]-2,b[i][0]+1])
c.sort()
print(*c[-1])
```
No
| 89,800 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After Fox Ciel got off a bus, she found that the bus she was on was a wrong bus and she lost her way in a strange town. However, she fortunately met her friend Beaver Taro and asked which way to go to her castle. Taro's response to her was a string s, and she tried to remember the string s correctly.
However, Ciel feels n strings b1, b2, ... , bn are really boring, and unfortunately she dislikes to remember a string that contains a boring substring. To make the thing worse, what she can remember is only the contiguous substring of s.
Determine the longest contiguous substring of s that does not contain any boring string, so that she can remember the longest part of Taro's response.
Input
In the first line there is a string s. The length of s will be between 1 and 105, inclusive.
In the second line there is a single integer n (1 ≤ n ≤ 10). Next n lines, there is a string bi (1 ≤ i ≤ n). Each length of bi will be between 1 and 10, inclusive.
Each character of the given strings will be either a English alphabet (both lowercase and uppercase) or a underscore ('_') or a digit. Assume that these strings are case-sensitive.
Output
Output in the first line two space-separated integers len and pos: the length of the longest contiguous substring of s that does not contain any bi, and the first position of the substring (0-indexed). The position pos must be between 0 and |s| - len inclusive, where |s| is the length of string s.
If there are several solutions, output any.
Examples
Input
Go_straight_along_this_street
5
str
long
tree
biginteger
ellipse
Output
12 4
Input
IhaveNoIdea
9
I
h
a
v
e
N
o
I
d
Output
0 0
Input
unagioisii
2
ioi
unagi
Output
5 5
Note
In the first sample, the solution is traight_alon.
In the second sample, the solution is an empty string, so the output can be «0 0», «0 1», «0 2», and so on.
In the third sample, the solution is either nagio or oisii.
Submitted Solution:
```
R = lambda : map(int, input().split())
s = input()
n = int(input())
words = [input() for i in range(n)]
dp = [-1] * len(s)
for w in words:
si = 0
while si != -1:
si = s.find(w, si)
if si >= 0:
dp[si + len(w) - 1] = max(si + 1, dp[si + len(w) - 1])
si += 1
fl = 0
fr = 0
l = 0
found = False
for r in range(len(s)):
if dp[r] >= 0:
l = max(l, dp[r])
if r - l > fr - fl:
found = True
fl, fr = l, r
print(fr - fl + found, fl)
```
No
| 89,801 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
s = list(map(int, input().split()))
ans = 0
x0 = 0
x1 = 0
for i in range(n):
if s[i] == 1:
x1 = max(x0, x1) + 1
else:
x0 = x0 + 1
ans = max(x0, x1)
print(ans)
```
| 89,802 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
string = ''.join(map(str, input().split()))
maxx = 0
for i in range(n+1):
maxx = max(maxx, string[:i].count('0')+string[i:].count('1'))
print(maxx)
```
| 89,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
a=int(input())
b=input().split()
zerocount=0
zero=[]
onecount=0
one=[]
maxi=0
for i in range(a):
if(b[i]=='0'):
zerocount+=1
zero.append(zerocount)
for i in range(a-1, -1, -1):
if(b[i]=='1'):
onecount+=1
one.append(onecount)
one.reverse()
if(maxi<one[0]):
maxi=one[0]
for i in range(a-1):
if(maxi<zero[i]+one[i+1]):
maxi=zero[i]+one[i+1]
if(maxi<zero[a-1]):
maxi=zero[a-1]
print(maxi)
```
| 89,804 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
def solve(n, games):
games_to_keep = 0
# Calculate prefix for ones (how many ones from start to i)
ones_prefix = [0 for i in range(n)]
if games[0] == '1':
ones_prefix[0] = 1
for i in range(1, n):
ones_prefix[i] = ones_prefix[i-1]
if games[i] == '1':
ones_prefix[i] += 1
# Find max subsequence [0000000.....11111111]
def ones_after(pos):
return ones_prefix[-1] - ones_prefix[pos]
zeros_cnt = 0
for i, game in enumerate(games):
if game == '0':
zeros_cnt += 1
ones_after_zero = ones_after(i)
games_lasts = zeros_cnt + ones_after_zero
if games_lasts > games_to_keep:
games_to_keep = games_lasts
# Leave only zeros or only ones
ones_count = ones_prefix[-1]
zeros_count = n - ones_count
games_to_keep = max(games_to_keep, ones_count, zeros_count)
return games_to_keep
def main():
n = int(input())
games = input().split()
print(solve(n, games))
main()
```
| 89,805 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
input()
n = [int(x) for x in input().split()]
a = -1
aa = 0
for i, x in enumerate(n):
aaa = aa + len([x for x in n[i:] if x])
if aaa > a:
a = aaa
if not x:
aa += 1
print(max(a,aa))
```
| 89,806 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
p = list(map(int, input().split()))
ind_z = []
ind_o = []
for i in range(n):
if p[i] == 0:
ind_z.append(i)
else:
ind_o.append(i)
z = [0] * len(ind_z)
o = [0] * len(ind_o)
for i in range(len(z)):
z[i] = i + 1
for j in range(ind_z[i], n):
if p[j] == 1:
z[i] += 1
for i in range(len(o)):
o[i] = len(o) - i
for j in range(ind_o[i] - 1, -1, -1):
if p[j] == 0:
o[i] += 1
z = [0] + z
o = [0] + o
print(max(max(o), max(z)))
```
| 89,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
pref1 = [0]
for i in arr:
pref1.append(pref1[-1] + i)
suf0 = [0]
for i in arr[::-1]:
suf0.append(suf0[-1] + (i + 1) % 2)
ans = []
for i in range(n + 1):
ans.append(n - (suf0[::-1][i] + pref1[i]))
print(max(ans))
```
| 89,808 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Tags: brute force, implementation
Correct Solution:
```
def solve(s):
'''
>>> solve([1, 1, 0, 1])
3
>>> solve([0, 1, 0, 0, 1, 0])
4
>>> solve([0])
1
'''
zeroes = accum(s, 0)
ones = list(reversed(accum(reversed(s), 1)))
return max(x + y for x, y in zip(zeroes, ones))
def accum(lst, value):
counts = [0]
for el in lst:
if el == value:
counts.append(counts[-1] + 1)
else:
counts.append(counts[-1])
return counts
def main():
n = input()
s = list(map(int, input().split()))
print(solve(s))
if __name__ == '__main__':
main()
```
| 89,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n=int(input())
s=[int(c) for c in input().split()]
r=0
for i in range(n+1):
res=s[:i].count(0)
res+=s[i:].count(1)
r=max(res,r)
print(r)
```
Yes
| 89,810 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n = int(input())
a = [int(i) for i in input().split()]
ans = sum(a)
for i in range(len(a) - 1, - 1, -1):
ans = min(ans, (len(a) - i - sum(a[i:])) + sum(a[:i]))
print(len(a) - ans)
```
Yes
| 89,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n=int(input())
s=list(map(int,input().split()))
c=[]
t=0
while s[t]==0 and t<n-1:
t+=1
for i in range(t,n):
if s[i]==1:
k=0
for j in range(i):
if s[j]==1:
k+=1
for j in range(i+1,n):
if s[j]==0:
k+=1
c.append(k)
else:
k=0
for j in range(i):
if s[j]==1:
k+=1
for j in range(i+1,n):
if s[j]==0:
k+=1
c.append(k)
print(n-min(c))
```
Yes
| 89,812 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n = int(input())
s = list(map(int, input().split()))
res = max(i-sum(s[:i]) + 1 + sum(s[i+1:]) for i in range(n))
print(res)
```
Yes
| 89,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
#from collections import deque
n = int(input())
a = list(map(int, input().split()))
a.reverse()
prev = a.pop()
ct = 1
for _ in range(len(a)) :
if a[-1] == 1 and prev == 0 or a[-1] == 1 and prev == 1 :
prev = a.pop()
ct += 1
elif a[-1] == 0 and prev == 1 :
prev = a.pop()
elif a[-1] == 0 and prev == 0 :
prev = a.pop()
ct += 1
print(ct)
```
No
| 89,814 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
"""
Codeforces Round #334 (Div. 2)
Problem 846 A. Curriculum Vitae
@author yamaton
@date 2017-09-13
"""
def solve(xs):
n = len(xs)
return n - sum(1 for (i, j) in zip(xs, xs[1:]) if (i, j) == (1, 0))
def main():
n = int(input())
xs = [int(c) for c in input().split()]
assert len(xs) == n
result = solve(xs)
print(result)
if __name__ == '__main__':
main()
```
No
| 89,815 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
kol_z = p.count(0)
kol_o = p.count(1)
ind = n
if kol_o != 0:
ind1 = p.index(1)
for i in range(ind1):
if p[i] == 0:
kol_o += 1
for i in range(n - 1, -1, -1):
if p[i] == 0:
ind = i
break
for i in range(ind, n):
if p[i] == 1:
kol_z += 1
print(max(kol_z, kol_o))
```
No
| 89,816 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Hideo Kojima has just quit his job at Konami. Now he is going to find a new place to work. Despite being such a well-known person, he still needs a CV to apply for a job.
During all his career Hideo has produced n games. Some of them were successful, some were not. Hideo wants to remove several of them (possibly zero) from his CV to make a better impression on employers. As a result there should be no unsuccessful game which comes right after successful one in his CV.
More formally, you are given an array s1, s2, ..., sn of zeros and ones. Zero corresponds to an unsuccessful game, one — to a successful one. Games are given in order they were produced, and Hideo can't swap these values. He should remove some elements from this array in such a way that no zero comes right after one.
Besides that, Hideo still wants to mention as much games in his CV as possible. Help this genius of a man determine the maximum number of games he can leave in his CV.
Input
The first line contains one integer number n (1 ≤ n ≤ 100).
The second line contains n space-separated integer numbers s1, s2, ..., sn (0 ≤ si ≤ 1). 0 corresponds to an unsuccessful game, 1 — to a successful one.
Output
Print one integer — the maximum number of games Hideo can leave in his CV so that no unsuccessful game comes after a successful one.
Examples
Input
4
1 1 0 1
Output
3
Input
6
0 1 0 0 1 0
Output
4
Input
1
0
Output
1
Submitted Solution:
```
n = int(input())
games = input().split()
if games.count('1') > games.count('0'):
print(games.count('1'))
elif games.count('1') < games.count('0'):
print(games.count('0'))
```
No
| 89,817 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
import math
class Person:
def __init__(self, slices, a_happiness, b_happiness):
self.slices = slices
self.a_happiness = a_happiness
self.b_happiness = b_happiness
self.choice = None
def make_greedy_choice(self):
if self.a_happiness > self.b_happiness:
self.choice = (self.slices, 0)
else:
self.choice = (0, self.slices)
def happiness_for(self, a_slices, b_slices):
return a_slices * self.a_happiness + b_slices * self.b_happiness
@property
def happiness(self):
if self.choice is None:
raise RuntimeError("need pizza choice to compute happiness")
return self.happiness_for(self.choice[0], self.choice[1])
def choose(self, a, b):
self.choice = (a, b)
def __repr__(self):
return "Person({}, {}, {})".format(self.slices, self.a_happiness, self.b_happiness)
if __name__ == "__main__":
n, slices = [int(x) for x in input().split()]
people = []
for _ in range(n):
people.append(Person(*[int(x) for x in input().split()]))
required_slices = sum([person.slices for person in people])
quantity = math.ceil(required_slices / slices)
#print("Ordering {} pizzas (min quantity) for {} people: ".format(quantity, len(people)), people)
# first make greedy choice
for person in people:
person.make_greedy_choice()
greedy_happiness = sum([person.happiness for person in people])
greedy_a_slices = sum([person.choice[0] for person in people])
greedy_b_slices = sum([person.choice[1] for person in people])
greedy_quantity = math.ceil(greedy_a_slices / slices) + math.ceil(greedy_b_slices / slices)
#print("{} total happiness for greedy choices ({}, {}) resulting in {} pizzas".format(greedy_happiness, greedy_a_slices, greedy_b_slices, greedy_quantity))
if greedy_quantity <= quantity:
print(greedy_happiness)
else:
# Need to either change slice choices in a way that causes minimum reduction in happiness
## considering A to B
slices_to_change = greedy_a_slices % slices
a_people = filter(lambda person: person.choice[0] > 0, people)
a_reduction = 0
# sort a_people from least opposed to changing to most opposed
a_people = sorted(a_people, key=lambda person: person.a_happiness - person.b_happiness)
#print(a_people)
for person in a_people:
if slices_to_change == 0:
break
can_change = min(person.choice[0], slices_to_change)
a_reduction += (person.a_happiness - person.b_happiness) * can_change
slices_to_change -= can_change
#print("minimum happiness reduction from changing {} A slice choices to B was {}".format(greedy_a_slices % slices, a_reduction))
## considering B to A
slices_to_change = greedy_b_slices % slices
b_people = filter(lambda person: person.choice[1] > 0, people)
b_reduction = 0
# sort b_people from least opposed to changing to most opposed
b_people = sorted(b_people, key=lambda person: person.b_happiness - person.a_happiness)
#print(b_people)
for person in b_people:
if slices_to_change == 0:
break
can_change = min(person.choice[1], slices_to_change)
b_reduction += (person.b_happiness - person.a_happiness) * can_change
slices_to_change -= can_change
#print("minimum happiness reduction from changing {} B slice choices to A was {}".format(greedy_b_slices % slices, b_reduction))
print(greedy_happiness - min(a_reduction, b_reduction))
```
| 89,818 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
def solve(arr):
arr.sort(key=lambda q: q[1] - q[0])
m = sum(si for a, b, si in arr)
k = s * (m // s)
n = m - k
x, y, z = 0, 0, 0
for a, b, si in arr:
if k >= si:
k -= si
z += si * a
elif k > 0:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return x, y, z, n
n, s = map(int, input().split())
arr1, arr2 = [], []
for i in range(n):
si, ai, bi = map(int, input().split())
if ai > bi: arr1.append((ai, bi, si))
else: arr2.append((bi, ai, si))
x1, y1, z1, n1 = solve(arr1)
x2, y2, z2, n2 = solve(arr2)
d = x1 + x2 if n1 + n2 > s else max(x1 + y2, x2 + y1)
print(z1 + z2 + d)
```
| 89,819 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
import sys
n, s = tuple(map(int, input().split()))
x = []
for i in range(n):
si, a, b = tuple(map(int, input().split()))
x.append([si, a, b])
x = sorted(x, key=lambda t: abs(t[1] - t[2]))
labels = []
sum1 = 0
sum2 = 0
res = 0
for i in range(len(x)):
res += x[i][0] * max(x[i][1], x[i][2])
if x[i][1] > x[i][2]:
sum1 += x[i][0]
labels.append(1)
elif x[i][1] < x[i][2]:
sum2 += x[i][0]
labels.append(2)
else:
if sum1 > sum2:
sum2 += x[i][0]
labels.append(2)
else:
sum1 = x[i][0]
labels.append(1)
if ((sum1 - 1) // s + 1 + (sum2 - 1) // s + 1) == ((sum1 + sum2 - 1) // s + 1):
print(res)
sys.exit(0)
s1 = sum1
s2 = sum2
res1 = res
for i in range(len(labels)):
c = False
if labels[i] == 1:
j = 0
while x[i][0] - j != 0:
if s1 % s == 0 or s2 % s == 0:
c = True
break
j += 1
s1 -= 1
s2 += 1
res1 -= abs(x[i][1] - x[i][2])
if c:
break
s1 = sum1
s2 = sum2
for i in range(len(labels)):
c = False
if labels[i] == 2:
j = 0
while x[i][0] - j != 0:
if s1 % s == 0 or s2 % s == 0:
c = True
break
j += 1
s1 += 1
s2 -= 1
res -= abs(x[i][1] - x[i][2])
if c:
break
print(max(res1, res))
```
| 89,820 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum(si for a, b, si in ls)
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return x, y, z, n
n,s = map(int,input().split())
first=[]
second=[]
for i in range(n):
si, ai, bi = map(int,input().split())
if ai>bi:
first.append((ai,bi,si))
else:
second.append((bi,ai,si))
x1,y1,z1,n1 = solve(first)
x2,y2,z2,n2 = solve(second)
d = x1+x2 if n1+n2>s else max(x1+y2,x2+y1)
print(z1+z2+d)
```
| 89,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
def get_losts(persons, count):
persons.sort(key = lambda p : p.lost)
losts = 0
i = 0
while count > 0:
df = min(count, persons[i].s)
losts += df * persons[i].lost
count -= df
i += 1
return losts
class Person:
def __init__(self, _s, _a, _b, _lost):
self.s = _s
self.a = _a
self.b = _b
self.lost = _lost
n, m = map(int, input().split())
s_count = 0
a_pizza = list()
a_count = 0
a_points = 0
b_pizza = list()
b_count = 0
b_points = 0
neutral_points = 0
neutral_count = 0
for i in range(n):
s, a, b = map(int, input().split())
s_count += s
if a == b:
neutral_points += s*a
s_count -= s
neutral_count += s
elif a > b:
a_pizza.append(Person(s, a, b, a - b))
a_count += s
a_points += s*a
else:
b_pizza.append(Person(s, a, b, b - a))
b_count += s
b_points += s*b
a_lost = a_count % m
b_lost = b_count % m
if a_lost + b_lost + neutral_count > m or a_lost == 0 or b_lost == 0:
print(neutral_points + a_points + b_points)
else:
a_lost = get_losts(a_pizza, a_lost)
b_lost = get_losts(b_pizza, b_lost)
print(neutral_points + a_points + b_points - min(a_lost, b_lost))
```
| 89,822 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
def solve(ls):
ls.sort(key=lambda q: q[1] - q[0])
m = sum(si for a, b, si in ls)
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, si in ls:
if k >= si:
k -= si
z += si * a
elif k:
z += k * a
x = (si - k) * a
y = (si - k) * b
k = 0
else:
x += si * a
y += si * b
return x, y, z, n
n,s = map(int,input().split())
first=[]
second=[]
for i in range(n):
si, ai, bi = map(int,input().split())
if ai>bi:
first.append((ai,bi,si))
else:
second.append((bi,ai,si))
x1,y1,z1,n1 = solve(first)
x2,y2,z2,n2 = solve(second)
d = x1+x2 if n1+n2>s else max(x1+y2,x2+y1)
print(z1+z2+d)
# Made By Mostafa_Khaled
```
| 89,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
n, S = map(int, input().split())
arr = []
suma = 0
happy = 0
sumb = 0
dif = []
for i in range(n):
c, a, b = map(int, input().split())
if a >= b:
suma += c
happy += a * c
else:
sumb += c
happy += b * c
dif.append((a - b, c))
dif.sort()
num = (suma + sumb - 1) // S + 1
if (suma - 1) // S + 1 + (sumb - 1) // S + 1 <= num:
print(happy)
else:
moda = suma % S
modb = sumb % S
#a->b
for i in range(n):
if dif[i][0] >= 0:
ind = i
break
ans1 = happy
ans2 = happy
first = min(S - modb, moda)
if first <= moda:
now = ind
ans1 = 0
while first > 0:
if dif[now][1] > first:
ans1 += dif[now][0] * first
first = 0
else:
ans1 += dif[now][0] * dif[now][1]
first -= dif[now][1]
now += 1
#b->a
second = min(S - moda, modb)
if second <= modb:
now = ind - 1
ans2 = 0
while second > 0:
if dif[now][1] > second:
ans2 -= dif[now][0] * second
second = 0
else:
ans2 -= dif[now][0] * dif[now][1]
second -= dif[now][1]
now -= 1
print(happy - min(ans1, ans2))
```
| 89,824 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Tags: binary search, sortings, ternary search
Correct Solution:
```
f = lambda: map(int, input().split())
n, s = f()
u, v = [], []
for i in range(n):
d, a, b = f()
if a > b:
u.append([a, b, d])
else:
v.append([b, a, d])
def g(t):
t.sort(key=lambda q: q[1] - q[0])
m = sum(d for a, b, d in t)
k = s * (m // s)
n = m - k
x = y = z = 0
for a, b, d in t:
if k >= d:
k -= d
z += d * a
elif k:
z += k * a
x = (d - k) * a
y = (d - k) * b
k = 0
else:
x += d * a
y += d * b
return x, y, z, n
a, b = g(u), g(v)
d = a[0] + b[0] if a[3] + b[3] > s else max(a[0] + b[1], a[1] + b[0])
print(a[2] + b[2] + d)
```
| 89,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
from math import ceil
N, S = input().split()
N, S = int(N), int(S)
C = 0
pC = 0
nC = 0
cArr = []
for i in range(N):
s, a, b = input().split()
s, a, b = int(s), int(a), int(b)
C += s * b
cArr.append((a - b, s))
if a > b:
pC += s
else:
nC += s
cArr.sort(key=lambda k: -k[0])
tP = int(ceil((nC + pC) / S))
nP = int(pC / S)
hAns = C
sItr = nP * S
itr = 0
while sItr > 0 and itr < N:
si = min(cArr[itr][1], sItr)
hAns += si * cArr[itr][0]
sItr -= si
itr += 1
hAns2 = C
nP = int(pC / S) + 1
sItr = nP * S
e = S*(tP - nP) - nC
itr = 0
while itr < N and cArr[itr][0] > 0:
si = min(cArr[itr][1], sItr)
hAns2 += si * cArr[itr][0]
sItr -= si
itr += 1
if e < 0:
sItr = -e
while sItr > 0 and itr < N:
si = min(cArr[itr][1], sItr)
hAns2 += si * cArr[itr][0]
sItr -= si
itr += 1
print(max(hAns, hAns2))
```
Yes
| 89,826 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
n, s = map(int, input().split())
data = [[] for i in range(n)]
sec = 0
fir = 0
su = 0
for i in range(n):
a = list(map(int, input().split()))
data[i].append(abs(a[1] - a[2]))
if a[1] >= a[2]:
fir += a[0]
su += a[0] * a[1]
data[i].append(0)
else:
sec += a[0]
su += a[0] * a[2]
data[i].append(1)
data[i] += a
data = sorted(data)
#print(data)
fis = fir % s
sis = sec % s
if (fis + sis) > s or (fis == 0 or sis == 0):
print(su)
else:
cou = fis
k = 0
su1 = su
while cou > 0 and k < n:
if data[k][1] == 1:
k += 1
continue;
su1 -= min(cou, data[k][2]) * data[k][0]
cou -= min(cou, data[k][2])
k += 1
cou = sis
k = 0
su2 = su
while cou > 0 and k < n:
if data[k][1] == 0:
k += 1
continue;
su2 -= min(cou, data[k][2]) * data[k][0]
cou -= min(cou, data[k][2])
k += 1
print(max(su1, su2))
```
Yes
| 89,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
n, S = 0, 0
s = []
a = []
b = []
class node:
def __init__(self, x, id):
self.x = x
self.id = id
return
def __lt__(self, p):
return self.x < p.x
c = []
i , f = 0, 0
ans, sum, a1, a2 = 0, 0, 0, 0
s1, s2 = 0, 0
line = input().split()
n, S = int(line[0]), int(line[1])
for i in range(n):
line = input().split()
s.append(int(line[0]))
a.append(int(line[1]))
b.append(int(line[2]))
if a[i] > b[i]:
s1 += s[i]
elif a[i] < b[i]:
s2 += s[i]
sum += s[i]
ans += max(a[i], b[i]) * s[i]
c.append(node(a[i] - b[i], i))
cnt = (sum + S - 1) // S
if (s1 + S - 1) // S + (s2 + S - 1) // S <= cnt:
print(ans)
else:
c.sort()
s1 %= S
s2 %= S
for i in range(n):
if c[i].x <= 0:
f = i
continue
if not s1:
break
t = min(s[c[i].id], s1)
a1 += t * c[i].x
s1 -= t
for i in range(f, -1, -1):
if not c[i].x:
continue
if not s2:
break
t = min(s[c[i].id], s2)
a2 -= t * c[i].x
s2 -= t
print(ans - min(a1, a2))
```
Yes
| 89,828 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
def cns(ts,s):
if ts/s==int(ts/s):
return ts
else:
return (int(ts/s)+1)*s
n,spp=[int(i) for i in input().split()]
tsr=0
da=[[] for i in range(100005)]
db=[[] for i in range(100005)]
sl=[]
for i in range(n):
sl.append([int(j) for j in input().split()])
tsr+=sl[i][0]
if sl[i][1]>sl[i][2]:
da[sl[i][1]-sl[i][2]].append(i)
else:
db[sl[i][2]-sl[i][1]].append(i)
tsa=cns(tsr,spp)
a1=0
c1=0
for i in range(100000,-1,-1):
for j in da[i]:
a1+=sl[j][0]*sl[j][1]
c1+=sl[j][0]
c1r=cns(c1,spp)-c1
c2r=tsa-cns(c1,spp)
for i in range(100000,-1,-1):
for j in db[i]:
if sl[j][0]>c2r:
a1+=c2r*sl[j][2]
a1+=(sl[j][0]-c2r)*sl[j][1]
c2r=0
else:
a1+=sl[j][0]*sl[j][2]
c2r-=sl[j][0]
a2=0
c2=0
for i in range(100000,-1,-1):
for j in db[i]:
a2+=sl[j][0]*sl[j][2]
c2+=sl[j][0]
c2r=cns(c2,spp)-c2
c1r=tsa-cns(c2,spp)
for i in range(100000,-1,-1):
for j in da[i]:
if sl[j][0]>c1r:
a2+=c1r*sl[j][1]
a2+=(sl[j][0]-c1r)*sl[j][2]
c1r=0
else:
a2+=sl[j][0]*sl[j][1]
c1r-=sl[j][0]
print(max(a1,a2))
```
Yes
| 89,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
f = lambda: map(int, input().split())
n, s = f()
u, v = [], []
for i in range(n):
d, a, b = f()
if a > b:
u.append([a, b, d])
else:
v.append([b, a, d])
def g(t):
t.sort(key=lambda q: q[1] - q[0])
k = s * (sum(d for a, b, d in t) // s)
x = y = z = 0
for a, b, d in t:
if k >= d:
k -= d
z += d * a
elif k:
z += k * a
x = (d - k) * a
y = (d - k) * b
k = 0
else:
x += d * a
y += d * b
return x, y, z
a, b = g(u), g(v)
print(a[2] + b[2] + max(a[0] + b[1], a[1] + b[0]))
```
No
| 89,830 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
N, S = input().split()
N, S = int(N), int(S)
C = 0
pC = 0
cArr = []
for i in range(N):
s, a, b = input().split()
s, a, b = int(s), int(a), int(b)
C += s * b
cArr.append((a - b, s))
if a > b:
pC += s
cArr.sort(key=lambda k: -k[0])
hAns = 0
for i in range(2):
nP = int(pC / S) + i
hAnsTmp = C
sItr = nP * S
itr = 0
while sItr > 0:
si = min(cArr[itr][1], sItr)
hAnsTmp += si * cArr[itr][0]
sItr -= si
itr += 1
hAns = max(hAns, hAnsTmp)
print(hAns)
```
No
| 89,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
from math import ceil
N, S = input().split()
N, S = int(N), int(S)
C = 0
pC = 0
sTot = 0
cArr = []
for i in range(N):
s, a, b = input().split()
s, a, b = int(s), int(a), int(b)
C += s * b
sTot += s
cArr.append((a - b, s))
if a > b:
pC += s
cArr.sort(key=lambda k: -k[0])
hAns = 0
for i in range(2):
nP = int(pC / S) + i
hAnsTmp = C
sItr = nP * S
e = S * ceil(sTot / S) - sTot
itr = 0
while sItr > 0 and itr < N:
if not (cArr[itr][0] <= 0 and sItr <= e):
si = min(cArr[itr][1], sItr)
hAnsTmp += si * cArr[itr][0]
sItr -= si
itr += 1
hAns = max(hAns, hAnsTmp)
print(hAns)
```
No
| 89,832 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's another Start[c]up finals, and that means there is pizza to order for the onsite contestants. There are only 2 types of pizza (obviously not, but let's just pretend for the sake of the problem), and all pizzas contain exactly S slices.
It is known that the i-th contestant will eat si slices of pizza, and gain ai happiness for each slice of type 1 pizza they eat, and bi happiness for each slice of type 2 pizza they eat. We can order any number of type 1 and type 2 pizzas, but we want to buy the minimum possible number of pizzas for all of the contestants to be able to eat their required number of slices. Given that restriction, what is the maximum possible total happiness that can be achieved?
Input
The first line of input will contain integers N and S (1 ≤ N ≤ 105, 1 ≤ S ≤ 105), the number of contestants and the number of slices per pizza, respectively. N lines follow.
The i-th such line contains integers si, ai, and bi (1 ≤ si ≤ 105, 1 ≤ ai ≤ 105, 1 ≤ bi ≤ 105), the number of slices the i-th contestant will eat, the happiness they will gain from each type 1 slice they eat, and the happiness they will gain from each type 2 slice they eat, respectively.
Output
Print the maximum total happiness that can be achieved.
Examples
Input
3 12
3 5 7
4 6 7
5 9 5
Output
84
Input
6 10
7 4 7
5 8 8
12 5 8
6 11 6
3 3 7
5 9 6
Output
314
Note
In the first example, you only need to buy one pizza. If you buy a type 1 pizza, the total happiness will be 3·5 + 4·6 + 5·9 = 84, and if you buy a type 2 pizza, the total happiness will be 3·7 + 4·7 + 5·5 = 74.
Submitted Solution:
```
# -*- coding: utf-8 -*-
import math
import collections
import bisect
import heapq
import time
"""
created by shhuan at 2017/10/3 12:35
"""
N, S = map(int, input().split())
M = []
for i in range(N):
M.append([int(x) for x in input().split()])
s = [M[i][0] for i in range(N)]
a = [M[i][1] for i in range(N)]
b = [M[i][2] for i in range(N)]
total = sum(s)
numpizza = int(math.ceil(total/S))
numslice = numpizza * S
pa = 0
pb = 0
pab = 0
sab = sorted([(a[i]-b[i], i) for i in range(N)], reverse=True)
for d, i in sab:
if d < 0:
pb += s[i]
elif d > 0:
pa += s[i]
else:
pab += 1
maxHappiness = 0
sbak = s
for i in range(pa//S, (pa+pab)//S+2):
j = i * S
k = numslice - j
if int(math.ceil(j/S)+math.ceil(k/S)) != numpizza:
continue
h = 0
s = [x for x in sbak]
l = 0
while j >= s[sab[l][1]] and l < N and sab[l][0] >= 0:
h += s[sab[l][1]] * a[sab[l][1]]
j -= s[sab[l][1]]
l += 1
r = N-1
while r >= 0 and k >= s[sab[r][1]] and sab[r][0] <= 0:
h += s[sab[r][1]] * b[sab[r][1]]
k -= s[sab[r][1]]
r -= 1
hm = 0
for jj in range(j+1):
kk = s[sab[l][1]] - jj
if kk <= k:
hm = max(hm, jj*a[sab[l][1]] + kk*b[sab[l][1]])
h += hm
maxHappiness = max(maxHappiness, h)
print(maxHappiness)
```
No
| 89,833 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a tree (a connected acyclic undirected graph) of n vertices. Vertices are numbered from 1 to n and each vertex is assigned a character from a to t.
A path in the tree is said to be palindromic if at least one permutation of the labels in the path is a palindrome.
For each vertex, output the number of palindromic paths passing through it.
Note: The path from vertex u to vertex v is considered to be the same as the path from vertex v to vertex u, and this path will be counted only once for each of the vertices it passes through.
Input
The first line contains an integer n (2 ≤ n ≤ 2·105) — the number of vertices in the tree.
The next n - 1 lines each contain two integers u and v (1 ≤ u, v ≤ n, u ≠ v) denoting an edge connecting vertex u and vertex v. It is guaranteed that the given graph is a tree.
The next line contains a string consisting of n lowercase characters from a to t where the i-th (1 ≤ i ≤ n) character is the label of vertex i in the tree.
Output
Print n integers in a single line, the i-th of which is the number of palindromic paths passing through vertex i in the tree.
Examples
Input
5
1 2
2 3
3 4
3 5
abcbb
Output
1 3 4 3 3
Input
7
6 2
4 3
3 7
5 2
7 2
1 4
afefdfs
Output
1 4 1 1 2 4 2
Note
In the first sample case, the following paths are palindromic:
2 - 3 - 4
2 - 3 - 5
4 - 3 - 5
Additionally, all paths containing only one vertex are palindromic. Listed below are a few paths in the first sample that are not palindromic:
1 - 2 - 3
1 - 2 - 3 - 4
1 - 2 - 3 - 5
Tags: bitmasks, data structures, divide and conquer, trees
Correct Solution:
```
import sys, os
def centroid_decomp(coupl):
n = len(coupl)
bfs = [n - 1]
for node in bfs:
bfs += coupl[node]
for nei in coupl[node]:
coupl[nei].remove(node)
size = [0] * n
for node in reversed(bfs):
size[node] = 1 + sum(size[child] for child in coupl[node])
def centroid_reroot(root):
while coupl[root]:
child = max(coupl[root], key = size.__getitem__)
if size[child] <= size[root] // 2:
break
size[root] -= size[child]
size[child] += size[root]
coupl[root].remove(child)
coupl[child].append(root)
root = child
return root
bfs = [n - 1]
for node in bfs:
centroid = centroid_reroot(node)
bfs += coupl[centroid]
yield centroid
inp = sys.stdin.buffer.read().split(); ii = 0
n = int(inp[ii]); ii += 1
coupl = [[] for _ in range(n)]
for _ in range(n - 1):
u = int(inp[ii]) - 1; ii += 1
v = int(inp[ii]) - 1; ii += 1
coupl[u].append(v)
coupl[v].append(u)
A = [1 << c - b'a'[0] for c in inp[ii]]; ii += 1
palistates = [0] + [1 << i for i in range(20)]
ans = [0.0] * n
dp = [0.0] * n
val = [0] * n
counter = [0] * (1 << 20)
for centroid in centroid_decomp(coupl):
bfss = []
for root in coupl[centroid]:
bfs = [root]
for node in bfs:
bfs += coupl[node]
bfss.append(bfs)
for node in bfs:
val[node] ^= A[node]
for child in coupl[node]:
val[child] = val[node]
entire_bfs = [centroid]
for bfs in bfss:
entire_bfs += bfs
for node in entire_bfs:
val[node] ^= A[centroid]
counter[val[node]] += 1
for bfs in bfss:
for node in bfs:
counter[val[node]] -= 1
for node in bfs:
v = val[node] ^ A[centroid]
for p in palistates:
dp[node] += counter[v ^ p]
for node in bfs:
counter[val[node]] += 1
for node in reversed(entire_bfs):
dp[node] += sum(dp[child] for child in coupl[node])
dp[centroid] += 1
for p in palistates:
dp[centroid] += counter[p]
dp[centroid] //= 2
for node in entire_bfs:
ans[node] += dp[node]
counter[val[node]] = val[node] = 0
dp[node] = 0.0
os.write(1, b' '.join(str(int(x)).encode('ascii') for x in ans))
```
| 89,834 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
import math
s = input()
s = s.split()
s = list(map(int, s))
k = s[0]
d = s[1]
t = s[2]
i = math.ceil(k / d)
c = i * d
m = (c + k) / 2
r1 = int(t / m)
remain = t - r1 * m
if remain < k:
print(r1 * c + remain)
else:
print(r1 * c + (remain - k) * 2 + k)
```
| 89,835 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
k, d, t = (int(x) for x in input().split())
import math as m
if d >= k:
chunksize = d
chunkspeed = k + (d-k)/2
else:
lcm = k // m.gcd(k, d) * d
lft = 0
rgt = lcm//d
while lft != rgt:
cur = (lft+rgt)//2
if d*cur < k:
lft = cur+1
else:
rgt = cur
chunksize = lft * d
chunkspeed = k + (chunksize-k)/2
chunks = m.floor(t / chunkspeed)
# print(chunksize)
# print(chunkspeed)
ans = chunksize * chunks
rem = t - (chunkspeed * chunks)
if rem <= k:
ans += rem
else:
ans += k
rem -= k
ans += rem*2
print(ans)
```
| 89,836 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
import math
k, d, t = map(int, input().split())
if d >= k:
off = d - k
else:
off = math.ceil(k / d) * d - k
times = t // (off / 2 + k)
t1 = times * (off + k)
t2 = t % (off / 2 + k)
if t2 > k:
t2 = k + (t2 - k) * 2
ans = t1 + t2
print (ans)
```
| 89,837 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
k, d, t = list(map(int, input().split()))
if k % d == 0:
print(t)
exit()
m = (k+d-1) // d * d
if 2*t % (m+k) == 0:
print(m*2*t / (m+k))
exit()
n = 2*t // (m+k)
res = n*m
f = 1 - (m +k) * n/(2*t)
if f <= k/t:
print(res+f*t)
else:
res += k
f -= k / t
print(res + f*2*t)
```
| 89,838 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
k, d, t = [int(x) for x in input().split()]
if d >= k:
off1 = d - k
else:
if k%d == 0:
off1 = 0
else:
off1 = d - k%d
reptime = k + off1/2
times = t // reptime
trest = t - times * reptime
sol = times * (k + off1)
if trest <= k:
sol += trest
else:
sol += k
sol += 2*(trest-k)
print("%.8f"%sol)
```
| 89,839 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
import math
k,d,t = [int(x) for x in input().split(' ')]
v = (d*math.ceil(k/d))
cyc = k + ((v-k)/2)
a = (t//cyc)
c = t-(a*cyc)-k
ans = 0
if c>0:
ans = c
print(t-(a*cyc)+(a*v)+ans)
```
| 89,840 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
k, d, t = map(int, input().split())
if k >= t or k%d == 0:
print(t)
exit()
if d < k:
dd = d*(k//d)
d = dd+d
no_of_cycles = 2*t//(k+d)
cooked = no_of_cycles*(k+d)/(2*t)
remaining = 1-cooked
ans = no_of_cycles*d
# print(no_of_cycles, ans, remaining, cooked)
if remaining <= k/t:
# print("AA")
ans += remaining*t
else:
remaining -= k/t
ans += k
ans += remaining * 2*t
print(ans)
```
| 89,841 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Tags: binary search, implementation, math
Correct Solution:
```
k, d, t = (int(x) for x in input().split())
if d >= k:
chunksize = d
chunkspeed = k + (d-k)/2
else:
if k % d == 0:
chunksize = k
else:
chunksize = ((k // d) + 1) * d
chunkspeed = k + (chunksize-k)/2
chunks = int(t / chunkspeed)
ans = chunksize * chunks
rem = t - (chunkspeed * chunks)
if rem <= k:
ans += rem
else:
ans += k
rem -= k
ans += rem*2
print(ans)
```
| 89,842 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 8 22:15:19 2018
@author: Nikita
"""
from math import ceil, floor
k, d, t = map(int, input().split())
period = 0
if k <= d:
period = d
else:
period = ceil(k / d) * d
cooking = k + period
num = floor(2 * t / cooking)
carry = 2 * t - num * cooking
ans = 0
if carry > 2 * k:
ans = num * period + carry - k
else:
ans = num * period + carry / 2
print(ans)
```
Yes
| 89,843 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
k, d, t = map(int, input().split())
a = 2*k+((k+d-1)//d)*d-k
q, r = divmod(2*t, a)
T = q*(((k+d-1)//d)*d)
if 0 <= r <= 2*k:
T += r/2
else:
T += k+(r-2*k)
print(T)
```
Yes
| 89,844 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
from math import *
k,d,t=map(int,input().split())
if d<k:
l=ceil(k/d)*d
w=l-k
else:
w=d-k
div=2*k+w
ans=((2*t)//div)*(w+k)
rem=(2*t)%div
if rem!=0:
if rem<=2*k:
ans+=rem/2
else:
ans+=rem-k
print(ans)
```
Yes
| 89,845 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
k,d,t=[int(i)for i in input().split()]
t = 2 * t
if d >= k:
s = 2*k + (d - k)
tt = k + (d - k)
if s >= t:
if 2*k >= t:
print(t//2)
exit(0)
else:
print(k + 2*(t//2-k))
exit(0)
h = t // s
x = t % s
if x <= 2*k:
print(h * tt + x / 2)
else:
print(h * tt + k + (x - 2 *k))
else:
last = 0
if k % d == 0:last = k
else :last = k - k % d + d
s = 2*k + (last - k)
tt = k + (last - k)
if s >= t:
if 2*k >= t:
print(t//2)
exit(0)
else:
print(k + 2*(t//2-k))
exit(0)
h = t // s
x = t % s
if x <= 2*k:
print(h * tt + x / 2)
else:
print(h * tt + k + (x - 2 *k))
```
Yes
| 89,846 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
import math
k,d,t=map(int,input().split())
if k>=t:
print(t)
elif k>=d and k%d==0:
print(t)
else:
if k!=0:
p=math.ceil(k/d)
r=(p*d)-k
f=(k/t)+((r)/(2*t))
m=math.ceil(1/f)
n=m-1
req=1-(n*f)
if n*f+(k/t)>1:
s=req*t
ans=n*(p*d)+s
print(ans)
elif n*f+(k/t)==1:
ans=n*(p*d)+k
print(ans)
else:
re=1-(n*f)+(k/t)
s=re*(2*t)
ans=n*(p*d)+k+s
print(ans)
```
No
| 89,847 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
k,d,t = map(int,input().split())
if k%d == 0 or t<=k:
print(t)
else:
cyc = k + (d - k%d)
dt = k*2 + (d - k%d)
t *= 2
n = int(t/dt)
if t % dt == 0:
n -= 1
ans = 0
if(t % dt > k*2):
ans = cyc*n + (t%dt)/2
else:
ans = cyc*n + k + (dt - 2*k)
print(ans)
```
No
| 89,848 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
k,d,t=input().split()
k,d,t=int(k),int(d),int(t)
time=0
if True:
m=int((k-1)/d)*d+d-k
#print(m)
tc=k+0.5*m
ta=k+m
l=int(t/tc)
time=ta*l
#print(tc)
#print(ta)
#print(time)
#print(l)
if (k>t-l*tc):
time+=t-l*tc
print(t-l*tc)
else:
time+=k
time+=2*(t-l*tc-k)
print(time)
```
No
| 89,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Julia is going to cook a chicken in the kitchen of her dormitory. To save energy, the stove in the kitchen automatically turns off after k minutes after turning on.
During cooking, Julia goes to the kitchen every d minutes and turns on the stove if it is turned off. While the cooker is turned off, it stays warm. The stove switches on and off instantly.
It is known that the chicken needs t minutes to be cooked on the stove, if it is turned on, and 2t minutes, if it is turned off. You need to find out, how much time will Julia have to cook the chicken, if it is considered that the chicken is cooked evenly, with constant speed when the stove is turned on and at a constant speed when it is turned off.
Input
The single line contains three integers k, d and t (1 ≤ k, d, t ≤ 1018).
Output
Print a single number, the total time of cooking in minutes. The relative or absolute error must not exceed 10 - 9.
Namely, let's assume that your answer is x and the answer of the jury is y. The checker program will consider your answer correct if <image>.
Examples
Input
3 2 6
Output
6.5
Input
4 2 20
Output
20.0
Note
In the first example, the chicken will be cooked for 3 minutes on the turned on stove, after this it will be cooked for <image>. Then the chicken will be cooked for one minute on a turned off stove, it will be cooked for <image>. Thus, after four minutes the chicken will be cooked for <image>. Before the fifth minute Julia will turn on the stove and after 2.5 minutes the chicken will be ready <image>.
In the second example, when the stove is turned off, Julia will immediately turn it on, so the stove will always be turned on and the chicken will be cooked in 20 minutes.
Submitted Solution:
```
k,d,t = map(int,input().split())
if k%d == 0 or t<=k:
print(t)
else:
cyc = k + (d - k%d)
dt = k*2 + (d - k%d)
t *= 2
n = int(t/dt)
ans = 0
if(t % dt <= k*2):
ans = cyc*n + (t%dt)/2
else:
ans = cyc*n + k + (dt - 2*k)
print(ans)
```
No
| 89,850 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
b,r,p = None, None, None
res = 0
mr = -1
mb = -1
for i in range(n):
ix,t = input().split()
ix = int(ix)
if t != 'R':
if b is not None:
res += ix-b
mb = max(mb, ix-b)
b = ix
if t != 'B':
if r is not None:
res += ix-r
mr = max(mr, ix-r)
r = ix
if t == 'P':
if p is not None:
if ix - p < mr + mb:
res -= (mr+mb) - (ix-p)
p = ix
mr = mb = 0
print(res)
```
| 89,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
def solve(length, cities):
result = 0
lastP = None
lastB = None
lastR = None
maxB = 0
maxR = 0
for idx, city in enumerate(cities):
i, code = city
if(code == 'B'):
if(lastB != None):
result += abs(i - lastB)
maxB = max(maxB, abs(i - lastB))
lastB = i
if(code == 'R'):
if(lastR != None):
result += abs(i - lastR)
maxR = max(maxR, abs(i - lastR))
lastR = i
if(code == 'P'):
# B case
if(lastB != None):
result += abs(i - lastB)
maxB = max(maxB, abs(i - lastB))
# R case
if(lastR != None):
result += abs(i - lastR)
maxR = max(maxR, abs(i - lastR))
if(lastP != None):
result += min(0, abs(i - lastP) - maxB - maxR)
maxB = 0
maxR = 0
lastB = i
lastR = i
lastP = i
return result
if __name__ == '__main__':
length = int(input())
cities = []
for i in range(length):
data = input().split(" ")
cities.append((int(data[0]), data[1]))
result = solve(length, cities)
print(result)
```
| 89,852 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
def inpmap():
return map(int, input().split())
n = int(input())
b, r, p = None, None, None
res = 0
mr = -1
mb = -1
for i in range(n):
ix, t = input().split()
ix = int(ix)
if t != 'R':
if b is not None:
res += ix - b
mb = max(mb, ix - b)
b = ix
if t != 'B':
if r is not None:
res += ix - r
mr = max(mr, ix - r)
r = ix
if t == 'P':
if p is not None:
if ix - p < mr + mb:
res -= (mr + mb) - (ix - p)
p = ix
mr = mb = 0
print(res)
```
| 89,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
from sys import exit, stdin, stdout
input, print = stdin.readline, stdout.write
n = int(input())
r, g, b = [], [], []
ans = 0
for i in range(n):
x, t = [i for i in input().split()]
x = int(x)
if t == 'P':
g.append(x)
elif t == 'R':
r.append(x)
else:
b.append(x)
if len(g) == 0:
if len(r):
ans += r[-1] - r[0]
if len(b):
ans += b[-1] - b[0]
print(str(ans))
exit(0)
if not len(r):
r.append(g[0])
if not len(b):
b.append(g[0])
if r[0] < g[0]:
ans += g[0] - r[0]
if b[0] < g[0]:
ans += g[0] - b[0]
if r[-1] > g[-1]:
ans += r[-1] - g[-1]
if b[-1] > g[-1]:
ans += b[-1] - g[-1]
bi, ri = 0, 0
for i in range(len(g) - 1):
while bi < len(b) - 1 and b[bi] < g[i]:
bi += 1
while ri < len(r) - 1 and r[ri] < g[i]:
ri += 1
a1, a2 = (g[i + 1] - g[i]) * 3, (g[i + 1] - g[i]) * 2
mr, mb, cbi, cri = r[ri] - g[i], b[bi] - g[i], bi, ri
while cbi + 1 < len(b) and b[cbi + 1] < g[i + 1]:
mb = max(mb, b[cbi + 1] - b[cbi])
cbi += 1
mb = max(mb, g[i + 1] - b[cbi])
while cri + 1 < len(r) and r[cri + 1] < g[i + 1]:
mr = max(mr, r[cri + 1] - r[cri])
cri += 1
mr = max(mr, g[i + 1] - r[cri])
if b[bi] < g[i] or b[bi] > g[i + 1]:
a2 = 100000000000000
a1 -= g[i + 1] - g[i]
mb = 0
if r[ri] < g[i] or r[ri] > g[i + 1]:
a2 = 100000000000000
a1 -= g[i + 1] - g[i]
mr = 0
ans += min(a1 - mr - mb, a2)
print(str(ans))
```
| 89,854 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
n=int(input())
last_r=None
last_b=None
last_p=None
ans=0
max_r=0
max_b=0
max_p=0
for _ in range(n):
s=input().split()
x=int(s[0])
c=s[1]
if c=='B':
if last_b!=None:
ans+=x-last_b
max_b=max(max_b,x-last_b)
last_b=x
if c=='R':
if last_r!=None:
ans+=x-last_r
max_r=max(max_r,x-last_r)
last_r=x
if c=='P':
if last_b!=None:
ans+=x-last_b
max_b=max(max_b,x-last_b)
last_b=x
if last_r!=None:
ans+=x-last_r
max_r=max(max_r,x-last_r)
last_r=x
if last_p!=None:
new_ans=(x-last_p)*3
new_ans-=max_r
new_ans-=max_b
if new_ans<(x-last_p)*2:
ans-=(x-last_p)*2-new_ans
last_p=x
max_b=0
max_r=0
print(ans)
```
| 89,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
rides = int(input())
franxx = []
Zero = []
Two = []
for i in range(rides):
darling = input().split()
if (darling[1] == 'B'):
darling[1] = 1
elif (darling[1] == 'R'):
darling[1] = 2
else:
darling[1] = 3
franxx.append((int(darling[0]), int(darling[1])))
love = 0
hiro = ["I love Zero Two", "I love Darling"]
for zero, two in franxx:
if (two == 3 or two == 1):
if (hiro[0] == 'I love Zero Two'):
Zero.append(0)
hiro[0] = zero
else:
Zero.append(zero - hiro[0])
love += zero - hiro[0]
hiro[0] = zero
if (two == 3 or two == 2):
if (hiro[1] == 'I love Darling'):
Two.append(0)
hiro[1] = zero
else:
Two.append(zero - hiro[1])
love += zero - hiro[1]
hiro[1] = zero
if (two == 1):
Two.append(0)
elif (two == 2):
Zero.append(0)
hiro = [-1, 0]
for ride in range(rides):
if (franxx[ride][1] == 3):
if (hiro[0] == -1):
hiro[0] = ride
hiro[1] = 0
else:
strelizia = [0, 0]
if ((hiro[1] & 1) == 0):
strelizia[0] = franxx[ride][0] - franxx[hiro[0]][0]
if ((hiro[1] & 2) == 0):
strelizia[1] = franxx[ride][0] - franxx[hiro[0]][0]
for darling in range(hiro[0], ride):
if (hiro[1] & 1):
strelizia[0] = max(strelizia[0], Zero[darling + 1])
if (hiro[1] & 2):
strelizia[1] = max(strelizia[1], Two[darling + 1])
if (strelizia[0] + strelizia[1] - franxx[ride][0] + franxx[hiro[0]][0] > 0):
love -= strelizia[0] + strelizia[1] - franxx[ride][0] + franxx[hiro[0]][0]
hiro[0] = ride
hiro[1] = 0
else:
hiro[1] |= franxx[ride][1]
print(love)
```
| 89,856 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
import sys
n = int(sys.stdin.buffer.readline().decode('utf-8'))
pos, type_ = [0]*n, ['']*n
for i, (x, c) in enumerate(line.decode('utf-8').split() for line in sys.stdin.buffer):
pos[i] = int(x)
type_[i] = c
r_cnt = type_.count('R')
b_cnt = type_.count('B')
p_cnt = n - r_cnt - b_cnt
inf = 2100000000
if p_cnt == 0:
r_min, r_max = inf, inf
b_min, b_max = inf, inf
for i in range(n):
if type_[i] == 'R':
r_min = min(pos[i], r_min)
r_max = pos[i]
else:
b_min = min(pos[i], b_min)
b_max = pos[i]
print(r_max - r_min + b_max - b_min)
exit()
p_index = [i for i in range(n) if type_[i] == 'P']
ans = 0
for c in 'RB':
for i in range(p_index[0]):
if type_[i] == c:
ans += pos[p_index[0]] - pos[i]
break
for i in range(n-1, p_index[-1], -1):
if type_[i] == c:
ans += pos[i] - pos[p_index[-1]]
break
for i, j in zip(p_index, p_index[1:]):
r, b = [], []
r_prev = b_prev = pos[i]
for k in range(i+1, j):
if type_[k] == 'R':
r.append(pos[k] - r_prev)
r_prev = pos[k]
else:
b.append(pos[k] - b_prev)
b_prev = pos[k]
r.append(pos[j] - r_prev)
b.append(pos[j] - b_prev)
r.sort()
b.sort()
ans += min(
pos[j]-pos[i] + sum(r) - r[-1] + sum(b) - b[-1],
sum(r) + sum(b)
)
print(ans)
```
| 89,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Tags: constructive algorithms, greedy
Correct Solution:
```
n = int(input())
b, r, p = None, None, None
ans = 0
mr = -1
mb = -1
for i in range(n):
ix, t = input().split()
ix = int(ix)
if t != 'R':
if b is not None:
ans += ix - b
mb = max(mb, ix - b)
b = ix
if t != 'B':
if r is not None:
ans += ix - r
mr = max(mr, ix - r)
r = ix
if t == 'P':
if p is not None:
if ix - p < mr + mb:
ans -= (mr + mb) - (ix - p)
p = ix
mr = mb = 0
print(ans)
```
| 89,858 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Submitted Solution:
```
#!/usr/bin/env python3
M = 4 * 10**9 + 1
n = int(input().strip())
f = lambda t: (int(t[0]), t[1])
# read and add far P points at both ends
xcis = [(-M, 'P')] + [f(input().strip().split()) for _ in range(n)] + [(M, 'P')]
iPs = [i for i in range(len(xcis)) if (xcis[i][1] == 'P')]
iRs = [i for i in range(len(xcis)) if (xcis[i][1] == 'R')]
iBs = [i for i in range(len(xcis)) if (xcis[i][1] == 'B')]
l = 0
for iiP in range(1, len(iPs)):
iP0 = iPs[iiP - 1]
iP1 = iPs[iiP]
dRmax = 0
dBmax = 0
(xR, _) = xcis[iP0]
(xB, _) = xcis[iP0]
for i in range(iP0 + 1, iP1 + 1):
(x, c) = xcis[i]
if c in 'RP':
dRmax = max(dRmax, x - xR)
xR = x
if c in 'BP':
dBmax = max(dBmax, x - xB)
xB = x
d = xcis[iP1][0] - xcis[iP0][0]
l += d + min(d, 2*d - dBmax - dRmax)
if iiP in [1, len(iPs) - 1]:
l -= d # remove connections to extra P points
iP0 = iP1
if len(iPs) == 2: # no P in original data
l = (0 if (len(iRs) < 2) else (xcis[iRs[-1]][0] - xcis[iRs[0]][0]))
l += (0 if (len(iBs) < 2) else (xcis[iBs[-1]][0] - xcis[iBs[0]][0]))
print (l)
```
Yes
| 89,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Submitted Solution:
```
import sys
def kruskal(v_count: int, edges: list) -> int:
edges.sort()
tree = [-1]*v_count
def get_root(x) -> int:
if tree[x] < 0:
return x
tree[x] = get_root(tree[x])
return tree[x]
def unite(x, y) -> bool:
x, y = get_root(x), get_root(y)
if x != y:
big, small = (x, y) if tree[x] < tree[y] else (y, x)
tree[big] += tree[small]
tree[small] = big
return x != y
cost = 0
for w, s, t in edges:
if unite(s, t):
cost += w
v_count -= 1
if v_count == 1:
break
return cost
n = int(sys.stdin.buffer.readline().decode('utf-8'))
pos, type_ = [0]*n, ['']*n
for i, (x, c) in enumerate(line.decode('utf-8').split() for line in sys.stdin.buffer):
pos[i] = int(x)
type_[i] = c
r_cnt = type_.count('R')
b_cnt = type_.count('B')
p_cnt = n - r_cnt - b_cnt
inf = 2100000000
if r_cnt == 0 or b_cnt == 0:
print(pos[-1] - pos[0])
exit()
if p_cnt == 0:
r_min, r_max = inf, -inf
b_min, b_max = inf, -inf
for i in range(n):
if type_[i] == 'R':
r_min = min(pos[i], r_min)
r_max = max(pos[i], r_max)
else:
b_min = min(pos[i], b_min)
b_max = max(pos[i], b_max)
print(r_max - r_min + b_max - b_min)
exit()
r_prev = b_prev = p_prev = inf
ri, bi = 0, 0
pi, pj = inf, -inf
r_edges = []
b_edges = []
for i in range(n):
if type_[i] == 'B':
bi += 1
if b_prev != inf:
b_edges.append((pos[i]-b_prev, bi-1, bi))
if p_prev != inf:
b_edges.append((pos[i]-p_prev, 0, bi))
b_prev = pos[i]
elif type_[i] == 'R':
ri += 1
if r_prev != inf:
r_edges.append((pos[i]-r_prev, ri-1, ri))
if p_prev != inf:
r_edges.append((pos[i]-p_prev, 0, ri))
r_prev = pos[i]
else:
if b_prev != inf:
b_edges.append((pos[i]-b_prev, 0, bi))
if r_prev != inf:
r_edges.append((pos[i]-r_prev, 0, ri))
p_prev = pos[i]
pi = min(pi, i)
pj = max(pj, i)
ans = pos[pj] - pos[pi]
ans += kruskal(ri+1, r_edges)
ans += kruskal(bi+1, b_edges)
print(ans)
```
No
| 89,860 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Submitted Solution:
```
n = int(input())
s = 0
x = []
c = []
for i in range(n):
a,b = input().split()
x.append(int(a))
c.append(b)
for i in range(n-1):
if c[i] != c[0]:
continue
if (c[i] == c[i+1] or c[i+1] == "P"):
s += x[i+1] - x[i]
else:
for j in range(i+2, n):
if(c[i] == c[j] or c[j] == "P"):
s += x[j] - x[i]
break
for i in range(n-1, 1, -1):
if c[i] == c[0]:
continue
if ((c[i] == c[i-1] and c[i-1] != "P") or (c[i] != "P" and c[i-1] == "P")):
s += x[i] - x[i-1]
else:
for j in range(i-2, 0, -1):
if(c[i] == c[j] or c[j] == "P"):
s += x[i] - x[j]
break
print(s)
```
No
| 89,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Submitted Solution:
```
def solv(p1,p2,a1):
ans1=0
r=[]
b=[]
for i in a1:
if(i[1]=='R'):
r.append(i[0])
elif(i[1]=='B'):
b.append(i[0])
ans1=2*(p2-p1)
ans2=p2-p1
if(len(r)):
L=[r[0]-p1]
R=[p2-r[-1]]
for i in range(1,len(r)):
L.append(r[i]-r[i-1] + L[-1])
for i in range(len(r)-1):
R.append(r[i+1]-r[i] + R[-1])
min1=min(L[-1],R[-1])
for i in range(len(r)-1):
min1=min(min1,L[i]+R[len(r)-i-1])
ans2+=min1
if(len(b)):
L=[b[0]-p1]
R=[p2-b[-1]]
for i in range(1,len(b)):
L.append(b[i]-b[i-1] + L[-1])
for i in range(len(b)-1):
R.append(b[i+1]-b[i] + R[-1])
min1=min(L[-1],R[-1])
for i in range(len(b)-1):
min1=min(min1,L[i]+R[len(r)-i-1])
ans2+=min1
print('in solv ',ans1,ans2,p1,p2)
return min(ans2,ans1)
n=int(input())
a=[]
for i in range(n):
x,y=input().split()
x=int(x)
a.append([x,y])
first=-1
last=-1
ans=0
for i in range(n):
if(a[i][1]=='P'):
if(first==-1):
first=i
else:
ans+=solv(a[last][0],a[i][0],a[last+1:i])
last=i
ans1=0
r=[]
b=[]
print(ans)
if(first!=-1):
for i in a[:first]:
if(i[1]=='R'):
r.append(i[0])
elif(i[1]=='B'):
b.append(i[0])
for i in range(len(r)-1):
ans+=r[i+1]-r[i]
for i in range(len(b)-1):
ans+=b[i+1]-b[i]
if(len(r)):
ans+=a[first][0]-r[-1]
if(len(b)):
ans+=a[first][0]-b[-1]
r=[]
b=[]
print(ans,r,b,first,a[:1])
for i in a[last:]:
if(i[1]=='R'):
r.append(i[0])
elif(i[1]=='B'):
b.append(i[0])
for i in range(len(r)-1):
ans+=r[i+1]-r[i]
for i in range(len(b)-1):
ans+=b[i+1]-b[i]
if(len(r)):
ans+=r[0]-a[last][0]
if(len(b)):
ans+=b[0]-a[last][0]
else:
r=[]
b=[]
for i in a:
if(i[1]=='R'):
r.append(i[0])
elif(i[1]=='B'):
b.append(i[0])
for i in range(len(r)-1):
ans+=r[i+1]-r[i]
for i in range(len(b)-1):
ans+=b[i+1]-b[i]
print(ans)
```
No
| 89,862 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The cities of Byteland and Berland are located on the axis Ox. In addition, on this axis there are also disputed cities, which belong to each of the countries in their opinion. Thus, on the line Ox there are three types of cities:
* the cities of Byteland,
* the cities of Berland,
* disputed cities.
Recently, the project BNET has been launched — a computer network of a new generation. Now the task of the both countries is to connect the cities so that the network of this country is connected.
The countries agreed to connect the pairs of cities with BNET cables in such a way that:
* If you look at the only cities of Byteland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables,
* If you look at the only cities of Berland and the disputed cities, then in the resulting set of cities, any city should be reachable from any other one by one or more cables.
Thus, it is necessary to choose a set of pairs of cities to connect by cables in such a way that both conditions are satisfied simultaneously. Cables allow bi-directional data transfer. Each cable connects exactly two distinct cities.
The cost of laying a cable from one city to another is equal to the distance between them. Find the minimum total cost of laying a set of cables so that two subsets of cities (Byteland and disputed cities, Berland and disputed cities) are connected.
Each city is a point on the line Ox. It is technically possible to connect the cities a and b with a cable so that the city c (a < c < b) is not connected to this cable, where a, b and c are simultaneously coordinates of the cities a, b and c.
Input
The first line contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^{5}) — the number of cities.
The following n lines contains an integer x_i and the letter c_i (-10^{9} ≤ x_i ≤ 10^{9}) — the coordinate of the city and its type. If the city belongs to Byteland, c_i equals to 'B'. If the city belongs to Berland, c_i equals to «R». If the city is disputed, c_i equals to 'P'.
All cities have distinct coordinates. Guaranteed, that the cities are given in the increasing order of their coordinates.
Output
Print the minimal total length of such set of cables, that if we delete all Berland cities (c_i='R'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables. Similarly, if we delete all Byteland cities (c_i='B'), it will be possible to find a way from any remaining city to any other remaining city, moving only by cables.
Examples
Input
4
-5 R
0 P
3 P
7 B
Output
12
Input
5
10 R
14 B
16 B
21 R
32 R
Output
24
Note
In the first example, you should connect the first city with the second, the second with the third, and the third with the fourth. The total length of the cables will be 5 + 3 + 4 = 12.
In the second example there are no disputed cities, so you need to connect all the neighboring cities of Byteland and all the neighboring cities of Berland. The cities of Berland have coordinates 10, 21, 32, so to connect them you need two cables of length 11 and 11. The cities of Byteland have coordinates 14 and 16, so to connect them you need one cable of length 2. Thus, the total length of all cables is 11 + 11 + 2 = 24.
Submitted Solution:
```
# B R P
def solve2(length, cities):
result = 0
for idx, city in enumerate(cities):
cityCode = city[1]
cityIdx = city[0]
it = idx - 1
visitedP = False
visitedN = False
visitedB = False
visitedR = False
BValue = 0
RValue = 0
PValue = 0
while(it >= 0):
neighbourCode = cities[it][1]
neighbourIdx = cities[it][0]
if(cityCode == 'P' ):
if(neighbourCode == 'B' and visitedB == False):
visitedB = True
BValue = neighbourIdx
elif(neighbourCode == 'R' and visitedR == False):
visitedR = True
RValue = neighbourIdx
elif(neighbourCode == 'P' and visitedP == False):
visitedP = True
PValue = neighbourIdx
it -= 1
if(visitedP and visitedB and visitedR): break
continue
if(neighbourCode == cityCode and visitedN == False):
visitedN = True
result += abs(cities[it][0] - cityIdx)
break
if(neighbourCode == 'P' and visitedP == False):
visitedP = True
result += abs(cities[it][0] - cityIdx)
break
it -= 1
if(cityCode == 'P'):
if(visitedB != False and visitedR != False and visitedP != False):
result += min(abs(RValue - cityIdx) + abs(BValue - cityIdx), abs(PValue - cityIdx))
elif(visitedP != False):
result += abs(PValue - cityIdx)
elif(visitedB != False and visitedR != False):
result += abs(RValue - cityIdx) + abs(BValue - cityIdx)
elif(visitedB != False):
result += abs(BValue - cityIdx)
elif(visitedR != False):
result += abs(RValue - cityIdx)
return result
def solve(length, cities):
result = 0
lastB = -1
lastP = -1
lastR = -1
for idx, city in enumerate(cities):
cityCode = city[1]
if(cityCode == 'P'):
if(lastP != -1 and lastB != -1 and lastR != -1):
if(abs(city[0] - cities[lastP][0]) < abs(city[0] - cities[lastR][0]) + abs(city[0] - cities[lastB][0])):
result += abs(city[0] - cities[lastP][0])
else: result += abs(city[0] - cities[lastR][0]) + abs(city[0] - cities[lastB][0])
elif(lastP > lastR and lastP > lastB): result += abs(city[0] - cities[lastP][0])
elif(lastR != -1 and lastB != -1): result += abs(city[0] - cities[lastR][0]) + abs(city[0] - cities[lastB][0])
elif(lastB > lastP and lastR == -1): result += abs(city[0] - cities[lastB][0])
elif(lastR > lastP and lastB == -1): result += abs(city[0] - cities[lastR][0])
lastP = idx
elif(cityCode == 'B'):
if(lastB != -1 and lastB > lastP): result += abs(city[0] - cities[lastB][0])
if(lastP != -1 and lastP > lastB): result += abs(city[0] - cities[lastP][0])
lastB = idx
else:
if(lastR != -1 and lastR > lastP): result += abs(city[0] - cities[lastR][0])
if(lastP != -1 and lastP > lastR): result += abs(city[0] - cities[lastP][0])
lastR = idx
return result
if __name__ == '__main__':
length = int(input())
cities = []
for i in range(length):
data = input().split(" ")
cities.append((int(data[0]), data[1]))
result = solve(length, cities)
print(result)
```
No
| 89,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
print(min((-n) % m * a, n % m * b))
```
| 89,864 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().strip().split())
if n == m:
print(0)
elif n < m:
if (m-n)*a < n*b:
print((m-n)*a)
else:
print(n*b)
elif n > m:
x = (n % m) * b
y = (m - (n % m)) * a
print(min(x,y))
```
| 89,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
q = n % m
p = n // m
print(min(((p + 1) * m - n) * a, q * b))
```
| 89,866 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
r = n % m
print(min(r * b, (m - r) * a))
```
| 89,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n, m, a, b = map(int, input().split())
n %= m
print(min(n * b, (m - n) * a))
```
| 89,868 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n,m,a,b=map(int,input().split())
print([0,min((n%m)*b,abs(m-n%m)*a)][n%m!=0])
```
| 89,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n,m,a,b=map(int,input().split())
if n%m==0:
print(0)
else:
x=a*(m*(n//m+1)-n)
y=b*(n-m*(n//m))
print(min(x,y))
```
| 89,870 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Tags: implementation, math
Correct Solution:
```
n,m,a,b=list(map(int,input().strip().split()))
if(n%m==0):
print(0)
else:
temp=n//m
demo=n-temp*m
demo=demo*b
temp=temp+1
bui=temp*m-n
bui=bui*a
if(bui>=demo):
print(demo)
else:
print(bui)
```
| 89,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
ans = 0
if n%m==0:
pass
elif n<m:
ans = min(b*n, a*(m-n))
else:
ans = min(b*(n%m), a*(m-(n%m)))
print(ans)
```
Yes
| 89,872 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
d = n % m
print(min(d * b, (m - d) * a))
```
Yes
| 89,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n, m, a, b = map(int, input().split())
if n % m == 0:
print(0)
else:
res1 = (n % m) * b
res2 = (m - n % m) * a
print(min(res1, res2))
```
Yes
| 89,874 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b = input().split(" ")
n = int(n)
m = int(m)
a = int(a)
b = int(b)
if n%m==0:
print(0)
else:
ba = int(n/m)
bb = ba
ba = ba + 1
ba = ba * m - n
ba = ba * a
bb = n-bb*m
bb = bb*b
if bb>ba:
print(ba)
else:
print(bb)
```
Yes
| 89,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b=list(map(int,input().split()))
l=[]
todestroy=(n%m)*b
tocreate=((n+m)//m*m-n)*a
print(tocreate)
l.append(todestroy)
l.append(tocreate)
print(min(l))
```
No
| 89,876 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b = input().split()
n = int(n)
m = int(m)
a = int(a)
b = int(b)
if(m%m==0):
print("0")
else:
if(n<m):
cost_of_const = (m-n)*a
cost_of_dest = n*b
print(min(cost_of_const , cost_dest))
else:
s = n//m
cost_of_dest = (n-s)*b
cost_of_const = (n+1-s)*a
print(min(cost_of_const , cost_dest))
```
No
| 89,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
n,m,a,b=[int(x) for x in input().split()]
k=n
t=m
while n%t!=0:
t-=1
while k%m!=0:
k+=1
print(min((k-n)*a,(m-t)*b))
```
No
| 89,878 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Berland Football Cup starts really soon! Commentators from all over the world come to the event.
Organizers have already built n commentary boxes. m regional delegations will come to the Cup. Every delegation should get the same number of the commentary boxes. If any box is left unoccupied then the delegations will be upset. So each box should be occupied by exactly one delegation.
If n is not divisible by m, it is impossible to distribute the boxes to the delegations at the moment.
Organizers can build a new commentary box paying a burles and demolish a commentary box paying b burles. They can both build and demolish boxes arbitrary number of times (each time paying a corresponding fee). It is allowed to demolish all the existing boxes.
What is the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m)?
Input
The only line contains four integer numbers n, m, a and b (1 ≤ n, m ≤ 10^{12}, 1 ≤ a, b ≤ 100), where n is the initial number of the commentary boxes, m is the number of delegations to come, a is the fee to build a box and b is the fee to demolish a box.
Output
Output the minimal amount of burles organizers should pay to satisfy all the delegations (i.e. to make the number of the boxes be divisible by m). It is allowed that the final number of the boxes is equal to 0.
Examples
Input
9 7 3 8
Output
15
Input
2 7 3 7
Output
14
Input
30 6 17 19
Output
0
Note
In the first example organizers can build 5 boxes to make the total of 14 paying 3 burles for the each of them.
In the second example organizers can demolish 2 boxes to make the total of 0 paying 7 burles for the each of them.
In the third example organizers are already able to distribute all the boxes equally among the delegations, each one get 5 boxes.
Submitted Solution:
```
a,b,c,d=[int(i) for i in input().split()]
if(a%b==0):
print(0)
else:
a1=b-(a%b)
a2=a-(a//b)
print(min(a1*c,a2*d))
```
No
| 89,879 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
n = int(input())
x = input()
x10 = int(x, 2)
lenx = len(x)
maxbit = x.count("1")
xc0 = x10 % (maxbit + 1)
xc1 = x10 % (maxbit - 1) if maxbit > 1 else 0
def f(ii):
cnt = 0
while ii > 0:
ii %= bin(ii).count("1")
cnt += 1
return cnt
for i in range(lenx):
if x[i] == "0":
t = xc0 + pow(2, (lenx - 1 - i), maxbit + 1)
ans = f(t % (maxbit + 1)) + 1
else:
if maxbit - 1 == 0:
ans = 0
else:
t = xc1 - pow(2, (lenx - 1 - i), maxbit - 1)
ans = f(t % (maxbit - 1)) + 1
print(ans)
```
| 89,880 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
N=int(input())
X=input()
c=X.count('1')
r1=int(X,2)%(c-1) if c>1 else 0
r2=int(X,2)%(c+1)
d=[0]*(N+1)
for i in range(N):
d[i+1]=d[(i+1)%bin(i+1).count('1')]+1
for i in range(N):
if X[i]=='0':
n=(r2+pow(2,N-i-1,c+1))%(c+1)
else:
if c==1:
print(0)
continue
n=(r1-pow(2,N-i-1,c-1))%(c-1)
print(d[n]+1)
```
| 89,881 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
N = int(input())
X = input()
popcount_X = X.count('1')
numX = int(X, 2)
a, b = numX % (popcount_X + 1), numX % (popcount_X - 1) if popcount_X != 1 else 0
for i, x in enumerate(X, 1):
if x == '1' and popcount_X == 1:
print(0); continue
ans = 1
if x == '1':
temp = (b - pow(2, N - i, popcount_X - 1)) % (popcount_X - 1)
else:
temp = (a + pow(2, N - i, popcount_X + 1)) % (popcount_X + 1)
while temp:
p = format(temp, 'b').count('1')
temp %= p
ans += 1
print(ans)
```
| 89,882 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
def f(n):
cnt = 0
while n:
buf = n
pc = 0
while buf:
pc += buf%2
buf //= 2
n = n%pc
cnt += 1
return cnt
N = int(input())
X = input()
v1, v2 = 0, 0
cnt = X.count("1")
for i, j in enumerate(X[::-1]):
if j=="1":
v1 += pow(2, i, cnt+1)
v1 %= (cnt+1)
if cnt>1:
v2 += pow(2, i, cnt-1)
v2 %= (cnt-1)
for i in range(N):
p = N-i-1
buf = 0
c2 = 0
if X[i]=="0":
c2 = cnt+1
buf = (v1+pow(2, p, c2))%c2
print(f(buf)+1)
else:
c2 = cnt-1
if c2>0:
buf = (v2-pow(2, p, c2))%c2
print(f(buf)+1)
else:
print(0)
```
| 89,883 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
N = int(input())
X = input()
temp = X.count("1")
t = [0, 0, 0]
t[0] = int(X, 2) % (temp-1) if temp != 1 else 0
t[2] = int(X, 2) % (temp+1)
cnt = 0
for i in range(N):
if X[i] == "1" and temp == 1:
print(0)
continue
if X[i] == "1":
# p = (1 << (N-i-1)) % (temp-1)
p = pow(2, N-1-i, temp-1)
a = (t[0]-p) % (temp-1)
elif X[i] == "0":
# m = (1 << (N-i-1)) % (temp+1)
m = pow(2, N-1-i, temp+1)
a = (t[2]+m) % (temp+1)
cnt = 1
while a > 0:
a = a % format(a, 'b').count("1")
cnt += 1
print(cnt)
```
| 89,884 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
N = int(input())
X = int(input(), 2)
M = 2 * (10 ** 5) + 10
ret = [0] * (M + 1)
for i in range(M + 1) :
x = i
c = 0
while x != 0 :
x = x % bin(x).count('1')
c += 1
ret[i] = c
p = bin(X).count('1')
a = X % (p + 1)
if p > 1 :
b = X % (p - 1)
for i in range(N - 1, -1, -1) :
if (1 << i) & X :
if p == 1 :
print(0)
else :
print(ret[(b - pow(2, i, p - 1)) % (p - 1)] + 1)
else :
print(ret[(a + pow(2, i, p + 1)) % (p + 1)] + 1)
```
| 89,885 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
def count_pop(y):
count = 0
while y != 0:
if y & 1 == 1:count+=1
y = y >> 1
return count
def main():
N = int(input())
X = input()
X_val=int(X,2)
X_pc=X.count('1')
x_mod_pc_x_plus_1 = X_val % (X_pc + 1)
x_mod_pc_x_minus_1 = X_val % max(X_pc - 1, 1)
for i in range(N):
if X[i] == '1':
pc = X_pc - 1
if pc == 0:
print(0)
continue
val = (x_mod_pc_x_minus_1 - pow(2, N-i-1, pc)) % pc
else:
pc = X_pc + 1
val = (x_mod_pc_x_plus_1 + pow(2, N-i-1, pc)) % pc
ans = 1
while val > 0:
val %= bin(val).count('1')
ans += 1
print(ans)
pass
if __name__=='__main__':
main()
```
| 89,886 |
Provide a correct Python 3 solution for this coding contest problem.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
"Correct Solution:
```
n = int(input())
x = list(map(int, input()))
one_cnt = x.count(1)
mods = [one_cnt - 1, one_cnt + 1]
sms = [0, 0]
for i in range(2):
if mods[i] == 0:
continue
for j, e in enumerate(x):
sms[i] += pow(2, n - j - 1, mods[i]) * e
sms[i] %= mods[i]
for i, e in enumerate(x):
idx = 1 - e
mod = mods[idx]
sm = sms[idx]
if mod == 0:
print(0)
continue
sm_changed = sm + pow(2, n - i - 1, mod) * (-1) ** e
sm_changed %= mod
ans = 1
while sm_changed:
tmp = sm_changed
cnt = 0
while tmp:
cnt += tmp & 1
tmp >>= 1
sm_changed %= cnt
ans += 1
print(ans)
```
| 89,887 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
def pop_count(n):
return sum(n >> i & 1 for i in range(n.bit_length()))
def f(n):
if n == 0:
return 0
return f(n % pop_count(n)) + 1
N = int(input())
X = input()
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print(f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)
elif p > 1:
print(f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)
else:
print(0)
```
Yes
| 89,888 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
N = int(input())
S = input()
def pcnt(x):
return str(bin(x)).count("1")
dpl = 5*10**5
dp = [0] * dpl
for i in range(1, dpl):
dp[i] = dp[i % pcnt(i)]+1
c = S.count("1")
a = int(S, 2) % (c+1)
def f():
if c == 1:
for i in range(N):
if S[i] == "0":
print(dp[(a + pow(2, N-i-1, c+1)) % (c+1)] + 1)
else:
print(0)
return
b = int(S, 2) % (c-1)
for i in range(N):
if S[i] == "0":
print(dp[(a+pow(2, N-i-1, c+1))%(c+1)]+1)
else:
print(dp[(b-pow(2, N-i-1, c-1))%(c-1)]+1)
f()
```
Yes
| 89,889 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
n = int(input())
x = input()
k = x.count("1")
cnt = 0
s = int(x, 2)
if k >= 2:
k1 = s % (k-1)
k2 = s % (k+1)
while s != 0:
targ = bin(s).count("1")
s = s % targ
cnt += 1
def ev(n):
cnt = 0
while n != 0:
m = bin(n).count("1")
n = n % m
cnt += 1
return cnt
if k != 1:
for i in range(n):
if x[i] == "0":
targ = k+1
print(ev((k2+pow(2, n-i-1, targ)) % targ)+1)
else:
targ = k-1
print(ev((k1-pow(2, n-i-1, targ)) % targ)+1)
else:
for i in range(n):
if x[i] == "0":
targ = k+1
print(ev((k2+pow(2, n-i-1, targ)) % targ)+1)
else:
targ = k-1
print(0)
```
Yes
| 89,890 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
n = int(input())
sn = input()
sr = ''.join(list(reversed(sn)))
sint = int(sn, 2)
spop = sn.count('1')
def f(x):
count = 0
while x != 0:
count += 1
pop = bin(x).count('1')
x %= pop
return count
m1 = sint % (spop + 1)
m2 = 0 if spop <= 1 else sint % (spop - 1)
a = [0] * n
for i in range(n):
if sr[i] == '0':
d = pow(2, i, spop + 1)
m = (m1 + d) % (spop + 1)
a[i] = f(m) + 1
elif spop != 1:
d = pow(2, i, spop - 1)
m = (m2 - d + spop - 1) % (spop - 1)
a[i] = f(m) + 1
else:
a[i] = 0
for ans in reversed(a):
print(ans)
```
Yes
| 89,891 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
n = int(input())
x = input()
num = 0
count = 0
for i in range(n):
if x[-(i+1)] == "1":
num += 2**i
count += 1
mod = [[0, 0] for _ in range(n)]
for i in range(n):
mod[i][0] = 2**i%(count-1) if count!=1 else 0
mod[i][1] = 2**i%(count+1)
mod1 = num%(count-1) if count!=1 else 0
mod2 = num%(count+1)
ans = [0]*n
for i in range(n):
if x[-(i+1)] == "1":
_num = num-2**i
if _num == 0:
continue
_num = (mod1-mod[i][0])%(count-1)
else:
_num = num+2**i
_num = (mod2+mod[i][1])%(count+1)
ans[i] += 1
_count = 0
for c in bin(_num):
if c == "1":
_count += 1
while True:
if _num == 0:
break
_num %= _count
_count = 0
for c in bin(_num):
if c == "1":
_count += 1
ans[i] += 1
for i in range(n):
print(ans[-(i+1)])
```
No
| 89,892 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
def popcount(x):
ans = 0
while x > 0:
if x & 1:
ans += 1
x >>= 1
return ans
def f(x, pc, memo=None):
if memo and (x, pc) in memo:
return memo[(x, pc)]
r = x % pc
if memo:
memo[(x, pc)] = r
return r
N = int(input())
X = input()
x = int(X, 2)
memo = {}
pc_x = X.count('1')
for i in range(N):
if X[i] == '1':
pc = pc_x - 1
else:
pc = pc_x + 1
if pc == 0:
print('0')
continue
f_x = f(x, pc, memo)
f_res = f(1<<(N-i-1), pc, memo)
if X[i] == '1':
f_i = f_x - f_res
else:
f_i = f_x + f_res
f_i = (f_i + 2 * pc) % pc
ans = 1
while f_i > 0:
ans += 1
pc = popcount(f_i)
f_i = f(f_i, pc)
print(ans)
```
No
| 89,893 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
N = int(input())
X = int('0b' + input(), 0)
for i in range(N-1, -1, -1):
xx = X ^ (1 << i)
c = 0
while xx > 0:
x = xx - ((xx >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x += (x >> 8)
x += (x >> 16)
x += (x >> 32)
x &= 0x0000007f
xx %= x
c += 1
else:
print(c)
```
No
| 89,894 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let \mathrm{popcount}(n) be the number of `1`s in the binary representation of n. For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.
Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)
For example, when n=7, it becomes 0 after two operations, as follows:
* \mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.
* \mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.
You are given an integer X with N digits in binary. For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted. Find f(X_1), f(X_2), \ldots, f(X_N).
Constraints
* 1 \leq N \leq 2 \times 10^5
* X is an integer with N digits in binary, possibly with leading zeros.
Input
Input is given from Standard Input in the following format:
N
X
Output
Print N lines. The i-th line should contain the value f(X_i).
Examples
Input
3
011
Output
2
1
1
Input
23
00110111001011011001110
Output
2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3
Submitted Solution:
```
n = int(input())
x = input()
c = x.count("1")
for i in range(n):
a = int(x[i])
if a == 1:
a = 0
cc = c - 1
else:
a = 1
cc = c + 1
ref = int(x[:i] + str(a) + x[i + 1:], 2)
cnt = 0
ref = ref%cc
cnt += 1
while ref > 0:
bitcnt = bin(ref).count("1")
ref = ref%bitcnt
cnt += 1
print(cnt)
```
No
| 89,895 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N jewelry shops numbered 1 to N.
Shop i (1 \leq i \leq N) sells K_i kinds of jewels. The j-th of these jewels (1 \leq j \leq K_i) has a size and price of S_{i,j} and P_{i,j}, respectively, and the shop has C_{i,j} jewels of this kind in stock.
A jewelry box is said to be good if it satisfies all of the following conditions:
* For each of the jewelry shops, the box contains one jewel purchased there.
* All of the following M restrictions are met.
* Restriction i (1 \leq i \leq M): (The size of the jewel purchased at Shop V_i)\leq (The size of the jewel purchased at Shop U_i)+W_i
Answer Q questions. In the i-th question, given an integer A_i, find the minimum total price of jewels that need to be purchased to make A_i good jewelry boxes. If it is impossible to make A_i good jewelry boxes, report that fact.
Constraints
* 1 \leq N \leq 30
* 1 \leq K_i \leq 30
* 1 \leq S_{i,j} \leq 10^9
* 1 \leq P_{i,j} \leq 30
* 1 \leq C_{i,j} \leq 10^{12}
* 0 \leq M \leq 50
* 1 \leq U_i,V_i \leq N
* U_i \neq V_i
* 0 \leq W_i \leq 10^9
* 1 \leq Q \leq 10^5
* 1 \leq A_i \leq 3 \times 10^{13}
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
Description of Shop 1
Description of Shop 2
\vdots
Description of Shop N
M
U_1 V_1 W_1
U_2 V_2 W_2
\vdots
U_M V_M W_M
Q
A_1
A_2
\vdots
A_Q
The description of Shop i (1 \leq i \leq N) is in the following format:
K_i
S_{i,1} P_{i,1} C_{i,1}
S_{i,2} P_{i,2} C_{i,2}
\vdots
S_{i,K_i} P_{i,K_i} C_{i,K_i}
Output
Print Q lines. The i-th line should contain the minimum total price of jewels that need to be purchased to make A_i good jewelry boxes, or -1 if it is impossible to make them.
Examples
Input
3
2
1 10 1
3 1 1
3
1 10 1
2 1 1
3 10 1
2
1 1 1
3 10 1
2
1 2 0
2 3 0
3
1
2
3
Output
3
42
-1
Input
5
5
86849520 30 272477201869
968023357 28 539131386006
478355090 8 194500792721
298572419 6 894877901270
203794105 25 594579473837
5
730211794 22 225797976416
842538552 9 420531931830
871332982 26 81253086754
553846923 29 89734736118
731788040 13 241088716205
5
903534485 22 140045153776
187101906 8 145639722124
513502442 9 227445343895
499446330 6 719254728400
564106748 20 333423097859
5
332809289 8 640911722470
969492694 21 937931959818
207959501 11 217019915462
726936503 12 382527525674
887971218 17 552919286358
5
444983655 13 487875689585
855863581 6 625608576077
885012925 10 105520979776
980933856 1 711474069172
653022356 19 977887412815
10
1 2 231274893
2 3 829836076
3 4 745221482
4 5 935448462
5 1 819308546
3 5 815839350
5 3 513188748
3 1 968283437
2 3 202352515
4 3 292999238
10
510266667947
252899314976
510266667948
374155726828
628866122125
628866122123
1
628866122124
510266667949
30000000000000
Output
26533866733244
13150764378752
26533866733296
19456097795056
-1
33175436167096
52
33175436167152
26533866733352
-1
Submitted Solution:
```
import math
print(math.floor(1.1421))
#1
print(math.floor(1.7320))
#1
print(math.floor(1.5))
#1
print(math.floor(2.5))
#2
print(math.floor(3.5))
#3
```
No
| 89,896 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
LARGE = 998244353
def solve(n):
r = 0
mck = 1
factorial_n = 1
factorial_inv = [0] * (n + 1)
factorial_inv[0] = 1
for i in range(1, n + 1):
factorial_n *= i
factorial_n %= LARGE
factorial_inv[-1] = pow(factorial_n, LARGE - 2, LARGE)
for i in range(n):
factorial_inv[n - i - 1] = (factorial_inv[n - i] * (n - i)) % LARGE
pow_2 = 1
for k in range(n // 2):
r += factorial_n * factorial_inv[n - k] * factorial_inv[k] * pow_2
r %= LARGE
pow_2 *= 2
pow_2 %= LARGE
res = (pow(3, n, LARGE) - (2 * r)) % LARGE
return res
def main():
n = int(input())
res = solve(n)
print(res)
def test():
assert solve(2) == 7
assert solve(10) == 50007
# assert solve(1000000) == 210055358
if __name__ == "__main__":
test()
main()
```
| 89,897 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
N = int(input())
nn = N + 10
P = 998244353
fa = [1] * (nn+1)
fainv = [1] * (nn+1)
for i in range(nn):
fa[i+1] = fa[i] * (i+1) % P
fainv[-1] = pow(fa[-1], P-2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i+1) % P
C = lambda a, b: fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
ans = pow(3, N, P)
for i in range(N//2 + 1, N + 1):
ans = (ans - 2 * C(N, i) * pow(2, N - i, P)) % P
print(ans)
```
| 89,898 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a positive even number N.
Find the number of strings s of length N consisting of `A`, `B`, and `C` that satisfy the following condition:
* s can be converted to the empty string by repeating the following operation:
* Choose two consecutive characters in s and erase them. However, choosing `AB` or `BA` is not allowed.
For example, `ABBC` satisfies the condition for N=4, because we can convert it as follows: `ABBC` → (erase `BB`) → `AC` → (erase `AC`) → `(empty)`.
The answer can be enormous, so compute the count modulo 998244353.
Constraints
* 2 \leq N \leq 10^7
* N is an even number.
Input
Input is given from Standard Input in the following format:
N
Output
Print the number of strings that satisfy the conditions, modulo 998244353.
Examples
Input
2
Output
7
Input
10
Output
50007
Input
1000000
Output
210055358
"Correct Solution:
```
def calc(n, mod):
f = 1
fac = [1]
for i in range(1, n + 1):
f *= i
f %= mod
fac.append(f)
inv = pow(f, mod - 2, mod)
invs = [1] * (n + 1)
invs[n] = inv
for i in range(n, 1, -1):
inv *= i
inv %= mod
invs[i - 1] = inv
return fac, invs
def cnk(n, r, mod, fac, inv):
return fac[n] * inv[n - r] * inv[r] % mod
n = int(input())
mod = 998244353
f, inv = calc(n + 10, mod)
ans = pow(3, n, mod)
p = [1]
for i in range(n // 2 + 10):
p.append(p[-1] * 2 % mod)
for k in range(n // 2 + 1, n + 1):
cur = 2 * cnk(n, k, mod, f, inv) * p[n - k]
ans -= cur
ans %= mod
print(ans)
```
| 89,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.