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.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
Submitted Solution:
```
def multiplication_table(number1, number2):
count = 0
value = 1
while value <= number2 ** 0.5:
if number2 % value == 0 and value <= n and number2 // value <= n:
if value != number2 // value:
count += 2
else:
count += 1
value += 1
return count
n, x = map(int, input().split())
print(multiplication_table(n, x))
```
Yes
| 13,700 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
Submitted Solution:
```
n, x = tuple(map(int, input().split()))
d = 1
res = 0
while d * d < x:
if d > n or x / d > n:
d += 1
continue
if x % d == 0:
res += 1
d+=1
res *= 2
if d * d == x:
res += 1
print(res)
```
No
| 13,701 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
Submitted Solution:
```
n, x = input().split()
n, x = int(n), int(x)
import math
rt = math.sqrt(x)
count = 0
if x < n:
for i in range(1, int(rt)):
if (x % i == 0) and i <= n:
count = count + 1
count = 2* count
else:
count = 0
if int(rt) == rt:
count = count + 1
print(count)
```
No
| 13,702 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
Submitted Solution:
```
z=list(map(int,input().split()))
s=[]
c=1
for i in range(1,z[1]+1):
for o in range(1,+z[1]+1):
sd=i*o
if sd== z[1] :
s.append(sd)
print(len(s))
```
No
| 13,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's consider a table consisting of n rows and n columns. The cell located at the intersection of i-th row and j-th column contains number i Γ j. The rows and columns are numbered starting from 1.
You are given a positive integer x. Your task is to count the number of cells in a table that contain number x.
Input
The single line contains numbers n and x (1 β€ n β€ 105, 1 β€ x β€ 109) β the size of the table and the number that we are looking for in the table.
Output
Print a single number: the number of times x occurs in the table.
Examples
Input
10 5
Output
2
Input
6 12
Output
4
Input
5 13
Output
0
Note
A table for the second sample test is given below. The occurrences of number 12 are marked bold.
<image>
Submitted Solution:
```
from __future__ import division, print_function
from collections import *
from math import *
from itertools import *
from time import time
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
'''
Notes:
n = size of the table
x = number
'''
def main():
n, x = map(int, input().split())
count = 0
if n >= x:
count = 2
else:
count = 0
for i in range(2, min(x, n)+1):
if x % i == 0:
count += 1
if floor(sqrt(x)) ** 2 == x:
count -= 1
print(count)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
```
No
| 13,704 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
p, q = int(input()), 1
t, n = [], 1
while p > n * q:
if p % q == 0: t.append((p // q, n))
n += 1
q += n
p += (n * n - n) // 2
t += [(m, n) for n, m in t]
if p == n * q: t.append((n, n))
print(len(t))
for n, m in sorted(t): print(n, m)
```
| 13,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/D.in', 'r')
T = 1
def process():
ans = []
N = int(input())
for i in range(1, 3000000):
a = N + i * (i - 1) * (i + 1) // 6
j, mod = divmod(a, i * (i + 1) // 2)
if i > j: break
if mod: continue
ans.append((i, j))
if i != j: ans.append((j, i))
ans.sort()
print(len(ans))
for i, j in ans: print(i, j)
for _ in range(T):
process()
```
| 13,706 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
n,i,t,r=int(input()),0,0,[]
while n>=0:
i+=1
n-=i*i
t+=i
m=n//t+i
r+=[(m,i),(i,m)][m==i:]*(n%t==0<=n)
for p in[(len(r),'')]+sorted(r):print("%d %s"%p)
```
| 13,707 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
from collections import Counter
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def printlist(l): print(' '.join([str(x) for x in l]))
n = it()
L = []
R = []
for i in range(1,int((3*n)**(1/3))+1):
if 6*n % (i*(i+1)) == 0:
if ((6*n) // (i*(i+1)) + i - 1) % 3 == 0:
t = ((6*n) // (i*(i+1)) + i - 1) // 3
L.append([i,t])
if i < t:
R.insert(0,[t,i])
result = L + R
print(len(result))
for i in result:
printlist(i)
```
| 13,708 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
__author__ = 'MoonBall'
import sys
# sys.stdin = open('data/D.in', 'r')
T = 1
def process():
ans = []
N = int(input())
for i in range(1, N + 1):
a = N + i * (i - 1) * (i + 1) // 6
j, mod = divmod(a, i * (i + 1) // 2)
if i > j: break
if mod: continue
ans.append((i, j))
if i != j: ans.append((j, i))
ans.sort()
print(len(ans))
for i, j in ans: print(i, j)
for _ in range(T):
process()
```
| 13,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
s = int(input())
"""
nm + (n-1)(m-1) + ...
nm + nm -(n+m) + 1
6x
= 6mn*n - 3*(n-1)n(n+m) + (n-1)*n*(2n-1)
6x - n*(n+1)*(2n+1)+3*(n-1)n*n = (6n*n - 3*(n-1)*n)*m
"""
a, b = [], []
for n in range(1,1450000):
u = 6*s - n*(n-1)*(n+n-1)+3*(n-1)*n*n
v = 6*n*n - 3*(n-1)*n
if u % v == 0:
u //= v
if n <= u:
a += [(n, u)]
if n < u:
b += [(u, n)]
else:
break
print(len(a)+len(b))
for e in a:
print(*e)
for e in reversed(b):
print(*e)
```
| 13,710 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
x = int(input()) * 6
n, equ, ans = 0, False, []
while True:
n += 1
if n * (n + 1) * (2 * n - 1) > x:
break
if x % n != 0:
continue
if x % (n + 1) != 0:
continue
m = x // n // (n + 1) + n - 1
if m % 3 != 0:
continue
m = m // 3
if n <= m:
ans.append((n, m))
if n == m:
equ = True
print(len(ans) * 2 - equ)
for p in ans:
print("%d %d" % (p[0], p[1]))
if equ:
ans.pop()
ans.reverse()
for p in ans:
print("%d %d" % (p[1], p[0]))
```
| 13,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Tags: brute force, math
Correct Solution:
```
def main():
x = int(input())
l = squares(x)
last = l[len(l) - 1]
if last[0] != last[1]:
print(2 * len(l))
else:
print(2 * len(l) - 1)
for pair in l:
print(pair[0], pair[1])
if last[0] != last[1]:
for pair in l[::-1]:
print(pair[1], pair[0])
else:
revL = l[::-1]
for pair in revL[1:]:
print(pair[1], pair[0])
def squares(x):
if x == 1:
return [(1, 1)]
result = []
cubeRoot = int((6 * x)**(1/3))
n = 1
while n <= cubeRoot:
#m = (y / (n * (n + 1)) + n - 1) / 3
y = 6 * x
temp = n * (n + 1)
if y % temp == 0:
y //= temp
y += n - 1
if y % 3 == 0:
m = y // 3
if m >= n:
result += [(n, m)]
n += 1
return result
#main()
main()
```
| 13,712 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
n,i,t,r=int(input()),0,0,[]
while n>=0:
i+=1
n-=i*i
t+=i
m=n//t
r+=[(m+i,i),(i,m+i)][m==0:]*(m*t==n>=0)
for p in[(len(r),'')]+sorted(r):print("%d %s"%p)
```
Yes
| 13,713 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
n = int(input())
i = 0
s = 0
t = 0
x = 0
f = 0
res1 = []
res2 = []
while n >= 0:
i = i + 1
n = n - i * i
if ( n < 0 ):
break
t = t + i
m = n // t
if ( m * t != n ):
continue
else:
res1.append( i )
res2.append( m + i )
x = x + 1
if m == 0:
f = 1
print ( str(int(2 * x - f)) )
for i in range(x):
print( str(int(res1[i])) + " " + str(int(res2[i])))
res1.reverse()
res2.reverse()
for i in range(x):
if ( res1[i] != res2[i] ):
print( str(int(res2[i])) + " " + str(int(res1[i])))
```
Yes
| 13,714 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from itertools import chain, combinations
from functools import reduce
from collections import defaultdict
def res(m,n):
k = min(m,n)
return (1+k)*(k+2*k**2-3*k*(m+n)+6*m*n) // 6
def powerset(iterable):
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
def prod(it):
r = 1
for elem in it:
r *= elem
return r
def factorGenerator(n):
res = defaultdict(lambda: 0)
for p in range(2,10**6+1):
while n % p == 0:
res[p] += 1
n = n // p
return res
def divisorGen(n):
factors = list(factorGenerator(n).items())
nfactors = len(factors)
f = [0] * nfactors
while True:
yield reduce(lambda x, y: x*y, [factors[x][0]**f[x] for x in range(nfactors)], 1)
i = 0
while True:
f[i] += 1
if f[i] <= factors[i][1]:
break
f[i] = 0
i += 1
if i >= nfactors:
return
def res2(x):
r = []
x6 = 6 * x
divisors = set(divisorGen(x6))
for m in divisors:
a = x6 // m
if a % (m+1) != 0:
continue
b = a // (m+1)
c = b + m - 1
if c % 3 != 0:
continue
n = c // 3
if n < m:
continue
if res(m,n) != x:
continue
r.append((m,n))
return r
x = int(input())
r = res2(x)
r = r + [(n,m) for m,n in r]
r = sorted(set(r))
print(len(r))
for (m,n) in r:
print("%d %d"%(m, n))
```
Yes
| 13,715 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
x = int(input())
def solve(x):
count = 0
lst = []
x6 = x * 6
for n in range(1, x + 1):
t, r = divmod(x6, n*(n+1))
if t < 2*n + 1:
break
if r:
continue
m, r = divmod(t + n - 1, 3)
if r:
continue
count += 2
lst.append((n, m))
nn, mm = lst[-1]
if nn == mm:
count -= 1
print(count)
for n, m in lst:
print(n, m)
if nn != mm:
print(mm, nn)
lst.reverse()
for n, m in lst[1:]:
print(m, n)
solve(x)
```
Yes
| 13,716 |
Evaluate the correctness of the submitted Python 2 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from sys import stdin, stdout
from collections import Counter, defaultdict
pr=stdout.write
import heapq
raw_input = stdin.readline
def ni():
return int(raw_input())
def li():
return list(map(int,raw_input().split()))
def pn(n):
stdout.write(str(n)+'\n')
def pa(arr):
pr(' '.join(map(str,arr))+'\n')
# fast read function for total integer input
def inp():
# this function returns whole input of
# space/line seperated integers
# Use Ctrl+D to flush stdin.
return (map(int,stdin.read().split()))
range = xrange # not for python 3.0+
# main code
x=ni()
y=1
n=1
ans=[]
while x>=y*n:
if x%y==0:
ans.append((x/y,n))
if ans[-1][0]!=ans[-1][1]:
ans.append((n,x/y))
n+=1
x+=(n**2-n)/2
y+=n
pn(len(ans))
for i in ans:
pa(i)
```
No
| 13,717 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
sum = int(input())
a = []
b = []
def func(sum,m):
return 2*(sum - (m*m*m - m)//3)/(m*(m+1)) + m - 1
if (sum == 1):
print(1)
print('1 1')
else:
k = 1
for i in range (1, sum ):
z = func(sum, i)
if z % 1 == 0 and (z - i +1)*i*(i+1)//2 + (i*i*i - i)//3 == sum:
if (len(a)) > 0 and i == a[len(a)-1]:
k = 0
break
if (k == 0):
break
a.append(str(i) + ' ' + str(int(z)))
b.append(str(int(z)) + ' ' + str(i))
if k == 0:
break
if a[len(a)-1] != b[len(a)-1] :
print(2*len(a))
for i in range (len(a)):
print(a[i])
for i in range (len(a)):
print(b[len(a)-1-i])
else:
print(2*len(a)-1)
for i in range (len(a)):
print(a[i])
for i in range (len(a)-1):
print(b[len(a)-1-i])
```
No
| 13,718 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
from collections import Counter
def mp(): return map(int,input().split())
def lt(): return list(map(int,input().split()))
def pt(x): print(x)
def ip(): return input()
def it(): return int(input())
def sl(x): return [t for t in x]
def spl(x): return x.split()
def aj(liste, item): liste.append(item)
def bin(x): return "{0:b}".format(x)
def listring(l): return ' '.join([str(x) for x in l])
def printlist(l): print(' '.join([str(x) for x in l]))
n = it()
L = []
R = []
for i in range(1,int((3*n)**(1/3))+1):
if 6*n % (i*(i+1)) == 0:
if ((6*n) // (i*(i+1)) + i - 1) % 3 == 0:
t = ((6*n) // (i*(i+1)) + i - 1) // 3
L.append([i,t])
R.insert(0,[t,i])
result = L + R
for i in result:
printlist(i)
```
No
| 13,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
x = int(input())
res = []
ok = -1
for i in range(1, 1000001):
m = i
tmp = (m-1)*(m+1)*m//6 + x
if (tmp*2) % (m*(m+1)) == 0:
n = int((tmp*2) // (m*(m+1)))
if n > m:
res.append([i, n])
if n == m and ok == -1:
ok = len(res)
res.append([i, i])
d = 0 if ok == -1 else 1
print (len(res) * 2 - d)
for i in range(len(res)):
print (str(res[i][0]) + " " + str(res[i][1]))
for i in range(len(res)):
if i != ok:
print (str(res[len(res)-i-1][1]) + " " + str(res[len(res)-i-1][0]))
```
No
| 13,720 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 Γ 5 table there are 15 squares with side one, 8 squares with side two and 3 squares with side three. The total number of distinct squares in a 3 Γ 5 table is 15 + 8 + 3 = 26.
Input
The first line of the input contains a single integer x (1 β€ x β€ 1018) β the number of squares inside the tables Spongebob is interested in.
Output
First print a single integer k β the number of tables with exactly x distinct squares inside.
Then print k pairs of integers describing the tables. Print the pairs in the order of increasing n, and in case of equality β in the order of increasing m.
Examples
Input
26
Output
6
1 26
2 9
3 5
5 3
9 2
26 1
Input
2
Output
2
1 2
2 1
Input
8
Output
4
1 8
2 3
3 2
8 1
Note
In a 1 Γ 2 table there are 2 1 Γ 1 squares. So, 2 distinct squares in total.
<image>
In a 2 Γ 3 table there are 6 1 Γ 1 squares and 2 2 Γ 2 squares. That is equal to 8 squares in total.
<image>
Submitted Solution:
```
__author__ = 'Utena'
k=int(input())
n=1
m=[]
if k==999999999999999999:
print("6\n1 999999999999999999\n13 10989010989010993\n37 1422475106685645\n1422475106685645 37\n10989010989010993 13\n999999999999999999 1")
exit(0)
while True:
t=((k-int(n*(n+1)*(2*n+1)/6))/(int(n*(n+1)/2)))
if t>=0 and t%1==0:
m.append([n,n+t])
if n>100000:break
n+=1
u=len(m)
if m[-1][0]==m[-1][1]:
print(2*u-1)
for i in range(u):
print("%d %d"%(m[i][0],m[i][1]))
for i in range(u-1):
print("%d %d"%(m[u-i-2][1],m[u-i-2][0]))
else:
print(2*u)
for i in range(u):
print("%d %d"%(m[i][0],m[i][1]))
for i in range(u):
print("%d %d"%(m[u-i-1][1],m[u-i-1][0]))
```
No
| 13,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
#### IMPORTANT LIBRARY ####
############################
### DO NOT USE import random --> 250ms to load the library
############################
### In case of extra libraries: https://github.com/cheran-senthil/PyRival
######################
####### IMPORT #######
######################
from functools import cmp_to_key
from collections import deque, Counter
from heapq import heappush, heappop
from math import log, ceil
######################
#### STANDARD I/O ####
######################
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def print(*args, **kwargs):
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
def inp():
return sys.stdin.readline().rstrip("\r\n") # for fast input
def ii():
return int(inp())
def si():
return str(inp())
def li(lag = 0):
l = list(map(int, inp().split()))
if lag != 0:
for i in range(len(l)):
l[i] += lag
return l
def mi(lag = 0):
matrix = list()
for i in range(n):
matrix.append(li(lag))
return matrix
def lsi(): #string list
return list(map(str, inp().split()))
def print_list(lista, space = " "):
print(space.join(map(str, lista)))
######################
### BISECT METHODS ###
######################
def bisect_left(a, x):
"""i tale che a[i] >= x e a[i-1] < x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] < x:
left = mid+1
else:
right = mid
return left
def bisect_right(a, x):
"""i tale che a[i] > x e a[i-1] <= x"""
left = 0
right = len(a)
while left < right:
mid = (left+right)//2
if a[mid] > x:
right = mid
else:
left = mid+1
return left
def bisect_elements(a, x):
"""elementi pari a x nell'Γ‘rray sortato"""
return bisect_right(a, x) - bisect_left(a, x)
######################
### MOD OPERATION ####
######################
MOD = 10**9 + 7
maxN = 5
FACT = [0] * maxN
INV_FACT = [0] * maxN
def add(x, y):
return (x+y) % MOD
def multiply(x, y):
return (x*y) % MOD
def power(x, y):
if y == 0:
return 1
elif y % 2:
return multiply(x, power(x, y-1))
else:
a = power(x, y//2)
return multiply(a, a)
def inverse(x):
return power(x, MOD-2)
def divide(x, y):
return multiply(x, inverse(y))
def allFactorials():
FACT[0] = 1
for i in range(1, maxN):
FACT[i] = multiply(i, FACT[i-1])
def inverseFactorials():
n = len(INV_FACT)
INV_FACT[n-1] = inverse(FACT[n-1])
for i in range(n-2, -1, -1):
INV_FACT[i] = multiply(INV_FACT[i+1], i+1)
def coeffBinom(n, k):
if n < k:
return 0
return multiply(FACT[n], multiply(INV_FACT[k], INV_FACT[n-k]))
######################
#### GRAPH ALGOS #####
######################
# ZERO BASED GRAPH
def create_graph(n, m, undirected = 1, unweighted = 1):
graph = [[] for i in range(n)]
if unweighted:
for i in range(m):
[x, y] = li(lag = -1)
graph[x].append(y)
if undirected:
graph[y].append(x)
else:
for i in range(m):
[x, y, w] = li(lag = -1)
w += 1
graph[x].append([y,w])
if undirected:
graph[y].append([x,w])
return graph
def create_tree(n, unweighted = 1):
children = [[] for i in range(n)]
if unweighted:
for i in range(n-1):
[x, y] = li(lag = -1)
children[x].append(y)
children[y].append(x)
else:
for i in range(n-1):
[x, y, w] = li(lag = -1)
w += 1
children[x].append([y, w])
children[y].append([x, w])
return children
def dist(tree, n, A, B = -1):
s = [[A, 0]]
massimo, massimo_nodo = 0, 0
distanza = -1
v = [-1] * n
while s:
el, dis = s.pop()
if dis > massimo:
massimo = dis
massimo_nodo = el
if el == B:
distanza = dis
for child in tree[el]:
if v[child] == -1:
v[child] = 1
s.append([child, dis+1])
return massimo, massimo_nodo, distanza
def diameter(tree):
_, foglia, _ = dist(tree, n, 0)
diam, _, _ = dist(tree, n, foglia)
return diam
def dfs(graph, n, A):
v = [-1] * n
s = [[A, 0]]
v[A] = 0
while s:
el, dis = s.pop()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
def bfs(graph, n, A):
v = [-1] * n
s = deque()
s.append([A, 0])
v[A] = 0
while s:
el, dis = s.popleft()
for child in graph[el]:
if v[child] == -1:
v[child] = dis + 1
s.append([child, dis + 1])
return v #visited: -1 if not visited, otherwise v[B] is the distance in terms of edges
#FROM A GIVEN ROOT, RECOVER THE STRUCTURE
def parents_children_root_unrooted_tree(tree, n, root = 0):
q = deque()
visited = [0] * n
parent = [-1] * n
children = [[] for i in range(n)]
q.append(root)
while q:
all_done = 1
visited[q[0]] = 1
for child in tree[q[0]]:
if not visited[child]:
all_done = 0
q.appendleft(child)
if all_done:
for child in tree[q[0]]:
if parent[child] == -1:
parent[q[0]] = child
children[child].append(q[0])
q.popleft()
return parent, children
# CALCULATING LONGEST PATH FOR ALL THE NODES
def all_longest_path_passing_from_node(parent, children, n):
q = deque()
visited = [len(children[i]) for i in range(n)]
downwards = [[0,0] for i in range(n)]
upward = [1] * n
longest_path = [1] * n
for i in range(n):
if not visited[i]:
q.append(i)
downwards[i] = [1,0]
while q:
node = q.popleft()
if parent[node] != -1:
visited[parent[node]] -= 1
if not visited[parent[node]]:
q.append(parent[node])
else:
root = node
for child in children[node]:
downwards[node] = sorted([downwards[node][0], downwards[node][1], downwards[child][0] + 1], reverse = True)[0:2]
s = [node]
while s:
node = s.pop()
if parent[node] != -1:
if downwards[parent[node]][0] == downwards[node][0] + 1:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][1])
else:
upward[node] = 1 + max(upward[parent[node]], downwards[parent[node]][0])
longest_path[node] = downwards[node][0] + downwards[node][1] + upward[node] - min([downwards[node][0], downwards[node][1], upward[node]]) - 1
for child in children[node]:
s.append(child)
return longest_path
### TBD SUCCESSOR GRAPH 7.5
### TBD TREE QUERIES 10.2 da 2 a 4
### TBD ADVANCED TREE 10.3
### TBD GRAPHS AND MATRICES 11.3.3 e 11.4.3 e 11.5.3 (ON GAMES)
######################
## END OF LIBRARIES ##
######################
n = ii()
a = li()
seen = set()
start = 0
end = 0
res = list()
while end < n:
if a[end] in seen:
res.append([start+1,end+1])
start = end+1
seen = set()
else:
seen.add(a[end])
end += 1
if len(res) == 0:
print(-1)
else:
if start < n:
x,y = res.pop()
res.append([x,n])
print(len(res))
for i in range(len(res)):
print_list(res[i])
```
| 13,722 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
length = int(input())
gems = input().split()
result = []
s = 0
dist = set()
pend_e = 0
pend_s = 0
for i in range(0, length):
cur = gems[i]
if cur not in dist:
dist.add(cur)
else:
if pend_e != 0:
result.append([pend_s, pend_e])
pend_e = i + 1
pend_s = s + 1
s = i + 1
dist.clear()
if s != 0 and pend_e != length + 1:
result.append([pend_s, length])
if len(result) == 0:
print(-1)
else:
print(len(result))
for r in result:
print(r[0], r[1])
```
| 13,723 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
n = int(input())
li = list(map(int,input().split()))
s=set()
ans=[]
l=0
r=-1
for i in range(n):
if li[i] in s:
ans.append([l+1,i+1])
s = set()
l = i+1
r=1
else:
s.add(li[i])
if r==-1:
print(-1)
else:
print(len(ans))
ans[len(ans)-1][1]=n
for i in ans:
print(*i)
```
| 13,724 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
n = int(input())
lis=[*map(int,input().split())]
ans=[]
k=0;s = set()
for i in range(n):
if lis[i] in s:
ans.append([k+1,i+1])
k=i+1
s = set()
else:
s.add(lis[i])
c=len(ans)
if c==0:
print('-1')
else:
print(c)
ans[-1][1]=n
for i in ans:
print(*i)
```
| 13,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
z = []; p = set()
k1 = 1
for i in range(n):
if a[i] in p:
z.append((k1, i+1))
k1 = i+2
p = set()
else:
p.add(a[i])
if len(z) > 0:
z[len(z)-1] = (z[len(z)-1][0], n)
print(len(z))
for k in z:
print(k[0], k[1])
else:
print(-1)
```
| 13,726 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
def main():
n, res = int(input()), []
s, i, fmt = set(), 1, "{:n} {:n}".format
for j, a in enumerate(input().split(), 1):
if a in s:
s = set()
res.append(fmt(i, j))
i = j + 1
else:
s.add(a)
if res:
print(len(res))
res[-1] = res[-1].split()[0] + ' ' + str(n)
print('\n'.join(res))
else:
print(-1)
if __name__ == '__main__':
main()
```
| 13,727 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
n = int(input())
data = list(map(int, input().split()))
a = 0
answer = []
start = 1
finish = 1
help_set = set()
for i in range(n):
if data[i] in help_set:
answer.append([start, finish])
help_set = set()
start = finish + 1
finish += 1
else:
finish += 1
help_set.add(data[i])
if len(answer) == 0:
print(-1)
else:
answer[-1][-1] = n
print(len(answer))
for i in range(len(answer)):
print(*answer[i])
```
| 13,728 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Tags: greedy
Correct Solution:
```
n = int(input())
index = 1
memory = set()
counter = 0
segments = [[0, 0]]
for number in input().split():
if number not in memory:
memory.add(number)
else:
counter += 1
segments.append([segments[-1][1] + 1, index])
memory = set()
index += 1
segments[-1][1] = n
if counter != 0:
print(counter)
segments.remove([0, 0])
print('\n'.join('{0} {1}'.format(p, q) for (p, q) in segments))
else:
print(-1)
```
| 13,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split(' ')))
ans = []
s = 0
mark = set([a[0]])
for i in range(1, n):
if a[i] in mark:
mark = set()
ans.append([s+1, i+1])
s = i+1
else:
mark.add(a[i])
if len(ans) == 0:
print(-1)
else:
ans[-1][1] = n
print(len(ans))
for line in ans:
print(line[0], line[1])
```
Yes
| 13,730 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n = int(input())
s = input().split()
initial_pos = 0
ans = 0
ans_list = []
l = set()
for i in range(n):
if s[i] in l:
ans += 1
ans_list.append([initial_pos+1, i+1])
initial_pos = i+1
l = set()
else:
l.add(s[i])
if ans == 0:
print(-1)
else:
if not ans_list[-1][1] == n:
ans_list[-1][1] = n
print(ans)
for i in ans_list:
print(' '.join(str(e) for e in i))
```
Yes
| 13,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright Β© 2016 missingdays <missingdays@missingdays>
#
# Distributed under terms of the MIT license.
"""
"""
def good(nums):
for num in nums:
if nums[num] > 1:
return True
return False
n = int(input())
a = [int(i) for i in input().split()]
s = []
l, r = 0, 0
nums = {}
for i in range(n):
num = a[i]
if num in nums:
break
else:
nums[num] = True
else:
print(-1)
exit()
nums = {}
while r < n:
while r < n:
num = a[r]
if num in nums:
r += 1
break
else:
nums[num] = True
r += 1
r -= 1
s.append([l, r])
r += 1
l = r
nums = {}
length = len(s)
last = s[length-1]
for i in range(last[0], last[1]+1):
num = a[i]
if num in nums:
print(length)
break
else:
nums[num] = True
else:
s.pop()
s[length-2][1] = n-1
print(length-1)
for st in s:
for c in st:
print(c+1, end=" ")
print()
```
Yes
| 13,732 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n = int(input())
li = list(map(int,input().split()))
s=set()
otv=[]
l=0
r=-1
for i in range(n):
if li[i] in s:
otv.append([l+1,i+1])
s = set()
l = i+1
r=1
else:
s.add(li[i])
if r==-1:
print(-1)
else:
print(len(otv))
otv[len(otv)-1][1]=n
for i in otv:
print(*i)
# Made By Mostafa_Khaled
```
Yes
| 13,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n = int(input())
a = [k for k in (input()).split(' ')]
answer = -1
l = []
dict = {}
i = 0
for j in range(len(a)):
if dict.get(a[j]):
dict = {}
answer+=1
l.append(i)
l.append(j)
i = j+1
else:
dict.update({a[j] : 1})
if answer == -1:
print(answer)
else:
print(int(answer+1))
for p in l:
print(str(p+1)+' ')
```
No
| 13,734 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
s=set()
ans=[]
for i in range(n):
if l[i] in s:
if ans:
ans.append((ans[-1][1]+1,i+1))
else:
ans=[(1,i+1)]
s=set()
else:
s.add(l[i])
if ans:
print(len(ans))
for i in ans:
print(i[0],i[1])
else:
print(-1)
```
No
| 13,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
n=int(input())
ar=list(map(int,input().split()))
s=set()
ans=[]
p=1
for i in range(len(ar)):
if ar[i] not in s:
s.add(ar[i])
else:
ans.append([p,i+1])
p=i+2
s.clear()
if len(ans)!=0 and len(s):
ans.append([p,len(ar)])
if len(ans):
print(len(ans))
for i in ans:
print(i[0],i[1])
else:
print(-1)
```
No
| 13,736 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n pearls in a row. Let's enumerate them with integers from 1 to n from the left to the right. The pearl number i has the type ai.
Let's call a sequence of consecutive pearls a segment. Let's call a segment good if it contains two pearls of the same type.
Split the row of the pearls to the maximal number of good segments. Note that each pearl should appear in exactly one segment of the partition.
As input/output can reach huge size it is recommended to use fast input/output methods: for example, prefer to use scanf/printf instead of cin/cout in C++, prefer to use BufferedReader/PrintWriter instead of Scanner/System.out in Java.
Input
The first line contains integer n (1 β€ n β€ 3Β·105) β the number of pearls in a row.
The second line contains n integers ai (1 β€ ai β€ 109) β the type of the i-th pearl.
Output
On the first line print integer k β the maximal number of segments in a partition of the row.
Each of the next k lines should contain two integers lj, rj (1 β€ lj β€ rj β€ n) β the number of the leftmost and the rightmost pearls in the j-th segment.
Note you should print the correct partition of the row of the pearls, so each pearl should be in exactly one segment and all segments should contain two pearls of the same type.
If there are several optimal solutions print any of them. You can print the segments in any order.
If there are no correct partitions of the row print the number "-1".
Examples
Input
5
1 2 3 4 1
Output
1
1 5
Input
5
1 2 3 4 5
Output
-1
Input
7
1 2 1 3 1 2 1
Output
2
1 3
4 7
Submitted Solution:
```
#!/bin/python3
import sys
n = int(input())
a = list(map(int, input().split()))
ans = [];
sa = sorted(a);
cmpr = {};
for i in range(0, len(a)):
cmpr[a[i]] = i;
cid = [0 for i in range(0,n)];
id = 1;
pi = 0
for i in range(0,n):
if cid[cmpr[a[i]]] == id:
ans.append(i + 1)
id+=1
continue;
cid[cmpr[a[i]]] = id
if len(ans) == 0:
print(-1)
else:
print(len(ans))
ans = [0] + ans
for i in range(0, len(ans) - 1):
print(ans[i] + 1 , ans[i + 1] )
```
No
| 13,737 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
def rotate_r(ar, row, n):
ar[row] = ar[row][-n:] + ar[row][:-n]
return ar
def rotate_c(ar, m, col):
#c = ar[col][0]
c = ar[m - 1][col]
for i in range(m - 1, 0, -1):
#for i in range(m - 1):
ar[i][col] = ar[i - 1][col]
#ar[col][m - 1] = c
ar[0][col] = c
return ar
def print_matr(ar, n):
for i in range(n):
print(*ar[i])
ar2 = []
n, m, q = map(int, input().split())
#for i in range(n):
# ar = list(map(int, input().split()))
# ar2.append(ar)
query = [0 for i in range(q)]
rows = [0 for i in range(q)]
cols = [0 for i in range(q)]
nums = [0 for i in range(q)]
for i in range(q):
ar = list(map(int, input().split()))
query[i] = ar[0]
if ar[0] == 3:
rows[i] = ar[1] - 1
cols[i] = ar[2] - 1
nums[i] = ar[3]
elif ar[0] == 1:
rows[i] = ar[1] - 1
else:
cols[i] = ar[1] - 1
#print(query)
ans = [[0] * m for i in range(n)]
for i in range(q - 1, -1, -1):
if query[i] == 3:
ans[rows[i]][cols[i]] = nums[i]
#print('\n')
#print_matr(ans, n)
#print("l", rows[i] + 1, cols[i] + 1)
#print(i, nums[i])
elif query[i] == 1:
ans = rotate_r(ans, rows[i], 1)
#print('\n')
#print_matr(ans, n)
else:
ans = rotate_c(ans, n, cols[i])
#print('\n')
#print_matr(ans, n)
#row, n = map(int, input().split())
#print(rotate_r(ar2, 0, n))
print_matr(ans, n)
#ans = rotate_c(ans, n, 0)
#print_matr(ans, n)
```
| 13,738 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
import itertools
import bisect
import math
from collections import *
import os
import sys
from io import BytesIO, IOBase
ii = lambda: int(input())
lmii = lambda: list(map(int, input().split()))
li = lambda: list(input())
mii = lambda: map(int, input().split())
msi = lambda: map(str, input().split())
def main():
n,m,q=mii()
qq=[]
for test in range(q):
pp=lmii()
qq.append(pp)
qq.reverse()
mat=[]
for i in range(n):
mat.append([0]*m)
for i in range(q):
lst = qq[i]
if lst[0] == 3:
mat[lst[1]-1][lst[2]-1] = lst[3]
elif lst[0] == 2:
d = deque([])
for k in range(n):
d.append(mat[k][lst[1]-1])
d.appendleft(d.pop())
for k in range(n):
mat[k][lst[1]-1]=d[k]
else:
d = deque([])
for k in range(m):
d.append(mat[lst[1]-1][k])
d.appendleft(d.pop())
for k in range(m):
mat[lst[1]-1][k] = d[k]
for i in range(n):
print(*mat[i])
pass
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 13,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
a, b, c = map(int, input().split())
arr = []
mat = [[0 for j in range(b)] for i in range(a)]
for i in range(c):
arr.append(input())
arr = arr[::-1]
for command in arr:
arra = [int(i) for i in command.split()]
if arra[0] == 1:
swp = mat[arra[1] - 1][b - 1]
for i in range(b):
mat[arra[1] - 1][i], swp = swp, mat[arra[1] - 1][i]
elif arra[0] == 2:
swp = mat[a - 1][arra[1] - 1]
for i in range(a):
mat[i][arra[1] - 1], swp = swp, mat[i][arra[1] - 1]
else:
mat[arra[1] - 1][arra[2] - 1] = arra[3]
for i in mat:
for j in i:
print(j, end=" ")
print()
```
| 13,740 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
f = lambda: map(int, input().split())
n, m, q = f()
p = [[0] * m for j in range(n)]
for t in [list(f()) for k in range(q)][::-1]:
j = t[1] - 1
if t[0] == 1: p[j].insert(0, p[j].pop())
elif t[0] == 2:
s = p[-1][j]
for i in range(n - 1, 0, -1): p[i][j] = p[i - 1][j]
p[0][j] = s
else: p[j][t[2] - 1] = t[3]
for d in p: print(*d)
```
| 13,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
m,n,q = map(int,input().split())
inps = [map(lambda x: int(x)-1,input().split()) for _ in range(q)]
matrix = [[-1]*n for _ in range(m)]
for x in reversed(inps):
t,c,*cc = x
if t == 0:
matrix[c] = [matrix[c][-1]] + matrix[c][:-1]
elif t == 1:
new = [matrix[i][c] for i in range(m)]
for i,x in enumerate([new[-1]] + new[:-1]):
matrix[i][c] = x
elif t == 2:
matrix[c][cc[0]] = cc[1]
for x in matrix:
print(' '.join(map(lambda v: str(v+1), x)))
```
| 13,742 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
inf= list(map(int, input().split()))
n=inf[0]
m=inf[1]
q=inf[2]
quer=[0]*q
mat=[[0 for i in range(m)] for j in range(n)]
for i in range(0, q):
quer[i] =list(map(int, input().split()))
for i in range(q-1, -1, -1):
curr=quer[i]
if curr[0] == 1:
x = curr[1]-1
a = mat[x][m-1]
for j in range(m-1, 0, -1):
mat[x][j] = mat[x][j-1]
mat[x][0] = a
elif curr[0] == 2:
x = curr[1]-1
a = mat[n-1][x]
for j in range(n-1, 0, -1):
mat[j][x] = mat[j-1][x]
mat[0][x] = a
elif curr[0] == 3:
mat[curr[1]-1][curr[2]-1] =curr[3]
for i in range(n):
print(*mat[i])
```
| 13,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
f = lambda: map(int, input().split())
n, m, q = f()
p = [[0] * m for j in range(n)]
for t in [list(f()) for k in range(q)][::-1]:
j = t[1] - 1
if t[0] == 1: p[j].insert(0, p[j].pop())
elif t[0] == 2:
s = p[-1][j]
for i in range(n - 1, 0, -1): p[i][j] = p[i - 1][j]
p[0][j] = s
else: p[j][t[2] - 1] = t[3]
for d in p: print(*d)
# Made By Mostafa_Khaled
```
| 13,744 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Tags: implementation
Correct Solution:
```
n,m,q=(int(z) for z in input().split())
s=[]
res=[]
for i in range(n):
res.append([0]*m)
for i in range(q):
s.append([int(z) for z in input().split()])
while len(s)>0:
if s[-1][0]==3:
res[s[-1][1]-1][s[-1][2]-1]=s[-1][3]
elif s[-1][0]==2:
r=res[-1][s[-1][1]-1]
for i in range(n-1,0,-1):
res[i][s[-1][1]-1]=res[i-1][s[-1][1]-1]
res[0][s[-1][1]-1]=r
else:
r=res[s[-1][1]-1][-1]
for i in range(m-1,0,-1):
res[s[-1][1]-1][i]=res[s[-1][1]-1][i-1]
res[s[-1][1]-1][0]=r
s.pop()
for i in range(n):
print(' '.join(map(str,res[i])))
```
| 13,745 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
def main():
n, m, q = map(int, input().split())
nm = ["0"] * (m * n)
qq = [input() for _ in range(q)]
for s in reversed(qq):
k, *l = s.split()
if k == "3":
nm[(int(l[0]) - 1) * m + int(l[1]) - 1] = l[2]
elif k == "2":
j = int(l[0]) - 1
x = nm[j - m]
for i in range((n - 1) * m + j, j, -m):
nm[i] = nm[i - m]
nm[j] = x
else:
j = (int(l[0]) - 1) * m
x = nm[j + m - 1]
for i in range(j + m - 1, j, -1):
nm[i] = nm[i - 1]
nm[j] = x
for i in range(0, n * m, m):
print(' '.join(nm[i:i + m]))
if __name__ == "__main__":
main()
```
Yes
| 13,746 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
nmq = input().split(' ')
n, m, q = int(nmq[0]), int(nmq[1]), int(nmq[2])
mt = []
for i in range(0, n):
mt.append([])
for j in range(0, m):
mt[-1].append((i, j))
res = []
for i in range(0, n):
res.append([])
for j in range(0, m):
res[-1].append(0)
for i in range(0, q):
ins = input().split(' ')
if ins[0] == '1':
r = int(ins[1]) - 1
b = mt[r][0]
for j in range(0, m-1):
mt[r][j] = mt[r][j+1]
mt[r][m-1] = b
if ins[0] == '2':
c = int(ins[1]) - 1
b = mt[0][c]
for j in range(0, n-1):
mt[j][c] = mt[j+1][c]
mt[n-1][c] = b
if ins[0] == '3':
r = int(ins[1]) - 1
c = int(ins[2]) - 1
x = int(ins[3])
p = mt[r][c]
res[p[0]][p[1]] = x
for i in range(0, n):
for j in range(0, m-1):
print(res[i][j],' ', end='')
print(res[i][-1])
```
Yes
| 13,747 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
n, m, q = map(int, input().split())
nm = ["0"] * (m * n)
qq = [input() for _ in range(q)]
for s in reversed(qq):
k, *l = s.split()
if k == "3":
nm[(int(l[0]) - 1) * m + int(l[1]) - 1] = l[2]
elif k == "2":
j = int(l[0]) - 1
x = nm[j - m]
for i in range((n - 1) * m + j, j, -m):
nm[i] = nm[i - m]
nm[j] = x
else:
j = (int(l[0]) - 1) * m
x = nm[j + m - 1]
for i in range(j + m - 1, j, -1):
nm[i] = nm[i - 1]
nm[j] = x
for i in range(0, n * m, m):
print(' '.join(nm[i:i + m]))
```
Yes
| 13,748 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
import sys
import time
from pprint import pprint
from sys import stderr
from itertools import combinations
INF = 10 ** 18 + 3
EPS = 1e-10
MAX_CACHE = 10 ** 9
# Decorators
def time_it(function, output=stderr):
def wrapped(*args, **kwargs):
start = time.time()
res = function(*args, **kwargs)
elapsed_time = time.time() - start
print('"%s" took %f ms' % (function.__name__, elapsed_time * 1000),
file=output)
return res
return wrapped
@time_it
def main():
n, m, q = map(int, input().split())
matrix = [[(x, y) for x in range(m)]
for y in range(n)]
init_matrix = [[0] * m for _ in range(n)]
for _ in range(q):
args = list(map(int, input().split()))
t = args[1] - 1
if args[0] == 1:
matrix[t] = matrix[t][1:] + matrix[t][:1]
elif args[0] == 2:
first = matrix[0][t]
for i in range(n - 1):
matrix[i][t] = matrix[i + 1][t]
matrix[n - 1][t] = first
else:
r = args[2] - 1
x = args[3]
init_matrix[matrix[t][r][1]][matrix[t][r][0]] = x
for row in init_matrix:
print(*row)
def set_input(file):
global input
input = lambda: file.readline().strip()
def set_output(file):
global print
local_print = print
def print(*args, **kwargs):
kwargs["file"] = kwargs.get("file", file)
return local_print(*args, **kwargs)
if __name__ == '__main__':
set_input(open("input.txt", "r") if "MINE" in sys.argv else sys.stdin)
set_output(sys.stdout)
main()
```
Yes
| 13,749 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
inf= list(map(int, input().split()))
n=inf[0]
m=inf[1]
q=inf[2]
r=[[i for i in range(m)] for j in range(n)]
c=[[j for i in range(n)] for j in range(m)]
mat=[[0 for j in range(m)] for i in range(n)]
for i in range(q):
inf= list(map(int, input().split()))
if(inf[0]==3):
a=inf[1]-1
b=inf[2]-1
x=inf[3]
mat[c[a][b]][r[a][b]]=x
elif(inf[0]==1):
rn=inf[1]-1
r[rn].append(r[rn][0])
r[rn]=r[rn][1:]
else:
rn=inf[1]-1
c[rn].append(c[rn][0])
c[rn]=c[rn][1:]
for v in range(n):
print(*mat[v])
```
No
| 13,750 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
inf= list(map(int, input().split()))
n=inf[0]
m=inf[1]
q=inf[2]
r=[[i for i in range(m)] for j in range(n)]
c=[[j for i in range(m)] for j in range(n)]
mat=[[0 for j in range(m)] for i in range(n)]
for i in range(q):
inf= list(map(int, input().split()))
if(inf[0]==3):
a=inf[1]-1
b=inf[2]-1
x=inf[3]
mat[c[a][b]][r[a][b]]=x
elif(inf[0]==1):
rn=inf[1]-1
r[rn].append(r[rn][0])
r[rn]=r[rn][1:]
else:
rn=inf[1]-1
temp=c[0][rn]
for j in range(1,n):
c[j-1][rn]=c[j][rn]
c[n-1][rn]=temp
for v in range(n):
print(*mat[v])
```
No
| 13,751 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
inf= list(map(int, input().split()))
n=inf[0]
m=inf[1]
q=inf[2]
r=[[i for i in range(m)] for j in range(n)]
c=[[i for i in range(n)] for j in range(m)]
mat=[[0 for j in range(m)] for i in range(n)]
for i in range(q):
inf= list(map(int, input().split()))
if(inf[0]==3):
a=inf[1]-1
b=inf[2]-1
x=inf[3]
mat[c[b][a]][r[a][b]]=x
elif(inf[0]==1):
rn=inf[1]-1
r[rn].append(r[rn][0])
r[rn]=r[rn][1:]
else:
rn=inf[1]-1
c[rn].append(c[rn][0])
c[rn]=c[rn][1:]
for v in range(n):
print(*mat[v])
```
No
| 13,752 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem likes electronics. He can spend lots of time making different schemas and looking for novelties in the nearest electronics store. The new control element was delivered to the store recently and Artem immediately bought it.
That element can store information about the matrix of integers size n Γ m. There are n + m inputs in that element, i.e. each row and each column can get the signal. When signal comes to the input corresponding to some row, this row cyclically shifts to the left, that is the first element of the row becomes last element, second element becomes first and so on. When signal comes to the input corresponding to some column, that column shifts cyclically to the top, that is first element of the column becomes last element, second element becomes first and so on. Rows are numbered with integers from 1 to n from top to bottom, while columns are numbered with integers from 1 to m from left to right.
Artem wants to carefully study this element before using it. For that purpose he is going to set up an experiment consisting of q turns. On each turn he either sends the signal to some input or checks what number is stored at some position of the matrix.
Artem has completed his experiment and has written down the results, but he has lost the chip! Help Artem find any initial matrix that will match the experiment results. It is guaranteed that experiment data is consistent, which means at least one valid matrix exists.
Input
The first line of the input contains three integers n, m and q (1 β€ n, m β€ 100, 1 β€ q β€ 10 000) β dimensions of the matrix and the number of turns in the experiment, respectively.
Next q lines contain turns descriptions, one per line. Each description starts with an integer ti (1 β€ ti β€ 3) that defines the type of the operation. For the operation of first and second type integer ri (1 β€ ri β€ n) or ci (1 β€ ci β€ m) follows, while for the operations of the third type three integers ri, ci and xi (1 β€ ri β€ n, 1 β€ ci β€ m, - 109 β€ xi β€ 109) are given.
Operation of the first type (ti = 1) means that signal comes to the input corresponding to row ri, that is it will shift cyclically. Operation of the second type (ti = 2) means that column ci will shift cyclically. Finally, operation of the third type means that at this moment of time cell located in the row ri and column ci stores value xi.
Output
Print the description of any valid initial matrix as n lines containing m integers each. All output integers should not exceed 109 by their absolute value.
If there are multiple valid solutions, output any of them.
Examples
Input
2 2 6
2 1
2 2
3 1 1 1
3 2 2 2
3 1 2 8
3 2 1 8
Output
8 2
1 8
Input
3 3 2
1 2
3 2 2 5
Output
0 0 0
0 0 5
0 0 0
Submitted Solution:
```
def main():
n, m, q = map(int, input().split())
nm = ["0"] * (n * m)
a, b, c = m + 1, n - 1, (n - 1) * m
qq = [input() for _ in range(q)]
for s in reversed(qq):
k, *l = s.split()
if k == "3":
row, col, x = l
nm[int(row) * m + int(col) - a] = x
pass
else:
if k == "1":
t = (int(l[0]) - 1) * m
x = nm[t + b]
for i in range(t + b, t, -1):
nm[i] = nm[i - 1]
nm[t] = x
else:
t = int(l[0]) - 1
x = nm[t + c]
for i in range(t + c, t, -m):
nm[i] = nm[i - m]
nm[t] = x
for i in range(0, n * m, m):
print(' '.join(nm[i:i + m]))
if __name__ == "__main__":
main()
```
No
| 13,753 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Tags: data structures
Correct Solution:
```
from bisect import *
d = [{}, {}]
i = [0, 0]
for q in range(int(input())):
a, t, x = map(int, input().split())
for k in [0, 1]:
d[k][x] = d[k].get(x, [])
i[k] = bisect(d[k][x], t)
if a < 3: d[-a][x].insert(i[-a], t)
else: print(i[1] - i[0])
```
| 13,754 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Tags: data structures
Correct Solution:
```
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
new = lambda xx: (xx|xx-1)+1
def buildBIT(bit,n):
for i in range(1,n+1):
x = new(i)
if x <= n:
bit[x] += bit[i]
def pointUpdate(bit,point,n,diff):
while point <= n:
bit[point] += diff
point = new(point)
def calculatePrefix(bit,point):
su = 0
while point:
su += bit[point]
point &= point-1
return su
def rangeQuery(bit,start,stop):
# [start,stop]
return calculatePrefix(bit,stop)-calculatePrefix(bit,start-1)
def compressCoordinate(lst):
return {i:ind+1 for ind,i in enumerate(sorted(set(lst)))}
def main():
from collections import defaultdict
n = int(input())
dct = defaultdict(list)
oper = [list(map(int,input().split())) for _ in range(n)]
for a,t,x in oper:
dct[x].append(t)
new = {i:compressCoordinate(dct[i]) for i in dct}
for i in range(n):
oper[i][1] = new[oper[i][2]][oper[i][1]]
bit = {i:[0]*(len(dct[i])+1) for i in dct}
for a,t,x in oper:
if a == 1:
pointUpdate(bit[x],t,len(bit[x])-1,1)
elif a == 2:
pointUpdate(bit[x],t,len(bit[x])-1,-1)
else:
print(calculatePrefix(bit[x],t))
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 13,755 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Tags: data structures
Correct Solution:
```
from bisect import *
u, v = {}, {}
for q in range(int(input())):
a, t, x = map(int, input().split())
if x not in u: u[x], v[x] = [], []
if a < 3: insort([v, u][-a][x], t)
else: print(bisect(u[x], t) - bisect(v[x], t))
```
| 13,756 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Tags: data structures
Correct Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import random
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default=2**51, func=lambda a, b: a & b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
q=defaultdict(list)
que=[]
ind=defaultdict(list)
ans=defaultdict(int)
for i in range(n):
a,c,b=map(int,input().split())
ind[b].append(c)
q[b].append((a,c))
que.append((a,b,c))
for i in ind:
ind[i].sort()
inde=defaultdict(int)
for j in range(len(ind[i])):
inde[ind[i][j]]=j
e=[0]*len(ind[i])
s=SegmentTree(e)
for j in q[i]:
a,c=j
if a==1:
e[inde[c]]+=1
s.__setitem__(inde[c],e[inde[c]])
elif a==2:
e[inde[c]] -= 1
s.__setitem__(inde[c], e[inde[c]])
else:
ans[c]=s.query(0,inde[c])
for i in range(n):
a,b,c=que[i]
if a==3:
print(ans[c])
```
| 13,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n, c = int(input()), 0
a, t, x = [], [], []
for i in range(n):
ar = [int(i) for i in input().split()]
a.append(ar[0])
t.append(ar[1])
x.append(ar[2])
v = [0] * max(t)
for i in range(n):
if a[i] == 1:
v[t[i]-1] = x[i]
elif a[i] == 2:
for j in range(n):
if v[j] == x[i] and c < 1:
v[j] = 0
c += 1
elif a[i] == 3:
print(v.count(x[i]))
```
No
| 13,758 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
if len(state[j]) == 0:
state[j].append('n')
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
```
No
| 13,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
```
No
| 13,760 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Artem has invented a time machine! He could go anywhere in time, but all his thoughts of course are with computer science. He wants to apply this time machine to a well-known data structure: multiset.
Artem wants to create a basic multiset of integers. He wants these structure to support operations of three types:
1. Add integer to the multiset. Note that the difference between set and multiset is that multiset may store several instances of one integer.
2. Remove integer from the multiset. Only one instance of this integer is removed. Artem doesn't want to handle any exceptions, so he assumes that every time remove operation is called, that integer is presented in the multiset.
3. Count the number of instances of the given integer that are stored in the multiset.
But what about time machine? Artem doesn't simply apply operations to the multiset one by one, he now travels to different moments of time and apply his operation there. Consider the following example.
* First Artem adds integer 5 to the multiset at the 1-st moment of time.
* Then Artem adds integer 3 to the multiset at the moment 5.
* Then Artem asks how many 5 are there in the multiset at moment 6. The answer is 1.
* Then Artem returns back in time and asks how many integers 3 are there in the set at moment 4. Since 3 was added only at moment 5, the number of integers 3 at moment 4 equals to 0.
* Then Artem goes back in time again and removes 5 from the multiset at moment 3.
* Finally Artyom asks at moment 7 how many integers 5 are there in the set. The result is 0, since we have removed 5 at the moment 3.
Note that Artem dislikes exceptions so much that he assures that after each change he makes all delete operations are applied only to element that is present in the multiset. The answer to the query of the third type is computed at the moment Artem makes the corresponding query and are not affected in any way by future changes he makes.
Help Artem implement time travellers multiset.
Input
The first line of the input contains a single integer n (1 β€ n β€ 100 000) β the number of Artem's queries.
Then follow n lines with queries descriptions. Each of them contains three integers ai, ti and xi (1 β€ ai β€ 3, 1 β€ ti, xi β€ 109) β type of the query, moment of time Artem travels to in order to execute this query and the value of the query itself, respectively. It's guaranteed that all moments of time are distinct and that after each operation is applied all operations of the first and second types are consistent.
Output
For each ask operation output the number of instances of integer being queried at the given moment of time.
Examples
Input
6
1 1 5
3 5 5
1 2 5
3 6 5
2 3 5
3 7 5
Output
1
2
1
Input
3
1 1 1
2 2 1
3 3 1
Output
0
Submitted Solution:
```
n = int(input())
command = []
for i in range(n):
command.append(input().split(' '))
temp = []
for i in range(n):
temp.append(int(command[i][1]))
m = max(temp)
state = [None]*m
for i in range(m):
state[i]=['n']
res = []
c = 0
for i in range(n):
a = int(command[i][0])
t = int(command[i][1])
x = int(command[i][2])
if a == 1:
if state[t-1][0] == 'n':
state[t-1][0] = x
else:
state[t-1].append(x)
elif a == 2:
for j in range(t):
if x in state[j]:
state[j].remove(x)
if len(state[j]) == 1:
state[j].append('n')
break
elif a == 3:
for j in range(t):
c += state[j].count(x)
res.append(c)
c=0
for i in range(len(res)):
print(res[i])
```
No
| 13,761 |
Provide a correct Python 3 solution for this coding contest problem.
Zombies seem to have become much more intelligent lately β a few have somehow wandered into the base through the automatic gate. Heidi has had to beef up security, and a new gate has been installed. Unfortunately, now the questions being asked are more complicated, and even humans have trouble answering them. Can you still program the robot army to do this reliably?
The new questions are of the following form: a grayscale photograph has been divided into several horizontal pieces, which have been arbitrarily rearranged. The task is to assemble the original image back from these pieces (somewhat like in a jigsaw puzzle). To further delay the zombies, significant Gaussian-distributed noise has been added to the image.
Input
The input format is the same as in the previous version, except that the first line of every question now contains three space-separated numbers h, w and k (1 β€ h, w β€ 600, 2 β€ k β€ 16) β the height (number of rows) and width (number of columns) of the photograph and the number of pieces, respectively. The number of pieces evenly divides the height, and each piece is of the same height h / k.
Again, there is only one input file to be processed, and the same resources are provided to you as in the previous version (except that now you are given all input images in .bmp format, rather than the first 50).
Output
Your program should print q lines. The i-th line should contain your answer for the i-th question: a space-separated sequence of k numbers Ο1, Ο2, ..., Οk such that:
* Ο is a permutation of {1, 2, ..., k}, that is, each number from 1 to k appears exactly once in Ο,
* for each j = 1, ..., k, Οj is the position (index), in the original image, of the piece which is at position j in the input image. (See the illustration below for clarity.)
<image>
The second image from the test set. If the three pieces in the original image are numbered 1, 2, 3 from top to bottom, then the numbering in the image on the right should be 2, 3, 1. The correct answer for this image is thus 2 3 1.
Again, your answers will be accepted if they conform to this format and if at least 75% of them are correct.
Again, you may process the input locally and submit just your precomputed answers (i.e., a program which just prints your output for the input file all.in).
Note
The link to download all the necessary materials is http://assets.codeforces.com/files/690/medium_contestant_package.zip
"Correct Solution:
```
print("""2 1
2 3 1
4 3 2 1
1 3 4 2 5
1 6 11 3 10 9 15 12 7 13 2 5 4 14 8
5 1 3 11 10 7 6 9 13 15 12 4 14 2 8
9 7 2 5 1 10 8 3 4 6
2 1 4 3
4 12 8 2 9 14 5 7 1 6 10 13 15 3 11
11 5 6 8 10 12 7 2 1 4 9 3 13 14 15
11 7 8 4 5 15 13 14 3 9 12 2 1 10 6
12 7 11 4 10 2 5 14 13 1 6 3 9 8 15 16
3 2 1
4 2 1 3 5
1 8 11 15 3 2 7 16 13 4 6 10 9 12 5 14
9 8 6 13 11 10 2 7 14 12 5 4 15 3 1
11 8 9 3 1 14 2 12 4 16 10 7 5 13 15 6
15 5 2 14 3 13 1 7 12 8 4 10 6 11 9
9 7 3 14 2 12 13 5 1 15 11 10 8 4 6
9 7 13 10 15 16 5 3 6 1 2 11 8 4 14 12
6 13 2 11 5 10 3 14 9 1 12 8 16 4 15 7
2 7 16 14 13 8 5 10 4 12 11 1 6 9 3 15
3 2 6 14 7 12 10 9 5 4 8 15 11 13 1
3 11 4 5 14 10 16 9 8 6 7 13 12 1 15 2
4 3 11 9 8 16 6 15 2 13 7 14 10 1 12 5
1 12 9 7 6 5 2 13 14 10 15 8 11 4 3
2 1 3
2 1
1 3 2 6 4 8 7 5
14 7 8 6 1 9 13 5 2 4 11 15 16 10 3 12
1 7 4 3 6 5 2 8
13 7 6 14 12 15 3 5 1 9 8 10 4 11 2
11 2 15 5 14 3 9 10 7 1 12 13 8 6 4
4 2 3 1
16 13 11 14 9 2 15 3 1 5 6 7 12 8 4 10
3 1 4 9 16 15 7 10 6 13 5 11 2 14 12 8
14 16 13 4 9 10 12 8 7 11 3 5 15 6 2 1
3 1 6 5 2 4
14 8 2 10 6 16 9 7 15 4 1 3 11 13 5 12
15 8 10 9 11 12 7 13 5 14 1 4 3 2 6
5 7 3 10 6 12 8 4 11 1 2 9
2 1
13 14 8 6 4 7 5 10 3 11 2 9 15 12 1
2 15 11 13 12 5 3 4 9 8 14 6 10 1 7
3 1 4 2
6 2 16 5 7 10 15 1 8 14 13 4 9 11 3 12
3 1 2
16 4 13 11 7 9 5 2 10 3 6 15 12 14 8 1
2 5 1 9 15 7 3 11 13 4 8 12 6 14 10
6 3 12 14 15 13 7 2 5 16 4 11 8 1 10 9
5 7 11 3 10 15 2 9 4 8 14 13 16 12 1 6
16 1 2 3 7 15 6 12 8 11 10 14 13 4 9 5
6 5 2 10 12 8 4 13 9 11 1 15 3 14 7
12 13 9 1 3 11 4 8 15 14 10 7 16 5 6 2
4 2 3 1
10 3 15 2 12 7 11 4 16 6 13 9 14 8 5 1
6 3 1 5 2 4
14 11 7 5 6 15 3 4 2 10 1 13 8 9 12
10 8 2 11 15 5 1 13 16 12 14 9 6 4 3 7
8 2 15 11 9 12 16 6 13 7 4 5 14 1 10 3
3 9 10 13 6 16 5 4 8 7 12 11 1 15 14 2
1 4 6 12 5 15 2 3 9 13 8 7 14 11 10
6 7 3 2 5 8 1 9 10 4
11 10 12 15 3 13 1 16 2 8 4 5 6 14 7 9
8 1 13 15 7 10 5 9 3 2 6 4 12 11 14
12 6 11 14 3 5 1 8 10 16 15 7 2 9 4 13
3 2 1
4 7 8 2 1 6 5 3
2 1
1 10 14 13 5 11 8 12 16 9 15 6 4 7 2 3
15 9 2 8 1 4 14 13 5 3 12 6 7 11 10
4 1 5 2 3
1 8 3 11 9 5 6 7 4 2 10 12
9 3 14 10 13 6 1 16 2 7 4 11 15 8 12 5
11 10 14 3 9 13 15 16 6 1 2 8 12 7 5 4
11 16 14 3 6 12 4 1 2 8 7 13 10 9 15 5
15 14 4 6 9 5 3 2 13 12 10 11 7 1 8
13 10 15 11 4 16 2 3 14 9 5 6 8 7 12 1
4 3 5 14 6 8 16 10 9 12 2 11 13 15 7 1
1 4 5 10 9 6 8 3 2 7
7 6 15 5 12 13 2 4 3 14 11 1 10 8 9
2 14 9 3 8 7 6 15 10 11 16 5 12 13 1 4
2 5 9 1 11 4 16 6 8 7 12 3 13 10 15 14
3 5 7 14 1 9 6 4 10 8 11 15 2 16 12 13
15 14 10 13 1 5 2 12 4 11 8 9 6 7 3 16
6 1 4 16 2 9 8 5 12 11 10 13 3 7 14 15
16 14 9 8 4 1 7 2 12 10 3 5 11 6 15 13
6 1 5 2 4 3
3 10 4 5 9 6 1 2 7 8
8 1 15 10 12 5 14 11 4 2 3 13 7 9 6
5 13 12 7 9 1 10 4 15 8 3 2 14 6 11
2 3 6 1 4 5
1 15 13 6 7 11 12 2 14 4 8 9 3 10 5
14 7 8 6 12 13 16 15 3 10 11 9 1 4 5 2
7 2 4 13 9 1 15 8 12 11 6 3 5 14 10
3 4 5 6 15 8 9 10 14 12 11 13 7 2 1
4 11 5 12 8 14 10 7 3 9 16 13 15 1 6 2
2 6 3 1 4 5
6 5 7 9 2 8 3 1 4 10
14 7 15 11 1 4 3 13 5 10 6 9 8 2 12
15 14 5 3 7 4 1 9 11 6 10 2 12 13 8
16 14 3 7 13 2 6 1 10 12 9 4 5 8 11 15
3 8 5 10 12 11 4 6 7 9 2 1
11 3 5 4 12 8 1 2 6 7 9 10
3 11 6 16 13 15 5 2 12 7 14 8 10 9 4 1
6 5 1 4 3 2
1 4 2 10 12 11 9 5 6 13 3 14 15 8 7
7 13 10 5 2 12 6 3 8 4 15 11 1 9 14
12 5 7 8 1 9 10 15 6 4 14 13 3 2 11
2 5 3 9 13 4 7 12 6 14 10 11 15 1 8
5 4 2 6 1 3
4 8 9 1 5 13 11 7 3 12 2 6 14 15 10
2 1
11 5 7 9 15 2 8 14 3 13 10 12 1 6 4
5 14 15 4 13 6 8 10 7 12 2 11 16 3 9 1
12 8 7 2 3 9 15 5 11 6 4 14 13 1 10
14 7 11 13 2 3 12 1 10 9 5 8 4 15 6
6 4 3 5 1 2 7 8
1 9 13 4 6 14 11 7 2 15 12 8 5 10 3 16
3 5 1 8 2 9 7 12 4 11 10 6
2 5 4 9 11 12 13 6 3 1 15 10 8 7 14
13 6 8 11 12 15 1 2 10 9 7 14 3 5 4
2 11 15 12 5 8 9 1 14 10 4 3 6 7 13
5 8 16 3 10 6 14 7 1 15 12 9 13 2 11 4
10 12 1 16 11 4 2 15 6 7 13 14 5 3 8 9
1 2 5 3 4
6 5 1 4 2 3
8 4 7 5 6 1 2 3
4 2 3 1
4 5 6 8 3 1 2 9 10 7
1 8 10 12 14 13 16 11 9 4 3 2 7 5 15 6
2 1
14 8 1 15 11 2 9 7 3 12 10 4 5 13 6
15 13 8 2 7 11 6 5 14 9 10 12 3 4 1
2 1
8 4 5 10 6 1 14 13 12 9 2 3 11 15 7
10 3 6 8 5 11 14 16 7 1 9 2 13 4 15 12
7 5 6 2 4 1 8 3
10 2 7 9 11 6 1 8 3 5 12 4
4 2 3 1
3 13 9 7 11 15 14 10 5 2 16 12 4 8 1 6
1 6 10 4 15 5 3 13 7 12 9 2 8 11 14
2 7 14 16 13 8 3 15 12 11 1 4 6 5 10 9
4 3 1 2 5
3 4 11 7 15 1 13 10 9 14 16 12 5 8 2 6
4 9 14 7 12 3 10 5 13 1 2 11 8 6 15
10 9 16 13 7 3 12 4 15 8 5 1 11 2 6 14
2 1
14 4 1 2 13 6 3 5 12 10 7 9 15 8 11
3 4 1 6 2 5
5 10 4 6 2 8 11 9 1 7 3 13 15 14 12
2 4 1 3
16 14 12 11 7 3 2 6 1 9 4 10 15 13 5 8
14 16 1 4 15 12 2 11 5 8 10 9 6 13 7 3
4 2 1 3
8 11 3 4 1 10 14 6 13 7 15 2 12 5 9
""")
```
| 13,762 |
Provide tags and a correct Python 3 solution for this coding contest problem.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Tags: binary search, constructive algorithms, graphs, shortest paths
Correct Solution:
```
from collections import defaultdict
MAX = 10 ** 14
def Dijkstra(graph, s, n):
visited = [False] * n
d = [MAX] * n
parents = {}
d[s] = 0
for i in range(n):
_, v = min((d[j], j) for j in range(n) if not visited[j])
visited[v] = True
for u, cost in graph[v]:
if d[u] > d[v] + cost:
d[u] = d[v] + cost
parents[u] = v
return parents, d
def PrintSol(graph, variableEdgesInPath, n, zeros, edgesWithZero, leave):
for v in range(n):
for u, cost in graph[v]:
if u < v:
if (v, u) in variableEdgesInPath:
print(v, u, variableEdgesInPath[(v, u)])
elif zeros and (v, u) in edgesWithZero and (v, u) not in leave:
print(v, u, MAX)
else:
print(v, u, cost)
graphWithZero = defaultdict(list)
graphWithMax = defaultdict(list)
n, m, L, s, t = map(int, input().split(' '))
edgesWithZero = set()
for _ in range(m):
u, v, l = map(int, input().split(' '))
if l == 0:
graphWithZero[u].append((v, 1))
graphWithZero[v].append((u, 1))
graphWithMax[u].append((v, MAX))
graphWithMax[v].append((u, MAX))
edgesWithZero |= {(u, v), (v, u)}
else:
graphWithZero[u].append((v, l))
graphWithZero[v].append((u, l))
graphWithMax[u].append((v, l))
graphWithMax[v].append((u, l))
a2, d2 = Dijkstra(graphWithMax, s, n)
a1, d1 = Dijkstra(graphWithZero, s, n)
if d2[t] < L:
print('NO')
elif d2[t] == L:
print('YES')
PrintSol(graphWithMax, dict(), n, False, edgesWithZero, set())
elif d1[t] <= L:
print('YES')
v = t
leave = set()
variableEdgesInPath = dict()
total = 0
while v != s:
leave |= {(v, a1[v]), (a1[v], v)}
if (v, a1[v]) in edgesWithZero:
cur = max(L - total - d2[a1[v]], 1)
variableEdgesInPath[(max(v, a1[v]), min(v, a1[v]))] = cur
total += cur
else:
total += d1[v] - d1[a1[v]]
v = a1[v]
PrintSol(graphWithZero, variableEdgesInPath, n, True, edgesWithZero, leave)
else:
print('NO')
```
| 13,763 |
Provide tags and a correct Python 3 solution for this coding contest problem.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Tags: binary search, constructive algorithms, graphs, shortest paths
Correct Solution:
```
import heapq
from collections import defaultdict
class Graph:
def __init__(self, n):
self.nodes = set(range(n))
self.edges = defaultdict(list)
self.distances = {}
def add_edge(self, from_node, to_node, distance):
self.edges[from_node].append(to_node)
self.edges[to_node].append(from_node)
self.distances[from_node, to_node] = distance
self.distances[to_node, from_node] = distance
def dijkstra(graph, initial):
visited = {initial: 0}
path = {}
h = [(0, initial)]
nodes = set(graph.nodes)
while nodes and h:
current_weight, min_node = heapq.heappop(h)
try:
while min_node not in nodes:
current_weight, min_node = heapq.heappop(h)
except IndexError:
break
nodes.remove(min_node)
for v in graph.edges[min_node]:
weight = current_weight + graph.distances[min_node, v]
if v not in visited or weight < visited[v]:
visited[v] = weight
heapq.heappush(h, (weight, v))
path[v] = min_node
return visited, path
n, m, L, s, t = map(int, input().split())
min_g = Graph(n)
max_g = Graph(n)
g = Graph(n)
for _ in range(m):
u, v, w = map(int, input().split())
if w == 0:
min_w = 1
max_w = int(1e18)
else:
min_w = max_w = w
min_g.add_edge(u, v, min_w)
max_g.add_edge(u, v, max_w)
g.add_edge(u, v, w)
min_ls, min_p = dijkstra(min_g, s)
try:
min_l = min_ls[t]
max_l = dijkstra(max_g, s)[0][t]
except KeyError:
min_l = 0
max_l = -1
if min_l <= L <= max_l:
while min_l < L:
a = s
b = z = t
while z != s:
if g.distances[z, min_p[z]] == 0:
max_g.distances[z, min_p[z]] = min_g.distances[z, min_p[z]]
max_g.distances[min_p[z], z] = min_g.distances[z, min_p[z]]
a = z
b = min_p[z]
z = min_p[z]
new_dist = min_g.distances[a, b] + L - min_l
max_g.distances[a, b] = new_dist
max_g.distances[b, a] = new_dist
min_g = max_g
min_ls, min_p = dijkstra(min_g, s)
min_l = min_ls[t]
if min_l == L:
print('YES')
print('\n'.join('%s %s %s' % (u, v, w) for (u, v), w in min_g.distances.items() if u < v))
else:
print('NO')
else:
print('NO')
```
| 13,764 |
Provide tags and a correct Python 3 solution for this coding contest problem.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Tags: binary search, constructive algorithms, graphs, shortest paths
Correct Solution:
```
from collections import defaultdict
MAX_WEIGHT = 10 ** 14
def compute_path(graph, s, n):
visited = [False] * n
distances = [MAX_WEIGHT] * n
ancestors = {}
distances[s] = 0
for i in range(n):
_, v = min((distances[j], j) for j in range(n) if not visited[j])
visited[v] = True
for to, length in graph[v]:
if distances[to] > distances[v] + length:
distances[to] = distances[v] + length
ancestors[to] = v
return ancestors, distances
def output(graph, n_edges, extra, n, zeros, erased, leave):
for i in range(n):
for to, length in graph[i]:
if to < i:
if (i, to) in n_edges:
print(i, to, n_edges[(i, to)])
elif zeros and (i, to) in erased and (i, to) not in leave:
print(i, to, MAX_WEIGHT)
else:
print(i, to, length)
graph_with_0 = defaultdict(list)
graph_with_max = defaultdict(list)
n, m, L, s, t = map(int, input().split(' '))
erased = set()
for _ in range(m):
u, v, l = map(int, input().split(' '))
if l == 0:
graph_with_0[u].append((v, 1))
graph_with_0[v].append((u, 1))
graph_with_max[u].append((v, MAX_WEIGHT))
graph_with_max[v].append((u, MAX_WEIGHT))
erased |= {(u, v), (v, u)}
else:
graph_with_0[u].append((v, l))
graph_with_0[v].append((u, l))
graph_with_max[u].append((v, l))
graph_with_max[v].append((u, l))
a1, d1 = compute_path(graph_with_0, s, n)
a2, d2 = compute_path(graph_with_max, s, n)
if d2[t] < L:
print('NO')
elif d2[t] == L:
print('YES')
output(graph_with_max, dict(), 0, n, False, erased, set())
elif d1[t] <= L:
print('YES')
v = t
leave = set()
n_edges = dict()
total = 0
while v != s:
leave |= {(v, a1[v]), (a1[v], v)}
if (v, a1[v]) in erased:
cur = max(L - total - d2[a1[v]], 1)
n_edges[(max(v, a1[v]), min(v, a1[v]))] = cur
total += cur
else:
total += d1[v] - d1[a1[v]]
v = a1[v]
output(graph_with_0, n_edges, L - d1[t], n, True, erased, leave)
else:
print('NO')
```
| 13,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Tags: binary search, constructive algorithms, graphs, shortest paths
Correct Solution:
```
from collections import defaultdict
MAX = 10 ** 14
def Dijkstra(graph, s, n):
visited = [False] * n
d = [MAX] * n
parents = {}
d[s] = 0
for i in range(n):
_, v = min((d[j], j) for j in range(n) if not visited[j])
visited[v] = True
for to, length in graph[v]:
if d[to] > d[v] + length:
d[to] = d[v] + length
parents[to] = v
return parents, d
def PrintSol(graph, n_edges, n, zeros, edgesWithZero, leave):
for i in range(n):
for to, length in graph[i]:
if to < i:
if (i, to) in n_edges:
print(i, to, n_edges[(i, to)])
elif zeros and (i, to) in edgesWithZero and (i, to) not in leave:
print(i, to, MAX)
else:
print(i, to, length)
graphWithZero = defaultdict(list)
graphWithMax = defaultdict(list)
n, m, L, s, t = map(int, input().split(' '))
edgesWithZero = set()
for _ in range(m):
u, v, l = map(int, input().split(' '))
if l == 0:
graphWithZero[u].append((v, 1))
graphWithZero[v].append((u, 1))
graphWithMax[u].append((v, MAX))
graphWithMax[v].append((u, MAX))
edgesWithZero |= {(u, v), (v, u)}
else:
graphWithZero[u].append((v, l))
graphWithZero[v].append((u, l))
graphWithMax[u].append((v, l))
graphWithMax[v].append((u, l))
a2, d2 = Dijkstra(graphWithMax, s, n)
a1, d1 = Dijkstra(graphWithZero, s, n)
if d2[t] < L:
print('NO')
elif d2[t] == L:
print('YES')
PrintSol(graphWithMax, dict(), n, False, edgesWithZero, set())
elif d1[t] <= L:
print('YES')
v = t
leave = set()
n_edges = dict()
total = 0
while v != s:
leave |= {(v, a1[v]), (a1[v], v)}
if (v, a1[v]) in edgesWithZero:
cur = max(L - total - d2[a1[v]], 1)
n_edges[(max(v, a1[v]), min(v, a1[v]))] = cur
total += cur
else:
total += d1[v] - d1[a1[v]]
v = a1[v]
PrintSol(graphWithZero, n_edges, n, True, edgesWithZero, leave)
else:
print('NO')
```
| 13,766 |
Provide tags and a correct Python 3 solution for this coding contest problem.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Tags: binary search, constructive algorithms, graphs, shortest paths
Correct Solution:
```
import heapq
from collections import defaultdict
class Graph:
def __init__(self, n):
self.nodes = set(range(n))
self.edges = defaultdict(list)
self.distances = {}
def add_edge(self, from_node, to_node, distance):
self.edges[from_node].append(to_node)
self.edges[to_node].append(from_node)
self.distances[from_node, to_node] = distance
self.distances[to_node, from_node] = distance
def dijkstra(graph, initial, end):
visited = {initial: 0}
path = {}
h = [(0, initial)]
nodes = set(graph.nodes)
while nodes and h:
current_weight, min_node = heapq.heappop(h)
try:
while min_node not in nodes:
current_weight, min_node = heapq.heappop(h)
except IndexError:
break
if min_node == end:
break
nodes.remove(min_node)
for v in graph.edges[min_node]:
weight = current_weight + graph.distances[min_node, v]
if v not in visited or weight < visited[v]:
visited[v] = weight
heapq.heappush(h, (weight, v))
path[v] = min_node
return visited, path
n, m, L, s, t = map(int, input().split())
min_g = Graph(n)
max_g = Graph(n)
g = Graph(n)
for _ in range(m):
u, v, w = map(int, input().split())
if w == 0:
min_w = 1
max_w = int(1e18)
else:
min_w = max_w = w
min_g.add_edge(u, v, min_w)
max_g.add_edge(u, v, max_w)
g.add_edge(u, v, w)
min_ls, min_p = dijkstra(min_g, s, t)
try:
min_l = min_ls[t]
max_l = dijkstra(max_g, s, t)[0][t]
except KeyError:
min_l = 0
max_l = -1
if min_l <= L <= max_l:
while min_l < L:
a = s
b = z = t
while z != s:
if g.distances[z, min_p[z]] == 0:
max_g.distances[z, min_p[z]] = min_g.distances[z, min_p[z]]
max_g.distances[min_p[z], z] = min_g.distances[z, min_p[z]]
a = z
b = min_p[z]
z = min_p[z]
new_dist = min_g.distances[a, b] + L - min_l
max_g.distances[a, b] = new_dist
max_g.distances[b, a] = new_dist
min_g = max_g
min_ls, min_p = dijkstra(min_g, s, t)
min_l = min_ls[t]
if min_l == L:
print('YES')
print('\n'.join('%s %s %s' % (u, v, w) for (u, v), w in min_g.distances.items() if u < v))
else:
print('NO')
else:
print('NO')
```
| 13,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Submitted Solution:
```
n, m, l, s, t = map(int, input().split())
edges = []
graph = [[] for i in range(n)]
direct = [-1] * n
correct = [-1] * n
corrpath = [[] for i in range(n)]
for i in range(m):
u, v, w = map(int, input().split())
edges.append((u, v, w))
graph[u].append((v, w, i))
graph[v].append((u, w, i))
direct[s] = 0
queue = [s]
while queue:
curr = queue.pop()
for next, w, i in graph[curr]:
if w:
if direct[curr] >= 0 and (direct[next] < 0 or direct[curr] + w < direct[next]):
direct[next] = direct[curr] + w
queue.append(next)
if correct[curr] >= 0 and (correct[next] < 0 or correct[curr] + w < correct[next]):
correct[next] = correct[curr] + w
corrpath[next] = []
corrpath[next].extend(corrpath[curr])
queue.append(next)
else:
if correct[curr] >= 0 and (correct[next] < 0 or correct[curr] + 1 < correct[next]):
correct[next] = correct[curr] + 1
corrpath[next] = [i]
corrpath[next].extend(corrpath[curr])
queue.append(next)
if direct[curr] >= 0 and (correct[next] < 0 or correct[curr] + 1 < direct[next]):
correct[next] = direct[curr] + 1
corrpath[next] = [i]
queue.append(next)
if direct[t] >= 0 and direct[t] < l:
print("NO")
elif direct[t] == l:
print("YES")
for i in range(m):
u, v, w = edges[i]
if not w: w = 1
print(u, end = " ")
print(v, end = " ")
print(w)
elif correct[t] >= 0 and correct[t] <= l:
print("YES")
delta = l - correct[t]
for i in range(m):
u, v, w = edges[i]
if not w: w = 1
if delta and i in corrpath[t]:
w += delta
delta = 0
print(u, end = " ")
print(v, end = " ")
print(w)
else:
print("NO")
```
No
| 13,768 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Submitted Solution:
```
class Node:
length = None
through = None
def __str__(self):
return str(self.value)
def __init__(self, value):
self.value = value
self.connections = {}
nodes = {}
nodesWithoutZeros = {}
inputs = []
# maxW = -1
n, m, l, s, t = list(map(int, input().split()))
areZeros = False
for _ in range(m):
u, v, w = list(map(int, input().split()))
# if w > maxW:
# maxW = w
if not u in nodes.keys():
nodes[u] = Node(u)
if not v in nodes.keys():
nodes[v] = Node(v)
if w != 0:
if not u in nodesWithoutZeros.keys():
nodesWithoutZeros[u] = Node(u)
if not v in nodesWithoutZeros.keys():
nodesWithoutZeros[v] = Node(v)
nodesWithoutZeros[u].connections[v] = w
nodesWithoutZeros[v].connections[u] = w
else:
areZeros = True
inputs.append((u, v))
nodes[u].connections[v] = w
nodes[v].connections[u] = w
sortedNodes = []
def add(arr, no):
if no in arr:
arr.remove(no)
if len(arr) == 0:
arr.append(no)
return
i = len(arr)//2
while True:
if arr[i].length == no.length:
arr.insert(i, no)
elif arr[i].length > no.length:
new = (i + len(arr)) // 2
if new == i:
arr.insert(i+1, no)
return
i = new
else:
new = (len(arr) - i) // 2
if new == i:
arr.insert(i, no)
return
i = new
# minLengths = {}
# toGo = set(s)
done = set()
nodes[s].length = 0
add(sortedNodes, nodes[s])
while len(sortedNodes) > 0:
nod = sortedNodes.pop()
le = nod.length
for k, v in nod.connections.items():
if k in done:
continue
if v == 0:
v = 1
nodee = nodes[k]
if nodee.length == None:
nodee.length = v + le
nodee.through = nod.value
add(sortedNodes, nodee)
continue
if v + le < nodee.length:
nodee.length = le + v
nodee.through = nod.value
add(sortedNodes, nodee)
done.add(nod.value)
sortedNodes = []
done = set()
if s in nodesWithoutZeros.keys():
nodesWithoutZeros[s].length = 0
add(sortedNodes, nodesWithoutZeros[s])
while len(sortedNodes) > 0:
nod = sortedNodes.pop()
le = nod.length
for k, v in nod.connections.items():
if k in done:
continue
if v == 0:
v = 1
nodee = nodesWithoutZeros[k]
if nodee.length == None:
nodee.length = v + le
nodee.through = nod.value
add(sortedNodes, nodee)
continue
if v + le < nodee.length:
nodee.length = le + v
nodee.through = nod.value
add(sortedNodes, nodee)
done.add(nod.value)
if len(nodesWithoutZeros) > 0 and nodesWithoutZeros[t].length != None and nodesWithoutZeros[t].length < l:
print("NO")
elif len(nodesWithoutZeros) > 0 and areZeros == False and nodesWithoutZeros[t].length != None and nodesWithoutZeros[t].length != l:
print("NO")
elif nodes[t].length == None or nodes[t].length > l:
print("NO")
else:
toFill = []
sumL = 0
cur = t
while cur != s:
nod = nodes[cur]
if nod.connections[nod.through] == 0:
# nod.connections[nod.through] = 1
# nodes[nod.through].connections[cur] = 1
toFill.append(nod.value)
else:
sumL += nod.connections[nod.through]
cur = nod.through
sumL = l - sumL
if sumL < len(toFill):
print("NO")
while len(toFill) > 1:
nod = nodes[toFill.pop()]
nod.connections[nod.through] = 1
nodes[nod.through].connections[nod.value] = 1
sumL -= 1
nod = nodes[toFill.pop()]
nod.connections[nod.through] = sumL
nodes[nod.through].connections[nod.value] = sumL
for nod in nodes.values():
if nod.length == 0:
nod.length = l + 1
def getOutStr(inp):
va1 = inp[0]
va2 = inp[1]
node1 = nodes[va1]
return "{} {} {}".format(va1, va2, node1.connections[va2])
print("\n".join(map(getOutStr, inputs)))
```
No
| 13,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Submitted Solution:
```
from collections import defaultdict
MAX_WEIGHT = 10 ** 14
def compute_path(graph, s, n):
visited = [False] * n
distances = [MAX_WEIGHT] * n
ancestors = {}
distances[s] = 0
for i in range(n):
_, v = min((distances[j], j) for j in range(n) if not visited[j])
visited[v] = True
for to, length in graph[v]:
if distances[to] > distances[v] + length:
distances[to] = distances[v] + length
ancestors[to] = v
return ancestors, distances
def output(graph, u, v, extra, n, zeros, erased, leave):
for i in range(n):
for to, length in graph[i]:
if to < i:
if (i, to) == (u, v):
print(i, to, length + extra)
elif zeros and (i, to) in erased and (i, to) not in leave:
print(i, to, MAX_WEIGHT)
else:
print(i, to, length)
graph_with_0 = defaultdict(list)
graph_with_max = defaultdict(list)
n, m, L, s, t = map(int, input().split(' '))
erased = set()
for _ in range(m):
u, v, l = map(int, input().split(' '))
if l == 0:
graph_with_0[u].append((v, 1))
graph_with_0[v].append((u, 1))
graph_with_max[u].append((v, MAX_WEIGHT))
graph_with_max[v].append((u, MAX_WEIGHT))
erased |= {(u, v), (v, u)}
else:
graph_with_0[u].append((v, l))
graph_with_0[v].append((u, l))
graph_with_max[u].append((v, l))
graph_with_max[v].append((u, l))
a1, d1 = compute_path(graph_with_0, s, n)
a2, d2 = compute_path(graph_with_max, s, n)
if d2[t] < L:
print('NO')
elif d2[t] == L:
print('YES')
output(graph_with_max, n+1, n+1, 0, n, False, erased, set())
elif d1[t] <= L:
print('YES')
v = t
leave = set()
while v != s:
leave |= {(v, a1[v]), (a1[v], v)}
v = a1[v]
v = t
while (v, a1[v]) not in erased:
v = a1[v]
output(graph_with_0, max(v, a1[v]), min(v, a1[v]), L - d1[t], n, True, erased, leave)
else:
print('NO')
```
No
| 13,770 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
ZS the Coder has drawn an undirected graph of n vertices numbered from 0 to n - 1 and m edges between them. Each edge of the graph is weighted, each weight is a positive integer.
The next day, ZS the Coder realized that some of the weights were erased! So he wants to reassign positive integer weight to each of the edges which weights were erased, so that the length of the shortest path between vertices s and t in the resulting graph is exactly L. Can you help him?
Input
The first line contains five integers n, m, L, s, t (2 β€ n β€ 1000, 1 β€ m β€ 10 000, 1 β€ L β€ 109, 0 β€ s, t β€ n - 1, s β t) β the number of vertices, number of edges, the desired length of shortest path, starting vertex and ending vertex respectively.
Then, m lines describing the edges of the graph follow. i-th of them contains three integers, ui, vi, wi (0 β€ ui, vi β€ n - 1, ui β vi, 0 β€ wi β€ 109). ui and vi denote the endpoints of the edge and wi denotes its weight. If wi is equal to 0 then the weight of the corresponding edge was erased.
It is guaranteed that there is at most one edge between any pair of vertices.
Output
Print "NO" (without quotes) in the only line if it's not possible to assign the weights in a required way.
Otherwise, print "YES" in the first line. Next m lines should contain the edges of the resulting graph, with weights assigned to edges which weights were erased. i-th of them should contain three integers ui, vi and wi, denoting an edge between vertices ui and vi of weight wi. The edges of the new graph must coincide with the ones in the graph from the input. The weights that were not erased must remain unchanged whereas the new weights can be any positive integer not exceeding 1018.
The order of the edges in the output doesn't matter. The length of the shortest path between s and t must be equal to L.
If there are multiple solutions, print any of them.
Examples
Input
5 5 13 0 4
0 1 5
2 1 2
3 2 3
1 4 0
4 3 4
Output
YES
0 1 5
2 1 2
3 2 3
1 4 8
4 3 4
Input
2 1 123456789 0 1
0 1 0
Output
YES
0 1 123456789
Input
2 1 999999999 1 0
0 1 1000000000
Output
NO
Note
Here's how the graph in the first sample case looks like :
<image>
In the first sample case, there is only one missing edge weight. Placing the weight of 8 gives a shortest path from 0 to 4 of length 13.
In the second sample case, there is only a single edge. Clearly, the only way is to replace the missing weight with 123456789.
In the last sample case, there is no weights to assign but the length of the shortest path doesn't match the required value, so the answer is "NO".
Submitted Solution:
```
from collections import defaultdict
MAX_WEIGHT = 10 ** 14
def compute_path(graph, s, n):
visited = [False] * n
distances = [MAX_WEIGHT] * n
ancestors = {}
distances[s] = 0
for i in range(n):
_, v = min((distances[j], j) for j in range(n) if not visited[j])
visited[v] = True
for to, length in graph[v]:
if distances[to] > distances[v] + length:
distances[to] = distances[v] + length
ancestors[to] = v
return ancestors, distances
def output(graph, u, v, extra, n, zeros, erased, leave):
for i in range(n):
for to, length in graph[i]:
if to < i:
if (i, to) == (u, v):
print(i, to, length + extra)
elif zeros and (i, to) in erased and (i, to) not in leave:
print(i, to, MAX_WEIGHT)
else:
print(i, to, length)
graph_with_0 = defaultdict(list)
graph_with_max = defaultdict(list)
n, m, L, s, t = map(int, input().split(' '))
erased = set()
for _ in range(m):
u, v, l = map(int, input().split(' '))
if l == 0:
graph_with_0[u].append((v, 1))
graph_with_0[v].append((u, 1))
graph_with_max[u].append((v, MAX_WEIGHT))
graph_with_max[v].append((u, MAX_WEIGHT))
erased |= {(u, v), (v, u)}
else:
graph_with_0[u].append((v, l))
graph_with_0[v].append((u, l))
graph_with_max[u].append((v, l))
graph_with_max[v].append((u, l))
a1, d1 = compute_path(graph_with_0, s, n)
a2, d2 = compute_path(graph_with_max, s, n)
if d2[t] < L:
print('NO')
elif d2[t] == L:
print('YES')
output(graph_with_max, n+1, n+1, 0, n, False, erased, set())
elif d1[t] <= L:
print('YES')
v = t
leave = set()
while v != s:
leave |= {(v, a1[v]), (a1[v], v)}
if d2[v] > L:
c, d = max(v, a1[v]), min(v, a1[v])
v = a1[v]
output(graph_with_0, c, d, L - d1[t], n, True, erased, leave)
else:
print('NO')
```
No
| 13,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
import math
def isPrime(n):
a=math.sqrt(n)
i=2
while i<=a:
if n%i==0:
return False
i+=1
return True
n=int(input())
if isPrime(n):
print(1)
else:
if n%2==0:
print(2)
else:
if isPrime(n-2):
print(2)
else:
print(3)
```
| 13,772 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
import math,sys,bisect,heapq,os
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
from functools import lru_cache
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
def input(): return sys.stdin.readline().rstrip('\r\n')
#input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
aj = lambda: list(map(int, input().split()))
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
def solve():
def isprime(n):
n = abs(int(n))
if n < 2:
return False
if n == 2:
return True
if not n & 1:
return False
for x in range(3, int(n**0.5) + 1, 2):
if n % x == 0:
return False
return True
n, = aj()
if isprime(n):
print(1)
elif isprime(n-2):
print(2)
elif n%2 == 0:
print(2)
else:
print(3)
try:
#os.system("online_judge.py")
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
solve()
```
| 13,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
def isPrime(n):
if (n <= 1):
return False
if (n <= 3):
return True
if (n % 2 == 0 or n % 3 == 0):
return False
i = 5
while (i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
n=int(input())
print("1") if isPrime(n) else print("2") if n%2==0 else print("2") if isPrime(n-2) else print("3")
```
| 13,774 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
def isPrime(num):
if num <= 1:
return False
if num <= 3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
i = 5
while i * i <= num:
if num % i == 0 or num % (i+2) == 0:
return False
i += 6
return True
n = int(input())
if isPrime(n):
print(1)
elif n + 1 & 1:
print(2)
elif isPrime(n - 2):
print(2)
else:
print(3)
```
| 13,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Π€ΡΠ½ΠΊΡΠΈΡ Π²ΡΡΠΈΡΠ»ΡΠ΅Ρ, ΠΏΡΠΎΡΡΠΎΠ΅ Π»ΠΈ ΡΠΈΡΠ»ΠΎ n>=2
# 1 ΡΡΠΈΡΠ°Π΅ΡΡΡ ΠΏΡΠΎΡΡΡΠΌ
def isPrime(n):
if (n==2)|(n==3):
return True
elif (n%2==0)|(n%3==0):
return False
else:
nsq=int(n**0.5)+1
for k in range(3,nsq,2):
if n%k==0:
return False
return True
n=int(input())
if isPrime(n):
print(1)
elif isPrime(n-2):
print(2)
elif n%2==0:
print(2)
else:
print (3)
```
| 13,776 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
S1 = 'abcdefghijklmnopqrstuvwxyz'
S2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
n = iinp()
if isprime(n):
print(1)
elif n%2==0:
print(2)
else:
if isprime(n-2):
print(2)
else:
print(3)
```
| 13,777 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
from math import sqrt
def prime(n):
for d in range(3, int(sqrt(n)) + 1, 2):
if n % d == 0:
return 0
return 1
n = int(input())
if n == 2:
print(1)
elif n % 2 == 0:
print(2)
elif prime(n):
print(1)
elif prime(n - 2):
print(2)
else:
print(3)
```
| 13,778 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Tags: math, number theory
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
import time
start_time = time.time()
import collections
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
"""
If prime: 1
Elif even: 2
Elif odd: 3
"""
def is_prime(n):
for j in range(2,int(n**0.5)+1):
if n % j == 0:
return False
return True
def solve():
N = getInt()
if is_prime(N):
return 1
if N % 2 == 0:
return 2
if is_prime(N-2):
return 2
return 3
print(solve())
```
| 13,779 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def isprime(x):
for i in range(2,int(x**0.5)+1):
if x%i==0:
return False
return True
n=int(input())
if isprime(n):
print(1)
elif n%2==0:
print(2)
else:
if isprime(n-2):
print(2)
else:
print(3)
```
Yes
| 13,780 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def is_prime(n):
for i in range(2, int(n ** 0.5 + 1)):
if n % i == 0:
return False
return True
n = int(input())
if n % 2 == 0:
if is_prime(n):
print(1)
else:
print(2)
else:
if is_prime(n):
print(1)
elif is_prime(n - 2):
print(2)
else:
print(3)
```
Yes
| 13,781 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
n = int(input())
if n == 2:
print(1)
elif n % 2 == 0:
print(2)
else:
i = 2
flag = True
while i * i <= n:
if n % i == 0:
flag = False
break
i +=1
if flag:
print(1)
else:
i = 2
flag = True
while i * i <= n - 2:
if (n - 2) % i == 0:
flag = False
break
i += 1
if flag:
print(2)
else:
print(3)
```
Yes
| 13,782 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
mark = []
p = [1]
import math
def isPrime(n):
batas_atas = int(n ** 0.5)
for i in range(2, batas_atas+1):
if n % i == 0:
return False
return True
def gen_prime(upto):
for i in range(upto+1):
mark.append(True)
for i in range(2, upto+1):
if(mark[i]):
p.append(i)
for j in range(i,upto+1,i):
mark[j] = False
ans = 0
def cari_prima_terdekat(n):
global ans
#print(n)
if(n > 0):
for i in range(n,0,-1):
if(isPrime(i)):
ans += 1
print(i)
cari_prima_terdekat(n - i)
break
n = int(input())
if(isPrime(n)):
print(1)
elif(n % 2 == 0):
print(2)
elif(isPrime(n-2)):
print(2)
else:
print(3)
```
Yes
| 13,783 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
from math import sqrt
def getPrimeFactors(n):
factors = []
while n % 2 == 0:
factors.append(2)
n >>= 1
for i in range(3, int(sqrt(n)) + 1):
while n % i == 0:
factors.append(i)
n = n // i
if n > 2:
factors.append(n)
return factors
n = int(input())
print(len(getPrimeFactors(n)))
```
No
| 13,784 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def isprime(n):
if pow(2, n, n) == 2:
return True
else:
return False
n = int(input())
if n > 5 and n % 2:
if isprime(n):
print(1)
elif isprime(n-2):
print(2)
else:
print(3)
elif n > 2 and not n % 2:
print(2)
elif n in (2, 3, 5):
print(1)
```
No
| 13,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
from math import sqrt
def prime_check(n):
flag=1
for i in range(3,int(sqrt(n))+2,2):
if (n%i==0):
flag=0
break
return (flag)
n=int(input())
arr=[0,0,1,1,2,1,2,1,2,3,2]
if (n<=10):
print (arr[n])
else:
if (n%2==0):
print (2)
else:
if (prime_check(n)):
print (1)
elif (prime_check(n-2)):
print (2)
else:
print (3)
```
No
| 13,786 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Mr. Funt now lives in a country with a very specific tax laws. The total income of mr. Funt during this year is equal to n (n β₯ 2) burles and the amount of tax he has to pay is calculated as the maximum divisor of n (not equal to n, of course). For example, if n = 6 then Funt has to pay 3 burles, while for n = 25 he needs to pay 5 and if n = 2 he pays only 1 burle.
As mr. Funt is a very opportunistic person he wants to cheat a bit. In particular, he wants to split the initial n in several parts n1 + n2 + ... + nk = n (here k is arbitrary, even k = 1 is allowed) and pay the taxes for each part separately. He can't make some part equal to 1 because it will reveal him. So, the condition ni β₯ 2 should hold for all i from 1 to k.
Ostap Bender wonders, how many money Funt has to pay (i.e. minimal) if he chooses and optimal way to split n in parts.
Input
The first line of the input contains a single integer n (2 β€ n β€ 2Β·109) β the total year income of mr. Funt.
Output
Print one integer β minimum possible number of burles that mr. Funt has to pay as a tax.
Examples
Input
4
Output
2
Input
27
Output
3
Submitted Solution:
```
def isPrime(n):
if (n <= 1):
return False
if (n <= 3):
return True
if (n % 2 == 0 or n % 3 == 0):
return False
i = 5
while (i * i <= n):
if (n % i == 0 or n % (i + 2) == 0):
return False
i = i + 6
return True
n=int(input())
print("1") if isPrime(n) else print("2") if n%2==0 else print("3")
```
No
| 13,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def prepare(n, *a):
acc = 0
sub_max = -10**9
left_min = 0
left_max = 0
lmin2, lmax2 = 0, -10**9
for i, x in enumerate(a):
acc += x
sub_max = max(sub_max, acc - left_min)
left_min = min(left_min, acc)
left_max = max(left_max, acc)
if i > 0:
lmax2 = max(lmax2, acc)
if i < n - 1:
lmin2 = min(lmin2, acc)
return left_min, left_max, acc, sub_max, lmin2, lmax2
n, m = map(int, input().split())
small_a = [(0, 0, 0, 0, 0, 0)]
for _ in range(n):
small_a.append(prepare(*map(int, input().split())))
indexes = tuple(map(int, input().split()))
left_min, _, acc, ans, left_min2, _ = small_a[indexes[0]]
for i in indexes[1:]:
ans = max(
ans,
small_a[i][3],
acc + small_a[i][1] - left_min2,
acc + small_a[i][5] - left_min
)
left_min2 = min(left_min, acc + small_a[i][4])
left_min = min(left_min, acc + small_a[i][0])
acc += small_a[i][2]
print(ans)
```
| 13,788 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
if __name__ == "__main__":
i = input().split()
N = int(i[0])
M = int(i[1])
arrList = []
leftMax = []
rightMax = []
listTotal = []
rightSum = []
for i in range(N):
inputList = [int(x) for x in input().split()]
list = inputList[1:inputList[0] + 1]
listTotal.append(0)
leftMax.append(-999999)
rightMax.append(-999999)
rightSum.append(-999999)
rightIter = 0
for j in list:
listTotal[i] += j
rightIter += j
leftMax[i] = max(leftMax[i], listTotal[i])
rightSum[i] = max(rightSum[i], rightIter)
rightIter = 0 if rightIter < 0 else rightIter
rightMax[i] = rightIter
arrList.append(list)
idxOrder = [int(x) for x in input().split()][0:M]
maxSum = -99999999
currMax = 0
for i in idxOrder:
bestTot = max(maxSum, rightSum[i - 1])
bestSum = max(currMax + leftMax[i - 1], currMax + listTotal[i - 1])
maxSum = max(bestSum, bestTot)
currMax = max(currMax + listTotal[i - 1], rightMax[i - 1])
print(maxSum)
```
| 13,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a=[]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,su,su1=-1001,-1001,0,0
for j in range(1,len(b)):
su,su1=su+b[j],su1+b[-j]
pma=max(pma,su)
sma=max(sma,su1)
su,ma=0,max(b[1:])
for j in range(1,len(b)):
su=su+b[j]
ma=max(ma,su)
if su<0:
su=0
a.append((pma,ma,sma,su1))
ans=[-1001,-1001,-1001,0]
for i in input().split():
z=a[int(i)-1]
ans[0]=max(ans[0],ans[3]+z[0])
ans[1]=max(ans[1],ans[2]+z[0],z[1])
ans[2]=max(z[2],z[3]+ans[2])
ans[3]+=z[3]
print(max(ans))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 13,790 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a,ans=[],[-1001,-1001,-1001,0]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,ma,su,su1,su2=-1001,-1001,-1001,0,0,0
for j in range(1,len(b)):
su,su1,su2=su+b[j],su1+b[-j],su2+b[j]
ma,pma,sma=max(ma,su2),max(pma,su),max(sma,su1)
su2=su2*(su2>0)
a.append((pma,ma,sma,su1))
for i in input().split():
z=a[int(i)-1]
ans=[max(ans[0],ans[3]+z[0]),max(ans[1],ans[2]+z[0],z[1]),max(z[2],z[3]+ans[2]),ans[3]+z[3]]
print(max(ans))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 13,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
n,m=map(int,input().split())
l=[]
d={}
e={}
for i in range(n):
l = list(map(int,input().split()))
a=l[1]
b=sum(l)-l[0]
c=l[-1]
x = l[1]
for j in range(2,len(l)):
x+=l[j]
a=max(a,x)
x = l[-1]
for j in range(len(l)-2,0,-1):
x+=l[j]
c=max(c,x)
d[i+1] = [a,b,c]
a=l[1]
b=0
for j in range(1,len(l)):
b+=l[j]
a=max(a,b)
if b<0:
b=0
e[i+1]=a
dp = [[0,0,0] for i in range(m)]
l=list(map(int,input().split()))
ans = 0
for i in range(m-1,-1,-1):
if i==m-1:
dp[i][0] = d[l[i]][0]
dp[i][1] =d[l[i]][1]
dp[i][2] = d[l[i]][2]
ans = max(max(dp[i][1],dp[i][0]),dp[i][2])
ans=max(ans,e[l[i]])
else:
dp[i][0] = d[l[i]][0]
dp[i][1] = d[l[i]][1] + max(max(0,dp[i+1][0]),dp[i+1][1])
dp[i][2] = d[l[i]][2] + max(max(0,dp[i+1][0]),dp[i+1][1])
ans=max(ans,dp[i][0])
ans=max(ans,dp[i][1])
ans=max(ans,dp[i][2])
ans=max(ans,e[l[i]])
print(ans)
```
| 13,792 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
import sys
zz=1
sys.setrecursionlimit(10**5)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def fori(n):
return [fi() for i in range(n)]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def ii():
return input().rstrip()
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def comp(a,b):
if(a>b):
return 2
return 2 if a==b else 0
def gi():
return [xx for xx in input().split()]
def gtc(tc,ans):
print("Case #"+str(tc)+":",ans)
def cil(n,m):
return n//m+int(n%m>0)
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j,n,m):
return 0<=i<n and 0<=j<m
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=1
uu=t
while t>0:
t-=1
n,m=mi()
pm=[0]*n
sm=[0]*n
s=[0]*n
ans=[0]*n
for i in range(n):
a=li()
p=a[0]
a=a[1:]
maxi=-10**18;c=0
for j in range(p-1,-1,-1):
c+=a[j]
maxi=max(maxi,c)
sm[i]=maxi
s[i]=c
maxi=-10**18;c=0
for j in range(p):
c+=a[j]
maxi=max(maxi,c)
pm[i]=maxi
c=0;maxi=-10**18
for j in a:
if j>c+j:
c=j
else:
c+=j
maxi=max(maxi,c)
ans[i]=maxi
b=li()
maxi=-10**18;c=0
for i in b:
maxi=max([maxi,c+pm[i-1],ans[i-1]])
if sm[i-1]>c+s[i-1]:
c=sm[i-1]
else:
c+=s[i-1]
maxi=max(maxi,c)
if c<0:
c=0
print(maxi)
```
| 13,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
def get_best(arr):
ans, now = -(1 << 64), 0
for i in arr:
now += i
ans = max(ans, now)
if (now < 0): now = 0
return ans
def compute(arr):
ans, now = -(1 << 64), 0
for i in arr:
now += i
ans = max(ans, now)
return ans
n, m = map(int, input().split())
vals = []
suffix, prefix, summation, best = [0] * n, [0] * n, [0] * n, [0] * n
for i in range(n):
arr = list(map(int, input().split()))[1:]
summation[i] = sum(arr)
suffix[i] = compute(list(reversed(arr)))
prefix[i] = compute(arr)
best[i] = get_best(arr)
vals.append(arr)
idx = list(map(lambda x: int(x) - 1, input().split()))
f = [[0 for x in range(m + 1)] for p in range(2)]
f[0][m] = -(1 << 64)
i = m - 1
while i >= 0:
cur = idx[i]
f[0][i] = max(max(f[0][i + 1], best[cur]), suffix[cur] + f[1][i + 1])
f[1][i] = max(prefix[cur], summation[cur] + f[1][i + 1])
i -= 1
print(f[0][0])
```
| 13,794 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Tags: data structures, dp, greedy, implementation, math, trees
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
def main():
n,m=map(int,input().split())
a,ans=[],[-1001,-1001,-1001,0]
for i in range(n):
b=list(map(int,input().split()))
pma,sma,ma,su,su1,su2=-1001,-1001,-1001,0,0,0
for j in range(1,len(b)):
su,su1=su+b[j],su1+b[-j]
pma,sma=max(pma,su),max(sma,su1)
for j in range(1,len(b)):
su2=su2+b[j]
ma=max(ma,su2)
su2=su2*(su2>0)
a.append((pma,ma,sma,su1))
for i in input().split():
z=a[int(i)-1]
ans=[max(ans[0],ans[3]+z[0]),max(ans[1],ans[2]+z[0],z[1]),max(z[2],z[3]+ans[2]),ans[3]+z[3]]
print(max(ans))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 13,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
if __name__ == "__main__":
i = input().split()
N = int(i[0])
M = int(i[1])
arrList = []
for i in range(N):
list = [int(x) for x in input().split()]
arrList.append(list[1:])
idxOrder = [int(x) for x in input().split()][0:M]
maxSum = 0
currMax = 0
for i in idxOrder:
for j in arrList[i - 1]:
currMax = max(j, currMax + j)
maxSum = max(currMax, maxSum)
print(1)
```
No
| 13,796 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = [int(k) for k in input().split()][1:]
indices = [int(k) for k in input().split()]
x = 1
for i in range(len(indices)):
for val in d[indices[i]]:
if not dp:
dp.append(val)
else:
dp.append(max(val + dp[x - 1], val))
x += 1
res = max(res, dp[-1])
print(res)
main()
```
No
| 13,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = input().split()[1:]
indices = input().split()
for i in range(len(indices)):
if int(indices[i]) in d:
for val in d[int(indices[i])]:
val = int(val)
if not dp:
dp.append(val)
x = 1
else:
dp.append(max(val + dp[x - 1], val))
x += 1
res = max(res, dp[-1])
print(res)
main()
```
No
| 13,798 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ahmed and Mostafa used to compete together in many programming contests for several years. Their coach Fegla asked them to solve one challenging problem, of course Ahmed was able to solve it but Mostafa couldn't.
This problem is similar to a standard problem but it has a different format and constraints.
In the standard problem you are given an array of integers, and you have to find one or more consecutive elements in this array where their sum is the maximum possible sum.
But in this problem you are given n small arrays, and you will create one big array from the concatenation of one or more instances of the small arrays (each small array could occur more than once). The big array will be given as an array of indexes (1-based) of the small arrays, and the concatenation should be done in the same order as in this array. Then you should apply the standard problem mentioned above on the resulting big array.
For example let's suppose that the small arrays are {1, 6, -2}, {3, 3} and {-5, 1}. And the indexes in the big array are {2, 3, 1, 3}. So the actual values in the big array after formatting it as concatenation of the small arrays will be {3, 3, -5, 1, 1, 6, -2, -5, 1}. In this example the maximum sum is 9.
Can you help Mostafa solve this problem?
Input
The first line contains two integers n and m, n is the number of the small arrays (1 β€ n β€ 50), and m is the number of indexes in the big array (1 β€ m β€ 250000). Then follow n lines, the i-th line starts with one integer l which is the size of the i-th array (1 β€ l β€ 5000), followed by l integers each one will be greater than or equal -1000 and less than or equal 1000. The last line contains m integers which are the indexes in the big array, and you should concatenate the small arrays in the same order, and each index will be greater than or equal to 1 and less than or equal to n.
The small arrays are numbered from 1 to n in the same order as given in the input. Some of the given small arrays may not be used in big array.
Note, that the array is very big. So if you try to build it straightforwardly, you will probably get time or/and memory limit exceeded.
Output
Print one line containing the maximum sum in the big array after formatting it as described above. You must choose at least one element for the sum, i. e. it cannot be empty.
Please, do not use %lld specificator to write 64-bit integers in C++. It is preferred to use cout (also you may use %I64d).
Examples
Input
3 4
3 1 6 -2
2 3 3
2 -5 1
2 3 1 3
Output
9
Input
6 1
4 0 8 -3 -10
8 3 -2 -5 10 8 -9 -5 -4
1 0
1 -3
3 -8 5 6
2 9 6
1
Output
8
Submitted Solution:
```
def main():
n, m = map(int, input().split())
d = {}
dp = []
res = 0
for i in range(1, n + 1):
d[i] = [int(k) for k in input().split()][1:]
indices = [int(k) for k in input().split()]
if not indices:
return 0
setup = d[indices[0]]
dp.append(setup[0])
x = 1
for i in range(1, len(setup)):
res = max(res, dp[-1])
dp.append(max(setup[i] + dp[x - 1], setup[i]))
x += 1
for i in range(1, len(indices)):
for val in d[indices[i]]:
res = max(res, dp[-1])
dp.append(max(val + dp[x - 1], val))
x += 1
print(res)
main()
```
No
| 13,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.